@ontos-ai/knowhere-sdk 2.6.0 → 2.6.1-beta.20261027152313

package/dist/{chunk-R2NKBUNB.mjs → chunk-DIONXJWK.mjs}

@@ -770,15 +770,17 @@ function readObjectVersion(object) {
   return { entityTag: object.entityTag, contentLength: object.contentLength };
 }
 function validateCachedResponse(response, marker, signal) {
-  if (response.headers.get("etag") !== marker.storageEntityTag)
+  if (response.status !== 206 || !response.body)
     rejectResponse(
       response,
-      new ArchiveCacheTransportError("Parsed result archive cache response version changed.")
+      new ArchiveCacheTransportError(
+        `Parsed result archive cache requires a ranged response (HTTP ${response.status}).`
+      )
     );
-  if (response.status !== 206 || !response.body)
+  if (response.headers.get("etag") !== marker.storageEntityTag)
     rejectResponse(
       response,
-      new ArchiveCacheTransportError("Parsed result archive cache requires a ranged response.")
+      new ArchiveCacheTransportError("Parsed result archive cache response version changed.")
     );
   const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(
     response.headers.get("content-range") ?? ""
@@ -845,7 +847,10 @@ function isPositiveInteger(value) {
 }
 
 // src/storage/streamed-parsed-document-sync.ts
-import { HttpRangeReader, ZipReader } from "@zip.js/zip.js";
+import {
+  HttpRangeReader,
+  ZipReader
+} from "@zip.js/zip.js";
 async function syncRemoteResultArchive(params) {
   params.signal?.throwIfAborted();
   validateArchiveSyncLimits(params.limits);
@@ -856,10 +861,14 @@ async function syncRemoteResultArchive(params) {
   const checkpointIntervalMs = params.limits?.checkpointIntervalMs ?? 2e3;
   const controller = new AbortController();
   const signal = params.signal ? AbortSignal.any([params.signal, controller.signal]) : controller.signal;
-  const transferParams = { ...params, signal };
+  const openingParams = { ...params, signal };
   const previous = await params.storage.readSyncProgress(params);
-  const openedSource = await openArchive(transferParams, previous);
+  const openedSource = await openArchive(openingParams, previous);
   const source = !openedSource.canSkipEntries && previous?.archiveIdentity && previous.archiveDownloadIdentity === openedSource.downloadIdentity ? { ...openedSource, identity: previous.archiveIdentity } : openedSource;
+  const transferParams = {
+    ...openingParams,
+    signal: source.signal ?? signal
+  };
   const archiveDownloadIdentity = source.isCached ? source.downloadIdentity : previous?.archiveDownloadIdentity;
   const concurrency = source.canSkipEntries ? params.limits?.maxConcurrentFiles ?? 1 : 1;
   const nextEntry = previous?.status === "completed" ? 0 : previous?.nextArchiveEntry ?? 0;
@@ -1112,6 +1121,50 @@ async function persistArchiveCacheBypass(params, previous) {
   await params.storage.writeSyncProgress(progress, { signal: params.signal });
   return progress;
 }
+var AbortableHttpRangeReader = class extends HttpRangeReader {
+  constructor(url, options, controller) {
+    super(url, options);
+    this.controller = controller;
+  }
+  controller;
+  createReadable(options) {
+    const reader = super.createReadable(options).getReader();
+    const cancellation = this.controller;
+    return new ReadableStream(
+      {
+        async pull(output) {
+          try {
+            const chunk = await reader.read();
+            if (chunk.done) {
+              reader.releaseLock();
+              output.close();
+            } else output.enqueue(chunk.value);
+          } catch (error) {
+            cancellation.abort(error);
+            reader.releaseLock();
+            output.error(error);
+          }
+        },
+        async cancel(reason) {
+          try {
+            await reader.cancel(reason);
+          } finally {
+            reader.releaseLock();
+          }
+        }
+      },
+      { highWaterMark: 0 }
+    );
+  }
+  async readUint8Array(index, length) {
+    try {
+      return await super.readUint8Array(index, length);
+    } catch (error) {
+      this.controller.abort(error);
+      throw error;
+    }
+  }
+};
 async function openArchiveTransport(params, previous, prepared) {
   const resultUrl = prepared?.resultUrl ?? params.resultUrl;
   const archiveCacheBypassed = prepared?.archiveCacheBypassed ?? previous?.archiveCacheBypassed;
@@ -1128,7 +1181,7 @@ async function openArchiveTransport(params, previous, prepared) {
   const supportsRange = probe.status === 206 && probe.headers.has("content-range");
   await probe.body?.cancel();
   if (!supportsRange) {
-    const { openSequentialArchive } = await import("./sequential-parsed-document-archive-STRFJHEB.mjs");
+    const { openSequentialArchive } = await import("./sequential-parsed-document-archive-W7HPYIKA.mjs");
     const source = await openSequentialArchive(
       { ...params, resultUrl },
       identity,
@@ -1136,32 +1189,43 @@ async function openArchiveTransport(params, previous, prepared) {
     );
     return { ...source, archiveCacheBypassed };
   }
+  const rangeController = new AbortController();
+  const rangeSignal = params.signal ? AbortSignal.any([params.signal, rangeController.signal]) : rangeController.signal;
   const options = {
     forceRangeRequests: true,
     preventHeadRequest: true,
     // Cached reads already pin a strong ETag and exact lengths; CDN timestamps can drift.
     checkResourceChanges: !prepared?.isCached,
     fetch: async (input, init) => {
-      let response;
       try {
-        response = await fetch(input, { ...init, signal: params.signal });
-      } catch (error) {
-        params.signal?.throwIfAborted();
-        if (prepared?.isCached)
-          throw new ArchiveCacheTransportError(
-            "Parsed result archive cache transport unavailable."
+        let response;
+        try {
+          response = await fetch(input, { ...init, signal: rangeSignal });
+        } catch (error) {
+          rangeSignal.throwIfAborted();
+          if (prepared?.isCached)
+            throw new ArchiveCacheTransportError(
+              "Parsed result archive cache transport unavailable."
+            );
+          throw error;
+        }
+        if (prepared?.isCached) return prepared.validateResponse(response);
+        if (response.status !== 206) {
+          const error = new Error(
+            `Parsed result Range request failed (HTTP ${response.status}).`
           );
+          rangeController.abort(error);
+          await response.body?.cancel(error).catch(() => void 0);
+          throw error;
+        }
+        return prepared ? prepared.validateResponse(response) : response;
+      } catch (error) {
+        rangeController.abort(error);
         throw error;
       }
-      if (prepared?.isCached) return prepared.validateResponse(response);
-      if (response.status !== 206) {
-        await response.body?.cancel();
-        throw new Error(`Parsed result Range request failed (HTTP ${response.status}).`);
-      }
-      return prepared ? prepared.validateResponse(response) : response;
     }
   };
-  const reader = new ZipReader(new HttpRangeReader(resultUrl, options), {
+  const reader = new ZipReader(new AbortableHttpRangeReader(resultUrl, options, rangeController), {
     useWebWorkers: false,
     checkCrc32: true
   });
@@ -1177,6 +1241,7 @@ async function openArchiveTransport(params, previous, prepared) {
       )
     ).digest("hex");
     return {
+      signal: rangeSignal,
       identity: previous?.archiveIdentity === identity ? identity : archiveIdentity,
       downloadIdentity: identity,
       archiveCacheBypassed,
@@ -1189,7 +1254,7 @@ async function openArchiveTransport(params, previous, prepared) {
             path: normalizeResultPath(entry.filename),
             contentLength: entry.uncompressedSize,
             read: () => {
-              entryRead = readRangeEntry(entry, params.signal, producers);
+              entryRead = readRangeEntry(entry, rangeSignal, producers);
               return entryRead.body;
             },
             waitForRead: () => entryRead?.completed ?? Promise.resolve()
@@ -1202,6 +1267,7 @@ async function openArchiveTransport(params, previous, prepared) {
       }
     };
   } catch (error) {
+    rangeController.abort(error);
     await reader.close();
     throw error;
   }
@@ -1213,10 +1279,16 @@ function readRangeEntry(entry, signal, producers) {
       streamController = controller;
     }
   });
+  const cancelOutput = () => {
+    streamController?.error(signal?.reason);
+  };
+  signal?.addEventListener("abort", cancelOutput, { once: true });
+  if (signal?.aborted) cancelOutput();
   const completed = entry.getData(stream.writable, { signal, checkCrc32: true, useWebWorkers: false }).then(() => void 0);
   const producer = completed.catch((error) => {
     streamController?.error(error);
   }).finally(() => {
+    signal?.removeEventListener("abort", cancelOutput);
     producers.delete(producer);
   });
   producers.add(producer);

package/dist/index.js

@@ -856,15 +856,17 @@ function readObjectVersion(object) {
   return { entityTag: object.entityTag, contentLength: object.contentLength };
 }
 function validateCachedResponse(response, marker, signal) {
-  if (response.headers.get("etag") !== marker.storageEntityTag)
+  if (response.status !== 206 || !response.body)
     rejectResponse(
       response,
-      new ArchiveCacheTransportError("Parsed result archive cache response version changed.")
+      new ArchiveCacheTransportError(
+        `Parsed result archive cache requires a ranged response (HTTP ${response.status}).`
+      )
     );
-  if (response.status !== 206 || !response.body)
+  if (response.headers.get("etag") !== marker.storageEntityTag)
     rejectResponse(
       response,
-      new ArchiveCacheTransportError("Parsed result archive cache requires a ranged response.")
+      new ArchiveCacheTransportError("Parsed result archive cache response version changed.")
     );
   const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(
     response.headers.get("content-range") ?? ""
@@ -1099,10 +1101,14 @@ async function syncRemoteResultArchive(params) {
   const checkpointIntervalMs = params.limits?.checkpointIntervalMs ?? 2e3;
   const controller = new AbortController();
   const signal = params.signal ? AbortSignal.any([params.signal, controller.signal]) : controller.signal;
-  const transferParams = { ...params, signal };
+  const openingParams = { ...params, signal };
   const previous = await params.storage.readSyncProgress(params);
-  const openedSource = await openArchive(transferParams, previous);
+  const openedSource = await openArchive(openingParams, previous);
   const source = !openedSource.canSkipEntries && previous?.archiveIdentity && previous.archiveDownloadIdentity === openedSource.downloadIdentity ? { ...openedSource, identity: previous.archiveIdentity } : openedSource;
+  const transferParams = {
+    ...openingParams,
+    signal: source.signal ?? signal
+  };
   const archiveDownloadIdentity = source.isCached ? source.downloadIdentity : previous?.archiveDownloadIdentity;
   const concurrency = source.canSkipEntries ? params.limits?.maxConcurrentFiles ?? 1 : 1;
   const nextEntry = previous?.status === "completed" ? 0 : previous?.nextArchiveEntry ?? 0;
@@ -1379,32 +1385,43 @@ async function openArchiveTransport(params, previous, prepared) {
     );
     return { ...source, archiveCacheBypassed };
   }
+  const rangeController = new AbortController();
+  const rangeSignal = params.signal ? AbortSignal.any([params.signal, rangeController.signal]) : rangeController.signal;
   const options = {
     forceRangeRequests: true,
     preventHeadRequest: true,
     // Cached reads already pin a strong ETag and exact lengths; CDN timestamps can drift.
     checkResourceChanges: !prepared?.isCached,
     fetch: async (input, init) => {
-      let response;
       try {
-        response = await fetch(input, { ...init, signal: params.signal });
-      } catch (error) {
-        params.signal?.throwIfAborted();
-        if (prepared?.isCached)
-          throw new ArchiveCacheTransportError(
-            "Parsed result archive cache transport unavailable."
+        let response;
+        try {
+          response = await fetch(input, { ...init, signal: rangeSignal });
+        } catch (error) {
+          rangeSignal.throwIfAborted();
+          if (prepared?.isCached)
+            throw new ArchiveCacheTransportError(
+              "Parsed result archive cache transport unavailable."
+            );
+          throw error;
+        }
+        if (prepared?.isCached) return prepared.validateResponse(response);
+        if (response.status !== 206) {
+          const error = new Error(
+            `Parsed result Range request failed (HTTP ${response.status}).`
           );
+          rangeController.abort(error);
+          await response.body?.cancel(error).catch(() => void 0);
+          throw error;
+        }
+        return prepared ? prepared.validateResponse(response) : response;
+      } catch (error) {
+        rangeController.abort(error);
         throw error;
       }
-      if (prepared?.isCached) return prepared.validateResponse(response);
-      if (response.status !== 206) {
-        await response.body?.cancel();
-        throw new Error(`Parsed result Range request failed (HTTP ${response.status}).`);
-      }
-      return prepared ? prepared.validateResponse(response) : response;
     }
   };
-  const reader = new import_zip2.ZipReader(new import_zip2.HttpRangeReader(resultUrl, options), {
+  const reader = new import_zip2.ZipReader(new AbortableHttpRangeReader(resultUrl, options, rangeController), {
     useWebWorkers: false,
     checkCrc32: true
   });
@@ -1420,6 +1437,7 @@ async function openArchiveTransport(params, previous, prepared) {
       )
     ).digest("hex");
     return {
+      signal: rangeSignal,
       identity: previous?.archiveIdentity === identity ? identity : archiveIdentity,
       downloadIdentity: identity,
       archiveCacheBypassed,
@@ -1432,7 +1450,7 @@ async function openArchiveTransport(params, previous, prepared) {
             path: normalizeResultPath(entry.filename),
             contentLength: entry.uncompressedSize,
             read: () => {
-              entryRead = readRangeEntry(entry, params.signal, producers);
+              entryRead = readRangeEntry(entry, rangeSignal, producers);
               return entryRead.body;
             },
             waitForRead: () => entryRead?.completed ?? Promise.resolve()
@@ -1445,6 +1463,7 @@ async function openArchiveTransport(params, previous, prepared) {
       }
     };
   } catch (error) {
+    rangeController.abort(error);
     await reader.close();
     throw error;
   }
@@ -1456,10 +1475,16 @@ function readRangeEntry(entry, signal, producers) {
       streamController = controller;
     }
   });
+  const cancelOutput = () => {
+    streamController?.error(signal?.reason);
+  };
+  signal?.addEventListener("abort", cancelOutput, { once: true });
+  if (signal?.aborted) cancelOutput();
   const completed = entry.getData(stream.writable, { signal, checkCrc32: true, useWebWorkers: false }).then(() => void 0);
   const producer = completed.catch((error) => {
     streamController?.error(error);
   }).finally(() => {
+    signal?.removeEventListener("abort", cancelOutput);
     producers.delete(producer);
   });
   producers.add(producer);
@@ -1554,7 +1579,7 @@ function createDownloadIdentity(jobId, response) {
     ])
   ).digest("hex");
 }
-var import_crypto2, import_zip2;
+var import_crypto2, import_zip2, AbortableHttpRangeReader;
 var init_streamed_parsed_document_sync = __esm({
   "src/storage/streamed-parsed-document-sync.ts"() {
     "use strict";
@@ -1564,6 +1589,50 @@ var init_streamed_parsed_document_sync = __esm({
     init_parsed_document_archive_cache();
     import_zip2 = require("@zip.js/zip.js");
     init_parsed_document_storage();
+    AbortableHttpRangeReader = class extends import_zip2.HttpRangeReader {
+      constructor(url, options, controller) {
+        super(url, options);
+        this.controller = controller;
+      }
+      controller;
+      createReadable(options) {
+        const reader = super.createReadable(options).getReader();
+        const cancellation = this.controller;
+        return new ReadableStream(
+          {
+            async pull(output) {
+              try {
+                const chunk = await reader.read();
+                if (chunk.done) {
+                  reader.releaseLock();
+                  output.close();
+                } else output.enqueue(chunk.value);
+              } catch (error) {
+                cancellation.abort(error);
+                reader.releaseLock();
+                output.error(error);
+              }
+            },
+            async cancel(reason) {
+              try {
+                await reader.cancel(reason);
+              } finally {
+                reader.releaseLock();
+              }
+            }
+          },
+          { highWaterMark: 0 }
+        );
+      }
+      async readUint8Array(index, length) {
+        try {
+          return await super.readUint8Array(index, length);
+        } catch (error) {
+          this.controller.abort(error);
+          throw error;
+        }
+      }
+    };
   }
 });
 

package/dist/index.mjs

@@ -47,7 +47,7 @@ import {
   syncParseResultToParsedDocumentStorage,
   syncRemoteResultArchive,
   validateArchiveSyncLimits
-} from "./chunk-R2NKBUNB.mjs";
+} from "./chunk-DIONXJWK.mjs";
 
 // src/client.ts
 import path2 from "path";

package/dist/{sequential-parsed-document-archive-STRFJHEB.mjs → sequential-parsed-document-archive-W7HPYIKA.mjs}

@@ -3,7 +3,7 @@ import {
   createDownloadIdentity,
   isSnapshotPath,
   normalizeResultPath
-} from "./chunk-R2NKBUNB.mjs";
+} from "./chunk-DIONXJWK.mjs";
 
 // src/storage/sequential-parsed-document-archive.ts
 import { Readable, Transform } from "stream";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ontos-ai/knowhere-sdk",
-  "version": "2.6.0",
+  "version": "2.6.1-beta.20261027152313",
   "description": "Official Node.js SDK for Knowhere document parsing API",
   "keywords": [
     "knowhere",