@ontos-ai/knowhere-sdk 2.5.0 → 2.6.0-beta.20261026172248

package/dist/chunk-FESTKAG6.mjs

@@ -0,0 +1,1343 @@
+// 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/api-errors.ts
+var APIError = class extends KnowhereError {
+  constructor(message, statusCode, code, requestId, details, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.requestId = requestId;
+    this.details = details;
+    this.body = body;
+    this.name = "APIError";
+  }
+  statusCode;
+  code;
+  requestId;
+  details;
+  body;
+};
+var BadRequestError = class extends APIError {
+  constructor(message, code, requestId, details, body) {
+    super(message, 400, code, requestId, details, body);
+    this.name = "BadRequestError";
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(message = "Authentication failed", code, requestId, details, body) {
+    super(message, 401, code, requestId, details, body);
+    this.name = "AuthenticationError";
+  }
+};
+var PaymentRequiredError = class extends APIError {
+  constructor(message = "Payment required", code, requestId, details, body) {
+    super(message, 402, code, requestId, details, body);
+    this.name = "PaymentRequiredError";
+  }
+};
+var PermissionDeniedError = class extends APIError {
+  constructor(message = "Permission denied", code, requestId, details, body) {
+    super(message, 403, code, requestId, details, body);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message = "Resource not found", code, requestId, details, body) {
+    super(message, 404, code, requestId, details, body);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends APIError {
+  constructor(message = "Conflict", code, requestId, details, body) {
+    super(message, 409, code, requestId, details, body);
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends APIError {
+  constructor(message = "Rate limit exceeded", code, requestId, details, body, retryAfter) {
+    super(message, 429, code, requestId, details, body);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+  retryAfter;
+};
+var InternalServerError = class extends APIError {
+  constructor(message = "Internal server error", code, requestId, details, body) {
+    super(message, 500, code, requestId, details, body);
+    this.name = "InternalServerError";
+  }
+};
+var ServiceUnavailableError = class extends APIError {
+  constructor(message = "Service unavailable", statusCode = 503, code, requestId, details, body) {
+    super(message, statusCode, code, requestId, details, body);
+    this.name = "ServiceUnavailableError";
+  }
+};
+var GatewayTimeoutError = class extends APIError {
+  constructor(message = "Gateway timeout", code, requestId, details, body) {
+    super(message, 504, code, requestId, details, body);
+    this.name = "GatewayTimeoutError";
+  }
+};
+function createAPIError(statusCode, message, code, requestId, details, body, retryAfter) {
+  switch (statusCode) {
+    case 400:
+      return new BadRequestError(message, code, requestId, details, body);
+    case 401:
+      return new AuthenticationError(message, code, requestId, details, body);
+    case 402:
+      return new PaymentRequiredError(message, code, requestId, details, body);
+    case 403:
+      return new PermissionDeniedError(message, code, requestId, details, body);
+    case 404:
+      return new NotFoundError(message, code, requestId, details, body);
+    case 409:
+      return new ConflictError(message, code, requestId, details, body);
+    case 429:
+      return new RateLimitError(message, code, requestId, details, body, retryAfter);
+    case 500:
+      return new InternalServerError(message, code, requestId, details, body);
+    case 502:
+    case 503:
+      return new ServiceUnavailableError(message, statusCode, code, requestId, details, body);
+    case 504:
+      return new GatewayTimeoutError(message, code, requestId, details, body);
+    default:
+      return new APIError(message, statusCode, code, requestId, details, body);
+  }
+}
+
+// src/errors/job-errors.ts
+var JobFailedError = class extends KnowhereError {
+  constructor(message, code, jobResult) {
+    super(message);
+    this.code = code;
+    this.jobResult = jobResult;
+    this.name = "JobFailedError";
+  }
+  code;
+  jobResult;
+};
+
+// 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 as createHash2 } from "crypto";
+
+// src/storage/archive-cache-transport-error.ts
+var ArchiveCacheTransportError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArchiveCacheTransportError";
+  }
+};
+
+// src/storage/parsed-document-archive-cache.ts
+import { createHash } from "crypto";
+var ARCHIVE_CACHE_TIMEOUT_MS = 3e4;
+var ArchiveOriginIntegrityError = class extends Error {
+};
+async function prepareCachedArchive(params) {
+  params.signal?.throwIfAborted();
+  if (params.archiveCacheBypassed) return createFallback(params);
+  if (!params.storage.writeObjectStream || !params.storage.headObject || !params.storage.getObjectUrl) {
+    await params.onBypass?.();
+    return createFallback(params);
+  }
+  const controller = new AbortController();
+  const signal = params.signal ? AbortSignal.any([params.signal, controller.signal]) : controller.signal;
+  const mutations = /* @__PURE__ */ new Set();
+  let rejectCancellation;
+  const cancellation = new Promise((_resolve, reject) => {
+    rejectCancellation = () => {
+      const reason = signal.reason;
+      reject(
+        reason instanceof Error ? reason : new Error("Parsed result archive cache was cancelled.", { cause: reason })
+      );
+    };
+    signal.addEventListener("abort", rejectCancellation, { once: true });
+  });
+  const timer = setTimeout(() => {
+    controller.abort(new Error("Parsed result archive cache exceeded its thirty-second budget."));
+  }, ARCHIVE_CACHE_TIMEOUT_MS);
+  let origin;
+  const preparation = (async () => {
+    origin = await probeArchiveOrigin({ ...params, signal });
+    signal.throwIfAborted();
+    if (!hasStrongEntityTag(origin.entityTag) || origin.contentLength === void 0)
+      throw new Error("Parsed result archive cache requires a strong origin version and length.");
+    return prepareArchiveCache(params, origin, signal, mutations);
+  })();
+  try {
+    return await Promise.race([preparation, cancellation]);
+  } catch (error) {
+    controller.abort(error);
+    await Promise.allSettled([...mutations]);
+    params.signal?.throwIfAborted();
+    if (error instanceof ArchiveOriginIntegrityError) throw error;
+    await params.onBypass?.();
+    return createFallback(params, origin);
+  } finally {
+    clearTimeout(timer);
+    if (rejectCancellation) signal.removeEventListener("abort", rejectCancellation);
+  }
+}
+function createFallback(params, origin) {
+  return {
+    resultUrl: params.resultUrl,
+    downloadIdentity: origin?.identity,
+    archiveCacheBypassed: true,
+    isCached: false,
+    validateResponse(response) {
+      if (origin && createOriginIdentity(params.jobId, response) !== origin.identity)
+        rejectResponse(
+          response,
+          new ArchiveOriginIntegrityError("Parsed result origin archive identity changed.")
+        );
+      return response;
+    }
+  };
+}
+async function probeArchiveOrigin(params) {
+  const response = await fetch(params.resultUrl, {
+    headers: { Range: "bytes=0-0" },
+    signal: params.signal
+  });
+  try {
+    if (!response.ok) throw new Error(`Parsed result download failed (HTTP ${response.status}).`);
+    return {
+      identity: createOriginIdentity(params.jobId, response),
+      contentLength: readOriginLength(response),
+      entityTag: response.headers.get("etag")
+    };
+  } finally {
+    await response.body?.cancel();
+  }
+}
+async function prepareArchiveCache(params, origin, signal, mutations) {
+  const object = { ...params, path: "result.zip" };
+  const initialHead = await params.storage.headObject(object);
+  signal.throwIfAborted();
+  let marker = null;
+  if (initialHead) {
+    const version = readObjectVersion(initialHead);
+    const stored = await params.storage.readObject({
+      ...object,
+      path: createMarkerPath(origin.identity, version.entityTag)
+    });
+    signal.throwIfAborted();
+    if (stored) marker = readMarker(stored, params, origin, version);
+  }
+  if (!marker) marker = await storeArchive(params, origin, signal, mutations);
+  signal.throwIfAborted();
+  const resultUrl = await params.storage.getObjectUrl(object);
+  signal.throwIfAborted();
+  if (!resultUrl) throw new Error("Parsed result archive cache has no readable object URL.");
+  const validateResponse = (response2) => validateCachedResponse(response2, marker, params.signal);
+  const response = await fetch(resultUrl, {
+    headers: { Range: "bytes=0-0", "If-Match": marker.storageEntityTag },
+    signal
+  });
+  try {
+    if (response.headers.get("content-range") !== `bytes 0-0/${marker.contentLength}` || response.headers.get("content-length") !== "1")
+      rejectResponse(
+        response,
+        new ArchiveCacheTransportError("Parsed result archive cache probe exceeded one byte.")
+      );
+    const validated = validateResponse(response);
+    await validated.arrayBuffer();
+  } catch (error) {
+    await response.body?.cancel().catch(() => void 0);
+    throw error;
+  }
+  signal.throwIfAborted();
+  return {
+    resultUrl,
+    downloadIdentity: origin.identity,
+    archiveCacheBypassed: false,
+    isCached: true,
+    validateResponse
+  };
+}
+async function storeArchive(params, origin, signal, mutations) {
+  const response = await fetch(params.resultUrl, {
+    headers: { "If-Match": origin.entityTag },
+    signal
+  });
+  if (signal.aborted) {
+    await response.body?.cancel();
+    signal.throwIfAborted();
+  }
+  if (!response.ok || !response.body) {
+    await response.body?.cancel();
+    if (response.status === 412)
+      throw new ArchiveOriginIntegrityError("Parsed result origin archive identity changed.");
+    throw new Error(`Parsed result archive cache download failed (HTTP ${response.status}).`);
+  }
+  if (createOriginIdentity(params.jobId, response) !== origin.identity) {
+    await response.body.cancel();
+    throw new ArchiveOriginIntegrityError("Parsed result origin archive identity changed.");
+  }
+  const hash = createHash("sha256");
+  let contentLength = 0;
+  let hasCompleted = false;
+  const body = response.body.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        signal.throwIfAborted();
+        contentLength += chunk.length;
+        if (contentLength > origin.contentLength)
+          throw new ArchiveOriginIntegrityError("Parsed result origin archive length changed.");
+        hash.update(chunk);
+        controller.enqueue(chunk);
+      },
+      flush() {
+        if (contentLength !== origin.contentLength)
+          throw new ArchiveOriginIntegrityError("Parsed result origin archive length changed.");
+        hasCompleted = true;
+      }
+    })
+  );
+  const object = { ...params, path: "result.zip" };
+  let write;
+  try {
+    signal.throwIfAborted();
+    write = await settleMutation(
+      params.storage.writeObjectStream({
+        ...object,
+        body,
+        contentType: "application/zip",
+        contentLength: origin.contentLength,
+        signal
+      }),
+      mutations
+    );
+  } catch (error) {
+    await body.cancel(error).catch(() => void 0);
+    throw error;
+  }
+  signal.throwIfAborted();
+  if (!hasCompleted)
+    throw new Error("Parsed result archive cache sink did not consume the stream.");
+  if (!hasStrongEntityTag(write.entityTag))
+    throw new Error("Parsed result archive cache requires a strong object version.");
+  const head = await params.storage.headObject(object);
+  signal.throwIfAborted();
+  if (!head) throw new Error("Parsed result archive cache was not persisted.");
+  const actualVersion = readObjectVersion(head);
+  if (write.entityTag !== actualVersion.entityTag || actualVersion.contentLength !== contentLength)
+    throw new Error("Parsed result archive cache object version or length changed during upload.");
+  const marker = {
+    version: 1,
+    jobId: params.jobId,
+    revisionKey: params.revisionKey,
+    originIdentity: origin.identity,
+    contentLength,
+    sha256: hash.digest("hex"),
+    storageEntityTag: actualVersion.entityTag
+  };
+  signal.throwIfAborted();
+  await settleMutation(
+    params.storage.writeObject({
+      ...object,
+      path: createMarkerPath(origin.identity, actualVersion.entityTag),
+      body: Buffer.from(JSON.stringify(marker)),
+      contentType: "application/json; charset=utf-8"
+    }),
+    mutations
+  );
+  signal.throwIfAborted();
+  return marker;
+}
+async function settleMutation(mutation, mutations) {
+  mutations.add(mutation);
+  try {
+    return await mutation;
+  } finally {
+    mutations.delete(mutation);
+  }
+}
+function readMarker(object, params, origin, version) {
+  const value = JSON.parse(Buffer.from(object.body).toString("utf8"));
+  if (typeof value !== "object" || value === null || !("version" in value) || value.version !== 1 || !("jobId" in value) || value.jobId !== params.jobId || !("revisionKey" in value) || value.revisionKey !== params.revisionKey || !("originIdentity" in value) || value.originIdentity !== origin.identity || !("contentLength" in value) || value.contentLength !== origin.contentLength || value.contentLength !== version.contentLength || !("storageEntityTag" in value) || value.storageEntityTag !== version.entityTag || !("sha256" in value) || typeof value.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.sha256))
+    throw new Error("Parsed result archive cache completion marker is invalid.");
+  return {
+    version: 1,
+    jobId: params.jobId,
+    revisionKey: params.revisionKey,
+    originIdentity: origin.identity,
+    contentLength: version.contentLength,
+    storageEntityTag: version.entityTag,
+    sha256: value.sha256
+  };
+}
+function readObjectVersion(object) {
+  if (!hasStrongEntityTag(object.entityTag) || !isPositiveInteger(object.contentLength))
+    throw new Error("Parsed result archive cache requires a strong object version and length.");
+  return { entityTag: object.entityTag, contentLength: object.contentLength };
+}
+function validateCachedResponse(response, marker, signal) {
+  if (response.headers.get("etag") !== marker.storageEntityTag)
+    rejectResponse(
+      response,
+      new ArchiveCacheTransportError("Parsed result archive cache response version changed.")
+    );
+  if (response.status !== 206 || !response.body)
+    rejectResponse(
+      response,
+      new ArchiveCacheTransportError("Parsed result archive cache requires a ranged response.")
+    );
+  const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(
+    response.headers.get("content-range") ?? ""
+  );
+  const contentLength = Number(response.headers.get("content-length"));
+  if (!range || Number(range[3]) !== marker.contentLength || Number(range[1]) > Number(range[2]) || Number(range[2]) >= marker.contentLength || contentLength !== Number(range[2]) - Number(range[1]) + 1)
+    rejectResponse(
+      response,
+      new ArchiveCacheTransportError("Parsed result archive cache response length changed.")
+    );
+  let actualLength = 0;
+  return new Response(
+    response.body.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          signal?.throwIfAborted();
+          actualLength += chunk.length;
+          if (actualLength > contentLength)
+            throw new ArchiveCacheTransportError(
+              "Parsed result archive cache response length changed."
+            );
+          controller.enqueue(chunk);
+        },
+        flush() {
+          if (actualLength !== contentLength)
+            throw new ArchiveCacheTransportError(
+              "Parsed result archive cache response length changed."
+            );
+        }
+      })
+    ),
+    { status: response.status, statusText: response.statusText, headers: response.headers }
+  );
+}
+function rejectResponse(response, error) {
+  void response.body?.cancel(error).catch(() => void 0);
+  throw error;
+}
+function createMarkerPath(originIdentity, entityTag) {
+  const identity = createHash("sha256").update(JSON.stringify([originIdentity, entityTag])).digest("hex");
+  return `.knowhere-sdk/archive-cache/${identity}.json`;
+}
+function createOriginIdentity(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");
+}
+function readOriginLength(response) {
+  const value = Number(
+    response.headers.get("content-range")?.split("/").at(-1) ?? response.headers.get("content-length")
+  );
+  return isPositiveInteger(value) ? value : void 0;
+}
+function hasStrongEntityTag(value) {
+  return typeof value === "string" && value.length > 0 && !value.startsWith("W/");
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+// src/storage/streamed-parsed-document-sync.ts
+import { HttpRangeReader, ZipReader } from "@zip.js/zip.js";
+async function syncRemoteResultArchive(params) {
+  params.signal?.throwIfAborted();
+  validateArchiveSyncLimits(params.limits);
+  const startedAt = Date.now();
+  const maxEntries = params.limits?.maxEntriesPerSync ?? 100;
+  const deadlineMs = params.limits?.archiveSyncDeadlineMs ?? 12e4;
+  const checkpointFileInterval = params.limits?.checkpointFileInterval ?? 1;
+  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 previous = await params.storage.readSyncProgress(params);
+  const source = await openArchive(transferParams, previous);
+  const concurrency = source.canSkipEntries ? params.limits?.maxConcurrentFiles ?? 1 : 1;
+  const nextEntry = previous?.status === "completed" ? 0 : previous?.nextArchiveEntry ?? 0;
+  const entryHashes = [];
+  const successfulHashes = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  let entryIndex = 0;
+  let startedEntries = 0;
+  let successfulEntries = 0;
+  let checkpointEntry = nextEntry;
+  let checkpointAt = Date.now();
+  let failure;
+  let archiveCacheBypassed = source.archiveCacheBypassed;
+  async function flushProgress(isSegmentBoundary, isRecovering = false) {
+    let contiguousEntry = checkpointEntry;
+    while (successfulHashes.has(contiguousEntry)) {
+      entryHashes[contiguousEntry] = successfulHashes.get(contiguousEntry);
+      contiguousEntry += 1;
+    }
+    if (contiguousEntry === checkpointEntry) return;
+    await params.storage.writeSyncProgress(
+      {
+        documentId: params.documentId,
+        revisionKey: params.revisionKey,
+        pinnedRevisionKey: params.revisionKey,
+        archiveIdentity: source.identity,
+        archiveCacheBypassed,
+        archiveEntryHashes: entryHashes.slice(0, contiguousEntry),
+        nextArchiveEntry: contiguousEntry,
+        status: "running",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      { signal: isRecovering ? void 0 : signal, isSegmentBoundary }
+    );
+    for (let index = checkpointEntry; index < contiguousEntry; index += 1)
+      successfulHashes.delete(index);
+    checkpointEntry = contiguousEntry;
+    successfulEntries = successfulHashes.size;
+    checkpointAt = Date.now();
+  }
+  function startEntry(entry, index) {
+    const task = copyEntry(transferParams, entry).then(
+      (hash) => {
+        successfulHashes.set(index, hash);
+        successfulEntries += 1;
+      },
+      (error) => {
+        if (failure === void 0)
+          failure = error instanceof Error ? error : new Error(String(error));
+        controller.abort(error);
+      }
+    ).finally(() => {
+      running.delete(task);
+    });
+    running.add(task);
+  }
+  async function drainEntries() {
+    await Promise.all(running);
+    if (failure !== void 0) throw failure;
+    signal.throwIfAborted();
+  }
+  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) {
+      if (failure !== void 0) throw failure;
+      signal.throwIfAborted();
+      if (paths.has(entry.path)) throw new Error(`Duplicate parsed result path: ${entry.path}`);
+      paths.add(entry.path);
+      if (entryIndex < nextEntry) {
+        const previousHash = previous?.archiveEntryHashes?.[entryIndex];
+        if (!previousHash) throw new Error("Parsed archive checkpoint is missing an entry hash.");
+        if (!source.canSkipEntries && await copyEntry(transferParams, entry, true) !== previousHash)
+          throw new Error("Parsed result archive entry changed while resuming.");
+        entryHashes.push(previousHash);
+        entryIndex += 1;
+        continue;
+      }
+      if (startedEntries > 0 && (startedEntries >= maxEntries || Date.now() - startedAt >= deadlineMs)) {
+        await drainEntries();
+        await flushProgress(true);
+        return { documentId: params.documentId, revisionKey: params.revisionKey, completed: false };
+      }
+      if (successfulEntries >= checkpointFileInterval || Date.now() - checkpointAt >= checkpointIntervalMs) {
+        await drainEntries();
+        await flushProgress(false);
+      }
+      startEntry(entry, entryIndex);
+      entryIndex += 1;
+      startedEntries += 1;
+      if (running.size >= concurrency) await Promise.race(running);
+    }
+    await drainEntries();
+    await flushProgress(true);
+    await validateRequiredObjects(params, paths);
+    await params.verifyRevision?.();
+    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,
+        archiveCacheBypassed,
+        archiveEntryHashes: entryHashes,
+        nextArchiveEntry: entryIndex,
+        status: "completed",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      { signal, isSegmentBoundary: true }
+    );
+    if (params.retainResultArchive && !source.isCached) {
+      try {
+        await retainArchive(transferParams, source.downloadIdentity);
+      } catch {
+      }
+    }
+    return {
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      completed: true,
+      commit
+    };
+  } catch (error) {
+    controller.abort(error);
+    await Promise.all(running);
+    const hasCacheTransportFailure = error instanceof ArchiveCacheTransportError || failure instanceof ArchiveCacheTransportError;
+    if (hasCacheTransportFailure) archiveCacheBypassed = true;
+    await flushProgress(true, true).catch(() => void 0);
+    if (hasCacheTransportFailure) {
+      await persistArchiveCacheBypass(
+        { ...params, signal: void 0 },
+        {
+          documentId: params.documentId,
+          revisionKey: params.revisionKey,
+          pinnedRevisionKey: params.revisionKey,
+          archiveIdentity: source.identity,
+          archiveEntryHashes: entryHashes.slice(0, checkpointEntry),
+          nextArchiveEntry: checkpointEntry,
+          status: "running",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ).catch(() => void 0);
+    }
+    throw failure ?? error;
+  } finally {
+    controller.abort();
+    await Promise.all(running);
+    await source.close();
+  }
+}
+function validateArchiveSyncLimits(limits) {
+  const names = [
+    "maxEntriesPerSync",
+    "archiveSyncDeadlineMs",
+    "maxConcurrentFiles",
+    "checkpointFileInterval",
+    "checkpointIntervalMs"
+  ];
+  for (const name of names) {
+    const value = limits?.[name];
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0))
+      throw new ValidationError(`${name} must be a positive safe integer.`);
+  }
+}
+async function copyEntry(params, entry, isVerification = false) {
+  const hash = createHash2("sha256");
+  const body = entry.read().pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        params.signal?.throwIfAborted();
+        hash.update(chunk);
+        controller.enqueue(chunk);
+      }
+    })
+  );
+  if (isVerification)
+    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),
+      contentLength: entry.contentLength,
+      signal: params.signal
+    });
+  return createHash2("sha256").update(entry.path).update(hash.digest()).digest("hex");
+}
+async function openArchive(params, previous) {
+  const prepared = params.cacheResultArchive ? await prepareCachedArchive({
+    ...params,
+    archiveCacheBypassed: previous?.archiveCacheBypassed,
+    onBypass: async () => {
+      await persistArchiveCacheBypass(params, previous);
+    }
+  }) : void 0;
+  try {
+    return await openArchiveTransport(params, previous, prepared);
+  } catch (error) {
+    if (!prepared?.isCached) throw error;
+    params.signal?.throwIfAborted();
+    const bypass = await persistArchiveCacheBypass(params, previous);
+    return openArchive({ ...params, cacheResultArchive: false }, bypass);
+  }
+}
+async function persistArchiveCacheBypass(params, previous) {
+  const progress = {
+    ...previous?.status === "completed" ? {} : previous,
+    documentId: params.documentId,
+    revisionKey: params.revisionKey,
+    pinnedRevisionKey: params.revisionKey,
+    archiveCacheBypassed: true,
+    status: "running",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await params.storage.writeSyncProgress(progress, { signal: params.signal });
+  return progress;
+}
+async function openArchiveTransport(params, previous, prepared) {
+  const resultUrl = prepared?.resultUrl ?? params.resultUrl;
+  const archiveCacheBypassed = prepared?.archiveCacheBypassed ?? previous?.archiveCacheBypassed;
+  let probe = await fetch(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}).`);
+  }
+  if (prepared) probe = prepared.validateResponse(probe);
+  const identity = prepared?.downloadIdentity ?? 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-YQ5U3VWM.mjs");
+    const source = await openSequentialArchive(
+      { ...params, resultUrl },
+      identity,
+      prepared?.isCached ? prepared.validateResponse : void 0
+    );
+    return { ...source, archiveCacheBypassed };
+  }
+  const options = {
+    forceRangeRequests: true,
+    preventHeadRequest: true,
+    checkResourceChanges: true,
+    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."
+          );
+        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), {
+    useWebWorkers: false,
+    checkCrc32: true
+  });
+  const producers = /* @__PURE__ */ new Set();
+  try {
+    const entries = await reader.getEntries();
+    const files = entries.filter(
+      (entry) => !entry.directory && isSnapshotPath(entry.filename)
+    );
+    const archiveIdentity = createHash2("sha256").update(identity).update(
+      JSON.stringify(
+        files.map((entry) => [entry.filename, entry.uncompressedSize, entry.signature])
+      )
+    ).digest("hex");
+    return {
+      identity: previous?.archiveIdentity === identity ? identity : archiveIdentity,
+      downloadIdentity: identity,
+      archiveCacheBypassed,
+      isCached: prepared?.isCached,
+      canSkipEntries: previous?.archiveIdentity !== identity,
+      entries: (function* () {
+        for (const entry of files)
+          yield {
+            path: normalizeResultPath(entry.filename),
+            contentLength: entry.uncompressedSize,
+            read: () => readRangeEntry(entry, params.signal, producers)
+          };
+      })(),
+      close: async () => {
+        await Promise.all(producers);
+        await reader.close();
+      }
+    };
+  } catch (error) {
+    await reader.close();
+    throw error;
+  }
+}
+function readRangeEntry(entry, signal, producers) {
+  const stream = new TransformStream();
+  const producer = entry.getData(stream.writable, { signal, checkCrc32: true, useWebWorkers: false }).then(
+    () => void 0,
+    async (error) => {
+      try {
+        await stream.writable.abort(error);
+      } catch {
+      }
+    }
+  ).finally(() => {
+    producers.delete(producer);
+  });
+  producers.add(producer);
+  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 createHash2("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,
+  APIError,
+  BadRequestError,
+  AuthenticationError,
+  PaymentRequiredError,
+  PermissionDeniedError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  InternalServerError,
+  ServiceUnavailableError,
+  GatewayTimeoutError,
+  createAPIError,
+  JobFailedError,
+  ParsedDocumentArchiveError,
+  sleep,
+  keysToCamel,
+  keysToSnake,
+  parseDates,
+  enrichJobResult,
+  enrichParseResult,
+  sanitizePath,
+  getFileExtension,
+  jitter,
+  syncParseResultToParsedDocumentStorage,
+  readParsedDocumentCommit,
+  readJsonObject,
+  normalizeResultPath,
+  syncRemoteResultArchive,
+  validateArchiveSyncLimits,
+  isSnapshotPath,
+  createDownloadIdentity
+};