@ontos-ai/knowhere-sdk 2.4.1 → 2.5.0

package/dist/chunk-4PWLXJGH.mjs

@@ -0,0 +1,719 @@
+// src/errors/base.ts
+var KnowhereError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KnowhereError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NetworkError = class extends KnowhereError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "NetworkError";
+  }
+  cause;
+};
+var TimeoutError = class extends NetworkError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var PollingTimeoutError = class extends KnowhereError {
+  constructor(message = "Polling timed out", elapsedMs) {
+    super(message);
+    this.elapsedMs = elapsedMs;
+    this.name = "PollingTimeoutError";
+  }
+  elapsedMs;
+};
+var ChecksumError = class extends KnowhereError {
+  constructor(message = "Checksum verification failed", expected, actual) {
+    super(message);
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "ChecksumError";
+  }
+  expected;
+  actual;
+};
+var ValidationError = class extends KnowhereError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var InvalidStateError = class extends KnowhereError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidStateError";
+  }
+};
+
+// src/errors/parsed-document-archive-error.ts
+var ParsedDocumentArchiveError = class extends KnowhereError {
+  code = "ARCHIVE_SPOOL_FAILED";
+  cause;
+  constructor(cause) {
+    super(
+      "Parsed result ZIP temporary storage is unavailable. Range-enabled object storage avoids temporary disk usage."
+    );
+    this.name = "ParsedDocumentArchiveError";
+    this.cause = cause;
+  }
+};
+
+// src/storage/parsed-document-storage.ts
+import JSZip from "jszip";
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://api.knowhereto.ai";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 5;
+var DEFAULT_POLL_INTERVAL = 1e4;
+var MAX_POLL_INTERVAL = 3e4;
+var DEFAULT_POLL_TIMEOUT = 18e5;
+var POLL_INTERVAL_INCREASE_THRESHOLD = 6e4;
+var POLL_INTERVAL_MULTIPLIER = 1.2;
+var INITIAL_RETRY_DELAY = 500;
+var MAX_RETRY_DELAY = 3e4;
+var RETRY_DELAY_BASE = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([409, 429, 502, 503, 504]);
+var TERMINAL_JOB_STATUSES = /* @__PURE__ */ new Set(["done", "failed"]);
+var ENV = {
+  API_KEY: "KNOWHERE_API_KEY",
+  BASE_URL: "KNOWHERE_BASE_URL",
+  LOG_LEVEL: "KNOWHERE_LOG_LEVEL"
+};
+
+// src/lib/utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function keysToCamel(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => keysToCamel(item));
+  }
+  if (typeof obj === "object" && obj.constructor === Object) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[snakeToCamel(key)] = keysToCamel(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function keysToSnake(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => keysToSnake(item));
+  }
+  if (typeof obj === "object" && obj.constructor === Object) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[camelToSnake(key)] = keysToSnake(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function parseDates(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => parseDates(item));
+  }
+  if (typeof obj === "object" && obj.constructor === Object) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if ((key.endsWith("At") || key.endsWith("Date")) && typeof value === "string" && /^\d{4}-\d{2}-\d{2}T/.test(value)) {
+        result[key] = new Date(value);
+      } else {
+        result[key] = parseDates(value);
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+function isTerminalStatus(status) {
+  return TERMINAL_JOB_STATUSES.has(status);
+}
+function enrichJobResult(jobResult) {
+  const computedProperties = {};
+  if (!Object.getOwnPropertyDescriptor(jobResult, "isTerminal")) {
+    computedProperties.isTerminal = {
+      get() {
+        return isTerminalStatus(this.status);
+      },
+      enumerable: true,
+      configurable: true
+    };
+  }
+  if (!Object.getOwnPropertyDescriptor(jobResult, "isDone")) {
+    computedProperties.isDone = {
+      get() {
+        return this.status === "done";
+      },
+      enumerable: true,
+      configurable: true
+    };
+  }
+  if (!Object.getOwnPropertyDescriptor(jobResult, "isFailed")) {
+    computedProperties.isFailed = {
+      get() {
+        return this.status === "failed";
+      },
+      enumerable: true,
+      configurable: true
+    };
+  }
+  if (Object.keys(computedProperties).length > 0) {
+    Object.defineProperties(jobResult, computedProperties);
+  }
+  return jobResult;
+}
+function enrichParseResult(parseResult, scope) {
+  if (scope.namespace !== void 0) {
+    parseResult.namespace = scope.namespace;
+  }
+  if (scope.documentId !== void 0) {
+    parseResult.documentId = scope.documentId;
+  }
+  return parseResult;
+}
+function sanitizePath(path) {
+  let sanitized = path.replace(/^\/+/, "");
+  sanitized = sanitized.replace(/\.\.(\/|\\)/g, "");
+  sanitized = sanitized.replace(/\\/g, "/");
+  return sanitized;
+}
+function getFileExtension(filename) {
+  const match = filename.match(/\.([^.]+)$/);
+  return match ? match[1].toLowerCase() : "";
+}
+function jitter(value, percent = 0.2) {
+  const randomFactor = 1 + (Math.random() * 2 - 1) * percent;
+  return Math.round(value * randomFactor);
+}
+
+// src/storage/parsed-document-storage.ts
+var parsedDocumentCommitPath = ".knowhere-sdk/commit.json";
+var jsonContentType = "application/json; charset=utf-8";
+var markdownContentType = "text/markdown; charset=utf-8";
+var csvContentType = "text/csv; charset=utf-8";
+var htmlContentType = "text/html; charset=utf-8";
+var binaryContentType = "application/octet-stream";
+async function syncParseResultToParsedDocumentStorage(params) {
+  const documentId = params.documentId ?? params.result.documentId ?? params.result.jobId;
+  const revisionKey = params.revisionKey ?? params.result.jobId;
+  for await (const object of collectResultLayoutObjects(params.result)) {
+    params.signal?.throwIfAborted();
+    await params.storage.writeObject({
+      documentId,
+      revisionKey,
+      ...object
+    });
+  }
+  await params.beforeCommit?.();
+  params.signal?.throwIfAborted();
+  const commit = {
+    version: 1,
+    documentId,
+    revisionKey,
+    source: params.source ?? "resultZip",
+    committedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeParsedDocumentJsonObject(params.storage, {
+    documentId,
+    revisionKey,
+    path: parsedDocumentCommitPath,
+    value: commit
+  });
+  return {
+    result: params.result,
+    documentId,
+    revisionKey,
+    commit
+  };
+}
+async function readParsedDocumentCommit(params) {
+  const object = await params.storage.readObject({
+    documentId: params.documentId,
+    revisionKey: params.revisionKey,
+    path: parsedDocumentCommitPath
+  });
+  if (!object) {
+    return null;
+  }
+  const commit = readJsonObject(object);
+  return commit.revisionKey === params.revisionKey && commit.documentId === params.documentId ? commit : null;
+}
+function readJsonObject(object) {
+  return JSON.parse(Buffer.from(object.body).toString("utf8"));
+}
+async function* collectResultLayoutObjects(result) {
+  const storedPaths = /* @__PURE__ */ new Set();
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(result.rawZip);
+  } catch {
+  }
+  if (zip) {
+    for (const entry of Object.values(zip.files)) {
+      if (entry.dir || entry.name === "result.zip") continue;
+      const path = normalizeResultPath(entry.name);
+      if (isSdkMetadataPath(path)) continue;
+      storedPaths.add(path);
+      yield {
+        path,
+        body: await entry.async("nodebuffer"),
+        contentType: inferContentTypeFromPath(path)
+      };
+    }
+  }
+  for (const object of generateMissingResultObjects(result, storedPaths)) yield object;
+}
+function* generateMissingResultObjects(result, storedPaths) {
+  if (!storedPaths.has("manifest.json")) yield createJsonObject("manifest.json", result.manifest);
+  if (!storedPaths.has("chunks.json"))
+    yield createJsonObject("chunks.json", keysToSnake(serializeChunks(result.chunks)));
+  if (!storedPaths.has("doc_nav.json") && result.docNav)
+    yield createJsonObject("doc_nav.json", result.docNav);
+  if (!storedPaths.has("full.md") && result.fullMarkdown)
+    yield createTextObject("full.md", result.fullMarkdown, markdownContentType);
+  if (!storedPaths.has("chunks_slim.json") && result.chunksSlim)
+    yield createJsonObject("chunks_slim.json", { chunks: result.chunksSlim });
+  if (!storedPaths.has("hierarchy.json") && result.hierarchy)
+    yield createJsonObject("hierarchy.json", result.hierarchy);
+  if (!storedPaths.has("toc_hierarchies.json") && result.tocHierarchies)
+    yield createJsonObject("toc_hierarchies.json", result.tocHierarchies);
+  if (!storedPaths.has("kb.csv") && result.kbCsv)
+    yield createTextObject("kb.csv", result.kbCsv, csvContentType);
+  if (!storedPaths.has("hierarchy_view.html") && result.hierarchyViewHtml)
+    yield createTextObject("hierarchy_view.html", result.hierarchyViewHtml, htmlContentType);
+  for (const chunk of result.imageChunks) {
+    const path = normalizeResultPath(chunk.filePath);
+    if (storedPaths.has(path)) continue;
+    yield {
+      path,
+      body: chunk.data,
+      contentType: inferContentTypeFromPath(path),
+      metadata: { chunkId: chunk.chunkId, chunkType: chunk.type, sourcePath: chunk.filePath }
+    };
+  }
+  for (const chunk of result.tableChunks) {
+    const path = normalizeResultPath(chunk.filePath);
+    if (storedPaths.has(path)) continue;
+    yield {
+      path,
+      body: Buffer.from(chunk.html, "utf8"),
+      contentType: htmlContentType,
+      metadata: { chunkId: chunk.chunkId, chunkType: chunk.type, sourcePath: chunk.filePath }
+    };
+  }
+}
+function serializeChunks(chunks) {
+  return {
+    chunks: chunks.map((chunk) => {
+      const rawChunk = {
+        chunkId: chunk.chunkId,
+        type: chunk.type,
+        contentSource: chunk.contentSource,
+        content: chunk.content,
+        path: chunk.path,
+        metadata: chunk.metadata
+      };
+      if (chunk.type === "image" || chunk.type === "table") {
+        return {
+          ...rawChunk,
+          filePath: chunk.filePath,
+          assetUrl: chunk.assetUrl
+        };
+      }
+      return rawChunk;
+    })
+  };
+}
+async function writeParsedDocumentJsonObject(storage, params) {
+  await storage.writeObject({
+    documentId: params.documentId,
+    revisionKey: params.revisionKey,
+    path: params.path,
+    body: Buffer.from(JSON.stringify(params.value, null, 2), "utf8"),
+    contentType: jsonContentType
+  });
+}
+function createJsonObject(path, value) {
+  return {
+    path,
+    body: Buffer.from(JSON.stringify(value, null, 2), "utf8"),
+    contentType: jsonContentType
+  };
+}
+function createTextObject(path, value, contentType) {
+  return {
+    path,
+    body: Buffer.from(value, "utf8"),
+    contentType
+  };
+}
+function inferContentTypeFromPath(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".json")) return jsonContentType;
+  if (lower.endsWith(".md")) return markdownContentType;
+  if (lower.endsWith(".csv")) return csvContentType;
+  if (lower.endsWith(".html") || lower.endsWith(".htm")) return htmlContentType;
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".svg")) return "image/svg+xml";
+  return binaryContentType;
+}
+function normalizeResultPath(value) {
+  const normalized = value.replaceAll("\\", "/").replace(/^\.\/+/, "");
+  if (normalized.length === 0 || normalized.includes("\0") || normalized.startsWith("/") || normalized.split("/").some((part) => part.length === 0 || part === "." || part === "..")) {
+    throw new Error(`Invalid parsed result path: ${value}`);
+  }
+  return normalized;
+}
+function isSdkMetadataPath(path) {
+  return path === ".knowhere-sdk" || path.startsWith(".knowhere-sdk/");
+}
+
+// src/storage/streamed-parsed-document-sync.ts
+import { createHash } from "crypto";
+import { HttpRangeReader, ZipReader } from "@zip.js/zip.js";
+async function syncRemoteResultArchive(params) {
+  params.signal?.throwIfAborted();
+  const startedAt = Date.now();
+  const maxEntries = Math.max(1, params.limits?.maxEntriesPerSync ?? 100);
+  const deadlineMs = Math.max(1, params.limits?.archiveSyncDeadlineMs ?? 12e4);
+  const previous = await params.storage.readSyncProgress(params);
+  const source = await openArchive(params);
+  const entryHashes = [];
+  const paths = /* @__PURE__ */ new Set();
+  let entryIndex = 0;
+  let copiedEntries = 0;
+  const nextEntry = previous?.status === "completed" ? 0 : previous?.nextArchiveEntry ?? 0;
+  try {
+    if (previous?.archiveIdentity && previous.archiveIdentity !== source.identity) {
+      throw new Error("Parsed result archive identity changed; start a new revision.");
+    }
+    if (previous?.pinnedRevisionKey && previous.pinnedRevisionKey !== params.revisionKey) {
+      throw new Error("Parsed result revision changed while resuming archive sync.");
+    }
+    for await (const entry of source.entries) {
+      params.signal?.throwIfAborted();
+      if (paths.has(entry.path)) throw new Error(`Duplicate parsed result path: ${entry.path}`);
+      paths.add(entry.path);
+      if (entryIndex >= nextEntry && copiedEntries > 0 && (copiedEntries >= maxEntries || Date.now() - startedAt >= deadlineMs)) {
+        return { documentId: params.documentId, revisionKey: params.revisionKey, completed: false };
+      }
+      if (entryIndex < nextEntry && source.canSkipEntries) {
+        const previousHash = previous?.archiveEntryHashes?.[entryIndex];
+        if (!previousHash) throw new Error("Parsed archive checkpoint is missing an entry hash.");
+        entryHashes.push(previousHash);
+        entryIndex += 1;
+        continue;
+      }
+      const hash = createHash("sha256");
+      const body = entry.read().pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            params.signal?.throwIfAborted();
+            hash.update(chunk);
+            controller.enqueue(chunk);
+          }
+        })
+      );
+      if (entryIndex < nextEntry) {
+        await body.pipeTo(new WritableStream(), { signal: params.signal });
+      } else {
+        await writeStream(params.storage, {
+          documentId: params.documentId,
+          revisionKey: params.revisionKey,
+          path: entry.path,
+          body,
+          contentType: inferContentTypeFromPath(entry.path),
+          signal: params.signal
+        });
+      }
+      const entryHash = createHash("sha256").update(entry.path).update(hash.digest()).digest("hex");
+      if (entryIndex < nextEntry && previous?.archiveEntryHashes?.[entryIndex] !== entryHash) {
+        throw new Error("Parsed result archive entry changed while resuming.");
+      }
+      entryHashes.push(entryHash);
+      entryIndex += 1;
+      if (entryIndex <= nextEntry) continue;
+      copiedEntries += 1;
+      await params.storage.writeSyncProgress({
+        documentId: params.documentId,
+        revisionKey: params.revisionKey,
+        pinnedRevisionKey: params.revisionKey,
+        archiveIdentity: source.identity,
+        archiveEntryHashes: [...entryHashes],
+        nextArchiveEntry: entryIndex,
+        status: "running",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    await validateRequiredObjects(params, paths);
+    await params.verifyRevision?.();
+    params.signal?.throwIfAborted();
+    const commit = {
+      version: 1,
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      source: "resultZip",
+      committedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await params.storage.writeObject({
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      path: parsedDocumentCommitPath,
+      body: Buffer.from(JSON.stringify(commit, null, 2)),
+      contentType: "application/json; charset=utf-8"
+    });
+    await params.storage.writeSyncProgress({
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      pinnedRevisionKey: params.revisionKey,
+      archiveIdentity: source.identity,
+      archiveEntryHashes: entryHashes,
+      nextArchiveEntry: entryIndex,
+      status: "completed",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (params.retainResultArchive) {
+      try {
+        await retainArchive(params, source.downloadIdentity);
+      } catch {
+      }
+    }
+    return {
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      completed: true,
+      commit
+    };
+  } finally {
+    await source.close();
+  }
+}
+async function openArchive(params) {
+  const probe = await fetch(params.resultUrl, {
+    headers: { Range: "bytes=0-0" },
+    signal: params.signal
+  });
+  if (!probe.ok) {
+    await probe.body?.cancel();
+    throw new Error(`Parsed result download failed (HTTP ${probe.status}).`);
+  }
+  const identity = createDownloadIdentity(params.jobId, probe);
+  const supportsRange = probe.status === 206 && probe.headers.has("content-range");
+  await probe.body?.cancel();
+  if (!supportsRange) {
+    const { openSequentialArchive } = await import("./sequential-parsed-document-archive-S56UEARH.mjs");
+    return openSequentialArchive(params, identity);
+  }
+  const options = {
+    forceRangeRequests: true,
+    preventHeadRequest: true,
+    checkResourceChanges: true,
+    fetch: async (input, init) => {
+      const response = await fetch(input, { ...init, signal: params.signal });
+      if (response.status !== 206) {
+        await response.body?.cancel();
+        throw new Error(`Parsed result Range request failed (HTTP ${response.status}).`);
+      }
+      return response;
+    }
+  };
+  const reader = new ZipReader(new HttpRangeReader(params.resultUrl, options), {
+    useWebWorkers: false,
+    checkCrc32: true
+  });
+  try {
+    const entries = await reader.getEntries();
+    const files = entries.filter(
+      (entry) => !entry.directory && isSnapshotPath(entry.filename)
+    );
+    const archiveIdentity = createHash("sha256").update(identity).update(
+      JSON.stringify(
+        files.map((entry) => [entry.filename, entry.uncompressedSize, entry.signature])
+      )
+    ).digest("hex");
+    return {
+      identity: archiveIdentity,
+      downloadIdentity: identity,
+      canSkipEntries: true,
+      entries: (function* () {
+        for (const entry of files)
+          yield {
+            path: normalizeResultPath(entry.filename),
+            read: () => readRangeEntry(entry, params.signal)
+          };
+      })(),
+      close: async () => {
+        await reader.close();
+      }
+    };
+  } catch (error) {
+    await reader.close();
+    throw error;
+  }
+}
+function readRangeEntry(entry, signal) {
+  const stream = new TransformStream();
+  void entry.getData(stream.writable, { signal, checkCrc32: true, useWebWorkers: false }).catch(async (error) => {
+    try {
+      await stream.writable.abort(error);
+    } catch {
+    }
+  });
+  return stream.readable;
+}
+async function writeStream(storage, params) {
+  if (storage.writeObjectStream) {
+    try {
+      await storage.writeObjectStream(params);
+    } catch (error) {
+      await params.body.cancel(error).catch(() => void 0);
+      throw error;
+    }
+    return;
+  }
+  const parts = [];
+  for await (const part of params.body) {
+    params.signal?.throwIfAborted();
+    parts.push(part);
+  }
+  await storage.writeObject({ ...params, body: Buffer.concat(parts) });
+}
+async function validateRequiredObjects(params, paths) {
+  const required = /* @__PURE__ */ new Set(["manifest.json", "chunks.json"]);
+  for (const path of required)
+    if (!paths.has(path)) throw new Error(`Required parsed result file missing: ${path}`);
+  const manifestObject = await params.storage.readObject({ ...params, path: "manifest.json" });
+  const chunksObject = await params.storage.readObject({ ...params, path: "chunks.json" });
+  if (!manifestObject || !chunksObject)
+    throw new Error("Required parsed result manifest.json or chunks.json was not persisted.");
+  const manifest = JSON.parse(Buffer.from(manifestObject.body).toString("utf8"));
+  const payload = JSON.parse(Buffer.from(chunksObject.body).toString("utf8"));
+  if (!isRecord(manifest)) throw new Error("Invalid parsed result manifest.json.");
+  const manifestJobId = manifest.job_id ?? manifest.jobId;
+  if (manifestJobId !== params.jobId)
+    throw new Error("Parsed result manifest job identity differs from the pinned job.");
+  const chunks = Array.isArray(payload) ? payload : isRecord(payload) ? payload.chunks : void 0;
+  if (!Array.isArray(chunks)) throw new Error("Invalid parsed result chunks.json.");
+  if (isRecord(manifest.files)) {
+    for (const path of Object.values(manifest.files))
+      if (typeof path === "string") required.add(normalizeResultPath(path));
+  }
+  for (const chunk of chunks) {
+    if (!isRecord(chunk)) throw new Error("Invalid parsed result chunk.");
+    const metadata = chunk.metadata;
+    const chunkType = chunk.type ?? chunk.chunk_type ?? chunk.chunkType;
+    const filePath = chunk.file_path ?? chunk.filePath ?? (isRecord(metadata) ? metadata.file_path ?? metadata.filePath : void 0) ?? (chunkType === "image" || chunkType === "table" ? chunk.path : void 0);
+    if (typeof filePath === "string") required.add(normalizeResultPath(filePath));
+    if (!isRecord(metadata)) continue;
+    const pageAssets = metadata.page_assets ?? metadata.pageAssets;
+    if (!Array.isArray(pageAssets)) continue;
+    for (const asset of pageAssets)
+      if (isRecord(asset)) {
+        const ref = asset.artifact_ref ?? asset.artifactRef;
+        if (typeof ref === "string") required.add(normalizeResultPath(ref));
+      }
+  }
+  for (const path of required)
+    if (!paths.has(path)) throw new Error(`Required parsed result file missing: ${path}`);
+}
+async function retainArchive(params, expectedIdentity) {
+  const response = await fetch(params.resultUrl, { signal: params.signal });
+  if (!response.ok || !response.body)
+    throw new Error(`Optional archive download failed (HTTP ${response.status}).`);
+  if (createDownloadIdentity(params.jobId, response) !== expectedIdentity) {
+    await response.body.cancel();
+    throw new Error("Optional result archive identity changed.");
+  }
+  await writeStream(params.storage, {
+    documentId: params.documentId,
+    revisionKey: params.revisionKey,
+    path: "result.zip",
+    body: response.body,
+    contentType: "application/zip",
+    signal: params.signal
+  });
+}
+function isSnapshotPath(path) {
+  const normalized = normalizeResultPath(path.replace(/\/$/, ""));
+  return normalized !== "result.zip" && normalized !== ".knowhere-sdk" && !normalized.startsWith(".knowhere-sdk/");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createDownloadIdentity(jobId, response) {
+  return createHash("sha256").update(
+    JSON.stringify([
+      jobId,
+      response.headers.get("etag"),
+      response.headers.get("last-modified"),
+      response.headers.get("content-range")?.split("/").at(-1) ?? response.headers.get("content-length")
+    ])
+  ).digest("hex");
+}
+
+export {
+  DEFAULT_BASE_URL,
+  DEFAULT_TIMEOUT,
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_POLL_INTERVAL,
+  MAX_POLL_INTERVAL,
+  DEFAULT_POLL_TIMEOUT,
+  POLL_INTERVAL_INCREASE_THRESHOLD,
+  POLL_INTERVAL_MULTIPLIER,
+  INITIAL_RETRY_DELAY,
+  MAX_RETRY_DELAY,
+  RETRY_DELAY_BASE,
+  RETRYABLE_STATUS_CODES,
+  ENV,
+  KnowhereError,
+  NetworkError,
+  TimeoutError,
+  PollingTimeoutError,
+  ChecksumError,
+  ValidationError,
+  InvalidStateError,
+  ParsedDocumentArchiveError,
+  sleep,
+  keysToCamel,
+  keysToSnake,
+  parseDates,
+  enrichJobResult,
+  enrichParseResult,
+  sanitizePath,
+  getFileExtension,
+  jitter,
+  syncParseResultToParsedDocumentStorage,
+  readParsedDocumentCommit,
+  readJsonObject,
+  normalizeResultPath,
+  syncRemoteResultArchive,
+  isSnapshotPath,
+  createDownloadIdentity
+};