@ontos-ai/knowhere-sdk 2.1.1 → 2.1.3

package/dist/index.js

@@ -1590,10 +1590,6 @@ var import_jszip2 = __toESM(require("jszip"));
 var pageCitationAssetsMetadataKey = "pageAssets";
 var defaultImageContentType = "application/octet-stream";
 var tableContentType = "text/html; charset=utf-8";
-var snapshotManifestKey = "manifest/current.json";
-var snapshotIndexKey = "index.json";
-var defaultSnapshotChunkPageSize = 200;
-var snapshotJsonContentType = "application/json; charset=utf-8";
 async function storeParseResultAssets(result, options) {
   if (!options) {
     return {
@@ -1611,148 +1607,11 @@ async function storeParseResultAssets(result, options) {
     }
   }
   const normalizedResult = Object.keys(assetUrlsByFilePath).length === 0 ? result : rewriteResultAssetUrls(result, assetUrlsByFilePath);
-  const snapshot = await storeParsedSnapshot({
-    result: normalizedResult,
-    assetUrlsByFilePath,
-    keyPrefix: normalizedKeyPrefix,
-    options
-  });
   return {
     result: normalizedResult,
-    assetUrlsByFilePath,
-    snapshot
-  };
-}
-async function storeParsedSnapshot(input) {
-  const pageSize = normalizeSnapshotChunkPageSize(input.options.chunkPageSize);
-  const totalChunks = input.result.chunks.length;
-  const totalPages = Math.max(1, Math.ceil(totalChunks / pageSize));
-  const chunkPageReferences = [];
-  const chunkPageUrlsByPage = {};
-  for (let page = 1; page <= totalPages; page += 1) {
-    const pageChunks = input.result.chunks.slice((page - 1) * pageSize, page * pageSize);
-    const pageKey = `${input.keyPrefix}/chunks/page-${page}.json`;
-    const chunkPage = {
-      version: 1,
-      jobId: input.result.jobId,
-      revisionKey: input.options.revisionKey ?? input.result.jobId,
-      documentId: input.result.documentId,
-      namespace: input.result.namespace,
-      sourceFileName: input.result.manifest.sourceFileName,
-      page,
-      pageSize,
-      total: totalChunks,
-      totalPages,
-      chunks: pageChunks.map(
-        (chunk, index) => toSnapshotChunk(chunk, (page - 1) * pageSize + index + 1)
-      )
-    };
-    const pageUrl = await writeJsonObject({
-      key: pageKey,
-      value: chunkPage,
-      adapter: input.options.adapter
-    });
-    if (pageUrl) chunkPageUrlsByPage[page] = pageUrl;
-    chunkPageReferences.push({
-      page,
-      pageSize,
-      chunkCount: pageChunks.length,
-      key: pageKey,
-      url: pageUrl
-    });
-  }
-  const manifest = {
-    version: 1,
-    kind: "knowhere-parsed-result-snapshot",
-    jobId: input.result.jobId,
-    revisionKey: input.options.revisionKey ?? input.result.jobId,
-    documentId: input.result.documentId,
-    namespace: input.result.namespace,
-    sourceFileName: input.result.manifest.sourceFileName,
-    totalChunks,
-    typeCounts: countSnapshotChunkTypes(input.result.chunks),
-    chunkPageSize: pageSize,
-    chunkPages: chunkPageReferences,
-    assetUrlsByFilePath: input.assetUrlsByFilePath,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const manifestKey = `${input.keyPrefix}/${snapshotManifestKey}`;
-  const indexKey = `${input.keyPrefix}/${snapshotIndexKey}`;
-  const manifestUrl = await writeJsonObject({
-    key: manifestKey,
-    value: manifest,
-    adapter: input.options.adapter
-  });
-  const indexUrl = await writeJsonObject({
-    key: indexKey,
-    value: manifest,
-    adapter: input.options.adapter
-  });
-  return {
-    manifest,
-    manifestKey,
-    manifestUrl,
-    indexKey,
-    indexUrl,
-    chunkPageUrlsByPage
-  };
-}
-function countSnapshotChunkTypes(chunks) {
-  return chunks.reduce(
-    (counts, chunk) => {
-      counts[chunk.type] += 1;
-      return counts;
-    },
-    { text: 0, image: 0, table: 0, page: 0 }
-  );
-}
-async function writeJsonObject(input) {
-  const result = await input.adapter.writeObject({
-    key: input.key,
-    body: Buffer.from(JSON.stringify(input.value, null, 2), "utf8"),
-    contentType: snapshotJsonContentType,
-    metadata: {
-      kind: "knowhere-parsed-result-snapshot"
-    }
-  });
-  return result.url ?? await input.adapter.getObjectUrl?.(result.key) ?? void 0;
-}
-function normalizeSnapshotChunkPageSize(value) {
-  if (!Number.isInteger(value) || value === void 0) return defaultSnapshotChunkPageSize;
-  return Math.min(Math.max(value, 1), 1e3);
-}
-function toSnapshotChunk(chunk, position) {
-  const filePath = getSnapshotChunkFilePath(chunk);
-  return {
-    id: chunk.chunkId,
-    chunkId: chunk.chunkId,
-    chunkType: chunk.type,
-    contentSource: chunk.contentSource,
-    content: chunk.content,
-    sectionPath: normalizeSnapshotSectionPath(chunk.path),
-    sourceChunkPath: chunk.path,
-    filePath,
-    sortOrder: position,
-    metadata: cloneChunkMetadata(chunk.metadata),
-    assetUrl: getSnapshotChunkAssetUrl(chunk)
+    assetUrlsByFilePath
   };
 }
-function normalizeSnapshotSectionPath(path4) {
-  return path4.length > 0 ? path4 : void 0;
-}
-function getSnapshotChunkFilePath(chunk) {
-  if (chunk.type === "image" || chunk.type === "table") {
-    return chunk.filePath;
-  }
-  const filePath = chunk.metadata.filePath;
-  return typeof filePath === "string" ? filePath : void 0;
-}
-function getSnapshotChunkAssetUrl(chunk) {
-  return chunk.type === "image" || chunk.type === "table" ? chunk.assetUrl : void 0;
-}
-function cloneChunkMetadata(metadata) {
-  return { ...metadata };
-}
 async function collectStorageAssets(result, keyPrefix) {
   const resultZip = await loadResultZipForPageCitationAssets(result);
   return [
@@ -1989,108 +1848,212 @@ function isRecord(value) {
 }
 
 // src/storage/parsed-document-storage.ts
-var parsedStorageKeyPrefix = "parsed";
-var manifestStoragePath = "manifest/current.json";
-var indexStoragePath = "index.json";
-var chunkPagePathPattern = /^chunks\/page-(\d+)\.json$/;
+var import_jszip3 = __toESM(require("jszip"));
+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;
-  const adapter = createParsedDocumentObjectStorageAdapter({
-    storage: params.storage,
+  const objects = await collectResultLayoutObjects(params.result);
+  for (const object of objects) {
+    await params.storage.writeObject({
+      documentId,
+      revisionKey,
+      ...object
+    });
+  }
+  const commit = {
+    version: 1,
     documentId,
-    revisionKey
-  });
-  const stored = await storeParseResultAssets(params.result, {
-    adapter,
-    keyPrefix: parsedStorageKeyPrefix,
-    chunkPageSize: params.chunkPageSize,
-    revisionKey
+    revisionKey,
+    source: params.source ?? "resultZip",
+    committedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeParsedDocumentJsonObject(params.storage, {
+    documentId,
+    revisionKey,
+    path: parsedDocumentCommitPath,
+    value: commit
   });
   return {
-    result: stored.result,
-    snapshot: stored.snapshot,
+    result: params.result,
     documentId,
-    revisionKey
+    revisionKey,
+    commit
   };
 }
-function createParsedDocumentObjectStorageAdapter(params) {
-  return {
-    writeObject: (input) => writeParsedStorageObject(params, input),
-    headObject: (key) => headParsedStorageObject(params, key),
-    getObjectUrl: (key) => getParsedStorageObjectUrl(params, key)
-  };
+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;
 }
-async function writeParsedStorageObject(params, input) {
-  const storagePath = stripParsedStorageKeyPrefix(input.key);
-  if (storagePath === manifestStoragePath) {
-    const manifest = JSON.parse(
-      Buffer.from(input.body).toString("utf8")
-    );
-    await params.storage.writeManifest({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      manifest
-    });
-    return { key: input.key };
+function readJsonObject(object) {
+  return JSON.parse(Buffer.from(object.body).toString("utf8"));
+}
+async function collectResultLayoutObjects(result) {
+  const objectsByPath = /* @__PURE__ */ new Map();
+  const rawZipObjects = await collectRawZipObjects(result.rawZip);
+  for (const object of rawZipObjects) {
+    objectsByPath.set(object.path, object);
+  }
+  for (const object of collectGeneratedResultObjects(result)) {
+    if (!objectsByPath.has(object.path)) {
+      objectsByPath.set(object.path, object);
+    }
+  }
+  return [...objectsByPath.values()].filter((object) => !isSdkMetadataPath(object.path));
+}
+async function collectRawZipObjects(rawZip) {
+  try {
+    const zip = await import_jszip3.default.loadAsync(rawZip);
+    const objects = [];
+    for (const entry of Object.values(zip.files)) {
+      if (entry.dir || entry.name === "result.zip") {
+        continue;
+      }
+      objects.push({
+        path: normalizeResultPath(entry.name),
+        body: new Uint8Array(await entry.async("nodebuffer")),
+        contentType: inferContentTypeFromPath(entry.name)
+      });
+    }
+    return objects;
+  } catch {
+    return [];
   }
-  if (storagePath === indexStoragePath) {
-    return { key: input.key };
+}
+function collectGeneratedResultObjects(result) {
+  const objects = [
+    createJsonObject("manifest.json", result.manifest),
+    createJsonObject("chunks.json", keysToSnake(serializeChunks2(result.chunks)))
+  ];
+  if (result.docNav) {
+    objects.push(createJsonObject("doc_nav.json", result.docNav));
+  }
+  if (result.fullMarkdown) {
+    objects.push(createTextObject("full.md", result.fullMarkdown, markdownContentType));
+  }
+  if (result.chunksSlim) {
+    objects.push(createJsonObject("chunks_slim.json", { chunks: result.chunksSlim }));
+  }
+  if (result.hierarchy) {
+    objects.push(createJsonObject("hierarchy.json", result.hierarchy));
+  }
+  if (result.tocHierarchies) {
+    objects.push(createJsonObject("toc_hierarchies.json", result.tocHierarchies));
+  }
+  if (result.kbCsv) {
+    objects.push(createTextObject("kb.csv", result.kbCsv, csvContentType));
   }
-  const chunkPageMatch = storagePath.match(chunkPagePathPattern);
-  if (chunkPageMatch) {
-    const page = JSON.parse(
-      Buffer.from(input.body).toString("utf8")
+  if (result.hierarchyViewHtml) {
+    objects.push(
+      createTextObject("hierarchy_view.html", result.hierarchyViewHtml, htmlContentType)
     );
-    await params.storage.writeChunkPage({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      page
+  }
+  for (const chunk of result.imageChunks) {
+    objects.push({
+      path: normalizeResultPath(chunk.filePath),
+      body: new Uint8Array(chunk.data),
+      contentType: inferContentTypeFromPath(chunk.filePath),
+      metadata: {
+        chunkId: chunk.chunkId,
+        chunkType: chunk.type,
+        sourcePath: chunk.filePath
+      }
     });
-    return { key: input.key };
   }
-  const stored = await params.storage.writeAsset({
-    documentId: params.documentId,
-    revisionKey: params.revisionKey,
-    sourcePath: storagePath,
-    body: input.body,
-    contentType: input.contentType,
-    metadata: input.metadata
-  });
+  for (const chunk of result.tableChunks) {
+    objects.push({
+      path: normalizeResultPath(chunk.filePath),
+      body: Buffer.from(chunk.html, "utf8"),
+      contentType: htmlContentType,
+      metadata: {
+        chunkId: chunk.chunkId,
+        chunkType: chunk.type,
+        sourcePath: chunk.filePath
+      }
+    });
+  }
+  return objects;
+}
+function serializeChunks2(chunks) {
   return {
-    key: input.key,
-    url: stored.url
+    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 headParsedStorageObject(params, key) {
-  const storagePath = stripParsedStorageKeyPrefix(key);
-  if (storagePath === manifestStoragePath || storagePath === indexStoragePath || chunkPagePathPattern.test(storagePath)) {
-    return null;
-  }
-  const url = await params.storage.getAssetUrl({
+async function writeParsedDocumentJsonObject(storage, params) {
+  await storage.writeObject({
     documentId: params.documentId,
     revisionKey: params.revisionKey,
-    sourcePath: storagePath
+    path: params.path,
+    body: Buffer.from(JSON.stringify(params.value, null, 2), "utf8"),
+    contentType: jsonContentType
   });
-  return url ? {
-    key,
-    url
-  } : null;
-}
-async function getParsedStorageObjectUrl(params, key) {
-  const storagePath = stripParsedStorageKeyPrefix(key);
-  if (storagePath === manifestStoragePath || storagePath === indexStoragePath || chunkPagePathPattern.test(storagePath)) {
-    return null;
+}
+function createJsonObject(path4, value) {
+  return {
+    path: path4,
+    body: Buffer.from(JSON.stringify(value, null, 2), "utf8"),
+    contentType: jsonContentType
+  };
+}
+function createTextObject(path4, value, contentType) {
+  return {
+    path: path4,
+    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 params.storage.getAssetUrl({
-    documentId: params.documentId,
-    revisionKey: params.revisionKey,
-    sourcePath: storagePath
-  });
+  return normalized;
 }
-function stripParsedStorageKeyPrefix(key) {
-  const prefix = `${parsedStorageKeyPrefix}/`;
-  return key.startsWith(prefix) ? key.slice(prefix.length) : key;
+function isSdkMetadataPath(path4) {
+  return path4 === ".knowhere-sdk" || path4.startsWith(".knowhere-sdk/");
 }
 
 // src/knowledge/local-store.ts
@@ -2325,7 +2288,6 @@ var MAX_GREP_LIMIT = 50;
 var DEFAULT_CONTEXT_CHARS = 80;
 var DEFAULT_REMOTE_SCAN_PAGE_SIZE = 100;
 var DEFAULT_MAX_SYNC_PAGES = 10;
-var DEFAULT_MAX_SYNC_ASSETS = 20;
 var DEFAULT_SYNC_DEADLINE_MS = 8e3;
 var DEFAULT_GREP_MAX_PAGES = 50;
 var DEFAULT_GREP_DEADLINE_MS = 8e3;
@@ -2333,6 +2295,7 @@ var DEFAULT_OUTLINE_MAX_PAGES = 50;
 var DEFAULT_OUTLINE_DEADLINE_MS = 8e3;
 var SAFE_LOCAL_DOCUMENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 var REMOTE_DOCUMENT_ID_PATTERN = /^doc[_-]/;
+var remoteReconstructionPageDirectory = ".knowhere-sdk/remote-reconstruction/pages";
 var Knowledge = class _Knowledge {
   client;
   store;
@@ -2367,8 +2330,7 @@ var Knowledge = class _Knowledge {
     return {
       document,
       result,
-      assetUrlsByFilePath: storedAssets.assetUrlsByFilePath,
-      parsedSnapshot: storedAssets.snapshot
+      assetUrlsByFilePath: storedAssets.assetUrlsByFilePath
     };
   }
   /** @deprecated Use parseToLocalCache for local cache imports or the top-level client.parse for server-safe parsing. */
@@ -2413,8 +2375,7 @@ var Knowledge = class _Knowledge {
     const result = syncedStorage.result;
     return {
       result,
-      assetUrlsByFilePath: storedAssets.assetUrlsByFilePath,
-      parsedSnapshot: syncedStorage.snapshot ?? storedAssets.snapshot
+      assetUrlsByFilePath: storedAssets.assetUrlsByFilePath
     };
   }
   async importJobResult(params) {
@@ -2426,8 +2387,7 @@ var Knowledge = class _Knowledge {
     return {
       document,
       result,
-      assetUrlsByFilePath: stored.assetUrlsByFilePath,
-      parsedSnapshot: stored.parsedSnapshot
+      assetUrlsByFilePath: stored.assetUrlsByFilePath
     };
   }
   /** @deprecated Use importJobResult for local cache imports or loadJobResult for server-safe loads. */
@@ -2450,14 +2410,13 @@ var Knowledge = class _Knowledge {
         result: loadedResult,
         storage: parsedStorageConfig.storage,
         documentId: loadedResult.documentId ?? normalized.localDocumentId ?? normalized.jobId,
-        revisionKey: params.revisionKey ?? normalized.jobId,
-        chunkPageSize: parsedStorageConfig.limits?.chunkPageSize
+        revisionKey: params.revisionKey ?? normalized.jobId
       });
       return {
         documentId: synced2.documentId,
         revisionKey: synced2.revisionKey,
         completed: true,
-        manifest: synced2.snapshot?.manifest
+        commit: synced2.commit
       };
     }
     if (!normalized.localDocumentId) {
@@ -2468,14 +2427,13 @@ var Knowledge = class _Knowledge {
       result,
       storage: parsedStorageConfig.storage,
       documentId: result.documentId ?? normalized.localDocumentId,
-      revisionKey: params.revisionKey ?? result.jobId,
-      chunkPageSize: parsedStorageConfig.limits?.chunkPageSize
+      revisionKey: params.revisionKey ?? result.jobId
     });
     return {
       documentId: synced.documentId,
       revisionKey: synced.revisionKey,
       completed: true,
-      manifest: synced.snapshot?.manifest
+      commit: synced.commit
     };
   }
   async syncParseResultToConfiguredStorage(result) {
@@ -2485,12 +2443,11 @@ var Knowledge = class _Knowledge {
     }
     const synced = await syncParseResultToParsedDocumentStorage({
       result,
-      storage: parsedStorageConfig.storage,
-      chunkPageSize: parsedStorageConfig.limits?.chunkPageSize
+      storage: parsedStorageConfig.storage
     });
     return {
       result: synced.result,
-      snapshot: synced.snapshot
+      commit: synced.commit
     };
   }
   async parseWithoutClientStorageAdapter(params) {
@@ -2741,10 +2698,7 @@ var Knowledge = class _Knowledge {
       page: pageParams.page,
       pageSize: pageParams.pageSize,
       chunkType: params.chunkType,
-      includeAssetUrls: shouldRequestRemoteAssetUrls(
-        params.assetUrlPolicy,
-        this.parsedStorageConfig
-      )
+      includeAssetUrls: true
     });
     const revisionKey = getRemoteRevisionKey(remotePage);
     const stored = await this.tryReadChunksFromParsedStorage({
@@ -2755,12 +2709,7 @@ var Knowledge = class _Knowledge {
     if (stored) {
       return stored;
     }
-    const chunks = await this.toRemoteReadChunks({
-      documentId,
-      revisionKey,
-      chunks: remotePage.chunks,
-      assetUrlPolicy: params.assetUrlPolicy
-    });
+    const chunks = remotePage.chunks.map((chunk) => toRemoteReadChunk(chunk));
     this.scheduleParsedStorageSync(documentId, revisionKey);
     return {
       document: createRemoteKnowledgeDocument({
@@ -2793,10 +2742,7 @@ var Knowledge = class _Knowledge {
       page: 1,
       pageSize: limits.remotePageSize,
       chunkType: params.chunkType,
-      includeAssetUrls: shouldRequestRemoteAssetUrls(
-        params.assetUrlPolicy,
-        this.parsedStorageConfig
-      )
+      includeAssetUrls: true
     });
     const revisionKey = getRemoteRevisionKey(firstPage);
     const stored = await this.tryReadChunksFromParsedStorage({
@@ -2823,18 +2769,10 @@ var Knowledge = class _Knowledge {
         page,
         pageSize: limits.remotePageSize,
         chunkType: params.chunkType,
-        includeAssetUrls: shouldRequestRemoteAssetUrls(
-          params.assetUrlPolicy,
-          this.parsedStorageConfig
-        )
+        includeAssetUrls: true
       });
     }
-    const chunks = await this.toRemoteReadChunks({
-      documentId,
-      revisionKey,
-      chunks: selected.slice(0, limit),
-      assetUrlPolicy: params.assetUrlPolicy
-    });
+    const chunks = selected.slice(0, limit).map((chunk) => toRemoteReadChunk(chunk));
     this.scheduleParsedStorageSync(documentId, revisionKey);
     return {
       document: createRemoteKnowledgeDocument({
@@ -2870,7 +2808,7 @@ var Knowledge = class _Knowledge {
       page: startPage,
       pageSize: limits.remotePageSize,
       chunkType: params.chunkType,
-      includeAssetUrls: false
+      includeAssetUrls: true
     });
     const revisionKey = getRemoteRevisionKey(firstPage);
     const stored = startPage === 1 ? await this.tryGrepChunksFromParsedStorage({
@@ -2967,7 +2905,7 @@ var Knowledge = class _Knowledge {
         page,
         pageSize: limits.remotePageSize,
         chunkType: params.chunkType,
-        includeAssetUrls: false
+        includeAssetUrls: true
       });
     }
   }
@@ -2982,7 +2920,7 @@ var Knowledge = class _Knowledge {
     const firstPage = await this.client.documents.listChunks(documentId, {
       page: 1,
       pageSize: limits.remotePageSize,
-      includeAssetUrls: false
+      includeAssetUrls: true
     });
     const revisionKey = getRemoteRevisionKey(firstPage);
     const stored = await this.tryReadOutlineFromParsedStorage(documentId, revisionKey);
@@ -3004,7 +2942,7 @@ var Knowledge = class _Knowledge {
       response = await this.client.documents.listChunks(documentId, {
         page,
         pageSize: limits.remotePageSize,
-        includeAssetUrls: false
+        includeAssetUrls: true
       });
     }
     const truncated = response.pagination.page < response.pagination.totalPages;
@@ -3030,28 +2968,13 @@ var Knowledge = class _Knowledge {
     };
   }
   async tryReadChunksFromParsedStorage(params) {
-    const parsedStorageConfig = this.parsedStorageConfig;
-    if (!parsedStorageConfig) {
-      return null;
-    }
-    const manifest = await this.readFreshParsedStorageManifest(
+    const storedResult = await this.readCommittedParsedStorageResult(
       params.documentId,
       params.revisionKey
     );
-    if (!manifest) {
-      return null;
-    }
+    if (!storedResult) return null;
     const pageParams = getReadPageParams(params.params);
-    const indexedChunks = await this.readStoredSnapshotChunks({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      manifest,
-      chunkType: params.params.chunkType
-    });
-    if (!indexedChunks) {
-      return null;
-    }
-    const scopedChunks = indexedChunks.filter((chunk) => matchesReadScope(chunk, params.params));
+    const scopedChunks = storedResult.chunks.filter((chunk) => !params.params.chunkType || chunk.chunkType === params.params.chunkType).filter((chunk) => matchesReadScope(chunk, params.params));
     const selected = hasScanReadFilters(params.params) ? selectReadWindow(
       scopedChunks,
       params.params,
@@ -3060,17 +2983,18 @@ var Knowledge = class _Knowledge {
       (pageParams.page - 1) * pageParams.pageSize,
       pageParams.page * pageParams.pageSize
     );
-    const visibleChunks = applyAssetUrlPolicyToReadChunks(
-      selected.map(toReadChunk),
-      params.params.assetUrlPolicy
-    );
+    const visibleChunks = await applyStoredAssetUrlsToReadChunks({
+      storageConfig: this.requireParsedStorageConfig(),
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      chunks: selected.map(toReadChunk)
+    });
     const totalChunks = scopedChunks.length;
     return {
       document: createStoredKnowledgeDocument({
         documentId: params.documentId,
-        manifest,
-        revisionKey: params.revisionKey,
-        typeCounts: countIndexedTypes(indexedChunks)
+        storedResult,
+        revisionKey: params.revisionKey
       }),
       chunks: visibleChunks,
       page: hasScanReadFilters(params.params) ? void 0 : pageParams.page,
@@ -3081,30 +3005,15 @@ var Knowledge = class _Knowledge {
     };
   }
   async tryGrepChunksFromParsedStorage(params) {
-    const parsedStorageConfig = this.parsedStorageConfig;
-    if (!parsedStorageConfig) {
-      return null;
-    }
-    const manifest = await this.readFreshParsedStorageManifest(
+    const storedResult = await this.readCommittedParsedStorageResult(
       params.documentId,
       params.revisionKey
     );
-    if (!manifest) {
-      return null;
-    }
-    const indexedChunks = await this.readStoredSnapshotChunks({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      manifest,
-      chunkType: params.params.chunkType
-    });
-    if (!indexedChunks) {
-      return null;
-    }
+    if (!storedResult) return null;
     const maxResults = clampLimit(params.params.maxResults, DEFAULT_GREP_LIMIT, MAX_GREP_LIMIT);
     const contextChars = params.params.contextChars ?? DEFAULT_CONTEXT_CHARS;
     const matcher = createMatcher(params.params);
-    const scopedChunks = indexedChunks.filter((chunk) => matchesGrepScope(chunk, params.params));
+    const scopedChunks = storedResult.chunks.filter((chunk) => !params.params.chunkType || chunk.chunkType === params.params.chunkType).filter((chunk) => matchesGrepScope(chunk, params.params));
     const matches = [];
     let scannedChunks = 0;
     for (const chunk of scopedChunks) {
@@ -3125,9 +3034,8 @@ var Knowledge = class _Knowledge {
           return {
             document: createStoredKnowledgeDocument({
               documentId: params.documentId,
-              manifest,
-              revisionKey: params.revisionKey,
-              typeCounts: countIndexedTypes(indexedChunks)
+              storedResult,
+              revisionKey: params.revisionKey
             }),
             matches,
             scannedChunks,
@@ -3139,9 +3047,8 @@ var Knowledge = class _Knowledge {
     return {
       document: createStoredKnowledgeDocument({
         documentId: params.documentId,
-        manifest,
-        revisionKey: params.revisionKey,
-        typeCounts: countIndexedTypes(indexedChunks)
+        storedResult,
+        revisionKey: params.revisionKey
       }),
       matches,
       scannedChunks,
@@ -3149,98 +3056,82 @@ var Knowledge = class _Knowledge {
     };
   }
   async tryReadOutlineFromParsedStorage(documentId, revisionKey) {
-    const manifest = await this.readFreshParsedStorageManifest(documentId, revisionKey);
-    if (!manifest) {
-      return null;
-    }
-    const indexedChunks = await this.readStoredSnapshotChunks({
-      documentId,
-      revisionKey,
-      manifest
-    });
-    if (!indexedChunks) {
-      return null;
-    }
-    const sections = buildFlatSectionsFromIndexedChunks(indexedChunks);
-    const typeCounts = countIndexedTypes(indexedChunks);
+    const storedResult = await this.readCommittedParsedStorageResult(documentId, revisionKey);
+    if (!storedResult) return null;
+    const sections = storedResult.docNav?.sections && storedResult.docNav.sections.length > 0 ? flattenSections(
+      storedResult.docNav.sections.map(
+        (section) => toKnowledgeSection(
+          section,
+          storedResult.chunks,
+          storedResult.manifest.sourceFileName
+        )
+      )
+    ) : buildFlatSectionsFromIndexedChunks(storedResult.chunks);
     return {
       document: createStoredKnowledgeDocument({
         documentId,
-        manifest,
-        revisionKey,
-        typeCounts
+        storedResult,
+        revisionKey
       }),
-      totalChunks: manifest.totalChunks,
-      typeCounts,
+      totalChunks: storedResult.chunks.length,
+      typeCounts: storedResult.typeCounts,
       sections,
-      sectionTree: nestSections(sections),
+      sectionTree: storedResult.docNav?.sections && storedResult.docNav.sections.length > 0 ? storedResult.docNav.sections.map(
+        (section) => toKnowledgeSection(
+          section,
+          storedResult.chunks,
+          storedResult.manifest.sourceFileName
+        )
+      ) : nestSections(sections),
       truncated: false
     };
   }
-  async readFreshParsedStorageManifest(documentId, revisionKey) {
+  async readCommittedParsedStorageResult(documentId, revisionKey) {
     const parsedStorageConfig = this.parsedStorageConfig;
     if (!parsedStorageConfig) {
       return null;
     }
-    const manifest = await parsedStorageConfig.storage.readManifest({
+    const commit = await readParsedDocumentCommit({
+      storage: parsedStorageConfig.storage,
       documentId,
       revisionKey
     });
-    if (!manifest || !isFreshManifest(manifest, revisionKey)) {
+    if (!commit) {
       return null;
     }
-    return manifest;
-  }
-  async readStoredSnapshotChunks(params) {
-    const parsedStorageConfig = this.parsedStorageConfig;
-    if (!parsedStorageConfig) {
+    const [manifestObject, chunksObject, docNavObject] = await Promise.all([
+      parsedStorageConfig.storage.readObject({
+        documentId,
+        revisionKey,
+        path: "manifest.json"
+      }),
+      parsedStorageConfig.storage.readObject({
+        documentId,
+        revisionKey,
+        path: "chunks.json"
+      }),
+      parsedStorageConfig.storage.readObject({
+        documentId,
+        revisionKey,
+        path: "doc_nav.json"
+      })
+    ]);
+    if (!manifestObject || !chunksObject) {
       return null;
     }
-    const chunks = [];
-    for (const pageReference of params.manifest.chunkPages) {
-      const page = await parsedStorageConfig.storage.readChunkPage({
-        documentId: params.documentId,
-        revisionKey: params.revisionKey,
-        page: pageReference.page,
-        chunkType: params.chunkType
-      });
-      if (!page) {
-        return null;
-      }
-      chunks.push(
-        ...page.chunks.filter((chunk) => !params.chunkType || chunk.chunkType === params.chunkType).map(toIndexedSnapshotChunk)
-      );
-    }
-    return chunks.sort((left, right) => left.position - right.position);
-  }
-  async toRemoteReadChunks(params) {
-    const readChunks = params.chunks.map((chunk) => toRemoteReadChunk(chunk));
-    if (params.assetUrlPolicy === "durable") {
-      return this.hardenReadChunkAssetUrls({
-        documentId: params.documentId,
-        revisionKey: params.revisionKey,
-        chunks: readChunks
-      });
-    }
-    return applyAssetUrlPolicyToReadChunks(readChunks, params.assetUrlPolicy);
-  }
-  async hardenReadChunkAssetUrls(params) {
-    const parsedStorageConfig = this.parsedStorageConfig;
-    if (!parsedStorageConfig) {
-      return applyAssetUrlPolicyToReadChunks(params.chunks, "none");
-    }
-    const hardenedChunks = [];
-    for (const chunk of params.chunks) {
-      hardenedChunks.push(
-        await hardenReadChunkAssetUrls({
-          storageConfig: parsedStorageConfig,
-          documentId: params.documentId,
-          revisionKey: params.revisionKey,
-          chunk
-        })
-      );
-    }
-    return hardenedChunks;
+    const manifest = readJsonObject(manifestObject);
+    const chunks = parseStoredResultChunks({
+      payload: readJsonObject(chunksObject),
+      sourceFileName: manifest.sourceFileName
+    });
+    const docNav = docNavObject ? readJsonObject(docNavObject) : void 0;
+    return {
+      commit,
+      manifest,
+      chunks,
+      docNav: docNav?.sections ? { sections: docNav.sections } : void 0,
+      typeCounts: countIndexedTypes(chunks)
+    };
   }
   scheduleParsedStorageSync(documentId, revisionKey) {
     const parsedStorageConfig = this.parsedStorageConfig;
@@ -3260,7 +3151,6 @@ var Knowledge = class _Knowledge {
           documentId,
           revisionKey,
           nextChunkPage: 1,
-          nextAssetIndex: 0,
           status: "failed",
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
           error: error instanceof Error ? error.message : String(error)
@@ -3270,28 +3160,63 @@ var Knowledge = class _Knowledge {
     void Promise.resolve(scheduler.schedule(task)).catch(() => void 0);
   }
   async syncRemoteDocumentToParsedStorage(params) {
-    const limits = getParsedStorageLimits(params.parsedStorageConfig.limits);
-    const existingProgress = params.revisionKey ? await params.parsedStorageConfig.storage.readSyncProgress({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey
-    }) : null;
-    let nextPage = existingProgress?.status === "running" ? existingProgress.nextChunkPage : 1;
-    let response = await this.client.documents.listChunks(params.documentId, {
-      page: nextPage,
-      pageSize: limits.remotePageSize,
+    const firstPage = await this.client.documents.listChunks(params.documentId, {
+      page: 1,
+      pageSize: 1,
       includeAssetUrls: true
     });
-    const revisionKey = params.revisionKey ?? getRemoteRevisionKey(response);
-    if (params.revisionKey && getRemoteRevisionKey(response) !== params.revisionKey) {
-      response = await this.client.documents.listChunks(params.documentId, {
-        page: 1,
-        pageSize: limits.remotePageSize,
-        includeAssetUrls: true
+    const revisionKey = params.revisionKey ?? getRemoteRevisionKey(firstPage);
+    if (params.revisionKey && getRemoteRevisionKey(firstPage) !== params.revisionKey) {
+      return this.syncRemoteDocumentToParsedStorage({
+        documentId: params.documentId,
+        parsedStorageConfig: params.parsedStorageConfig
       });
-      nextPage = 1;
     }
-    const totalPages = response.pagination.totalPages;
-    const chunkPages = [];
+    if (firstPage.jobId) {
+      try {
+        const loadedResult = await this.client.jobs.load(firstPage.jobId);
+        const synced = await syncParseResultToParsedDocumentStorage({
+          result: loadedResult,
+          storage: params.parsedStorageConfig.storage,
+          documentId: params.documentId,
+          revisionKey,
+          source: "resultZip"
+        });
+        await params.parsedStorageConfig.storage.writeSyncProgress({
+          documentId: params.documentId,
+          revisionKey,
+          status: "completed",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          documentId: synced.documentId,
+          revisionKey: synced.revisionKey,
+          completed: true,
+          commit: synced.commit
+        };
+      } catch {
+      }
+    }
+    return this.syncRemoteDocumentChunksToParsedStorage({
+      documentId: params.documentId,
+      revisionKey,
+      firstPage,
+      parsedStorageConfig: params.parsedStorageConfig
+    });
+  }
+  async syncRemoteDocumentChunksToParsedStorage(params) {
+    const limits = getParsedStorageLimits(params.parsedStorageConfig.limits);
+    const existingProgress = await params.parsedStorageConfig.storage.readSyncProgress({
+      documentId: params.documentId,
+      revisionKey: params.revisionKey
+    });
+    let nextPage = existingProgress?.status === "running" ? existingProgress.nextChunkPage ?? 1 : 1;
+    let response = nextPage === 1 && params.firstPage.pagination.pageSize === limits.remotePageSize ? params.firstPage : await this.client.documents.listChunks(params.documentId, {
+      page: nextPage,
+      pageSize: limits.remotePageSize,
+      includeAssetUrls: true
+    });
+    const totalPages = response.pagination.totalPages;
     let syncedPages = 0;
     const startedAt = Date.now();
     while (nextPage <= totalPages) {
@@ -3302,65 +3227,88 @@ var Knowledge = class _Knowledge {
           includeAssetUrls: true
         });
       }
-      const readChunks = await this.hardenReadChunkAssetUrls({
+      await params.parsedStorageConfig.storage.writeObject({
         documentId: params.documentId,
-        revisionKey,
-        chunks: response.chunks.map(toRemoteReadChunk)
-      });
-      const page = toSnapshotChunkPageFromReadChunks({
-        response,
-        revisionKey,
-        chunks: readChunks
-      });
-      await params.parsedStorageConfig.storage.writeChunkPage({
-        documentId: params.documentId,
-        revisionKey,
-        page
+        revisionKey: params.revisionKey,
+        path: getRemoteReconstructionPagePath(response.pagination.page),
+        body: Buffer.from(JSON.stringify({ chunks: response.chunks }), "utf8"),
+        contentType: "application/json; charset=utf-8"
       });
-      chunkPages.push(page);
       nextPage += 1;
       syncedPages += 1;
       await params.parsedStorageConfig.storage.writeSyncProgress({
         documentId: params.documentId,
-        revisionKey,
+        revisionKey: params.revisionKey,
         nextChunkPage: nextPage,
-        nextAssetIndex: 0,
         status: "running",
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       if (syncedPages >= limits.maxPagesPerSync || Date.now() - startedAt >= limits.syncDeadlineMs) {
         return {
           documentId: params.documentId,
-          revisionKey,
+          revisionKey: params.revisionKey,
           completed: false
         };
       }
     }
-    const manifest = createRemoteSnapshotManifest({
-      response,
-      revisionKey,
-      chunkPages
+    const chunks = await this.readRemoteReconstructionChunks({
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      totalPages,
+      parsedStorageConfig: params.parsedStorageConfig
     });
-    await params.parsedStorageConfig.storage.writeManifest({
+    if (!chunks) {
+      return {
+        documentId: params.documentId,
+        revisionKey: params.revisionKey,
+        completed: false
+      };
+    }
+    const synced = await syncParseResultToParsedDocumentStorage({
+      result: createMinimalParseResultFromRemoteChunks({
+        documentId: params.documentId,
+        revisionKey: params.revisionKey,
+        response,
+        chunks
+      }),
+      storage: params.parsedStorageConfig.storage,
       documentId: params.documentId,
-      revisionKey,
-      manifest
+      revisionKey: params.revisionKey,
+      source: "remoteReconstruction"
     });
     await params.parsedStorageConfig.storage.writeSyncProgress({
       documentId: params.documentId,
-      revisionKey,
+      revisionKey: params.revisionKey,
       nextChunkPage: totalPages + 1,
-      nextAssetIndex: 0,
       status: "completed",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     return {
       documentId: params.documentId,
-      revisionKey,
+      revisionKey: params.revisionKey,
       completed: true,
-      manifest
+      commit: synced.commit
     };
   }
+  async readRemoteReconstructionChunks(params) {
+    const chunks = [];
+    for (let page = 1; page <= params.totalPages; page += 1) {
+      const object = await params.parsedStorageConfig.storage.readObject({
+        documentId: params.documentId,
+        revisionKey: params.revisionKey,
+        path: getRemoteReconstructionPagePath(page)
+      });
+      if (!object) {
+        return null;
+      }
+      const payload = readJsonObject(object);
+      if (!isDocumentChunkArray(payload.chunks)) {
+        return null;
+      }
+      chunks.push(...payload.chunks);
+    }
+    return chunks;
+  }
   requireParsedStorageConfig() {
     if (!this.parsedStorageConfig) {
       throw new ValidationError("parsed document storage is not configured");
@@ -3374,7 +3322,8 @@ var Knowledge = class _Knowledge {
   async getPublishedDocumentJobId(documentId) {
     const response = await this.client.documents.listChunks(documentId, {
       page: 1,
-      pageSize: 1
+      pageSize: 1,
+      includeAssetUrls: true
     });
     if (!response.jobId) {
       throw new Error(
@@ -3407,14 +3356,12 @@ var defaultParsedStorageScheduler = {
 };
 function getParsedStorageLimits(limits) {
   return {
-    chunkPageSize: clampLimit(limits?.chunkPageSize, DEFAULT_REMOTE_SCAN_PAGE_SIZE, MAX_PAGE_SIZE),
     remotePageSize: clampLimit(
       limits?.remotePageSize,
       DEFAULT_REMOTE_SCAN_PAGE_SIZE,
       MAX_PAGE_SIZE
     ),
     maxPagesPerSync: clampLimit(limits?.maxPagesPerSync, DEFAULT_MAX_SYNC_PAGES, 1e3),
-    maxAssetsPerSync: clampLimit(limits?.maxAssetsPerSync, DEFAULT_MAX_SYNC_ASSETS, 1e3),
     syncDeadlineMs: clampLimit(limits?.syncDeadlineMs, DEFAULT_SYNC_DEADLINE_MS, 6e4),
     grepMaxPages: clampLimit(limits?.grepMaxPages, DEFAULT_GREP_MAX_PAGES, 1e3),
     grepDeadlineMs: clampLimit(limits?.grepDeadlineMs, DEFAULT_GREP_DEADLINE_MS, 6e4),
@@ -3423,13 +3370,13 @@ function getParsedStorageLimits(limits) {
   };
 }
 function validateReadParams(params) {
-  const usesPagedDisplay = params.page !== void 0 || params.pageSize !== void 0 || params.assetUrlPolicy !== void 0;
+  const usesPagedDisplay = params.page !== void 0 || params.pageSize !== void 0;
   if (!usesPagedDisplay) {
     return;
   }
   if (params.sectionPath !== void 0 || params.startChunk !== void 0 || params.endChunk !== void 0 || params.chunkId !== void 0) {
     throw new ValidationError(
-      "page, pageSize, and assetUrlPolicy cannot be combined with sectionPath, startChunk, endChunk, or chunkId"
+      "page and pageSize cannot be combined with sectionPath, startChunk, endChunk, or chunkId"
     );
   }
 }
@@ -3442,9 +3389,6 @@ function getReadPageParams(params) {
     pageSize: clampLimit(params.pageSize ?? params.limit, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE)
   };
 }
-function shouldRequestRemoteAssetUrls(assetUrlPolicy, parsedStorageConfig) {
-  return assetUrlPolicy === "durable" && parsedStorageConfig !== void 0;
-}
 function getRemoteRevisionKey(response) {
   const revisionKey = response.jobResultId ?? response.jobId;
   if (!revisionKey) {
@@ -3454,6 +3398,9 @@ function getRemoteRevisionKey(response) {
   }
   return revisionKey;
 }
+function getRemoteReconstructionPagePath(page) {
+  return `${remoteReconstructionPageDirectory}/page-${page}.json`;
+}
 function createRemoteKnowledgeDocument(params) {
   return {
     localDocumentId: params.documentId,
@@ -3468,23 +3415,103 @@ function createRemoteKnowledgeDocument(params) {
     updatedAt: /* @__PURE__ */ new Date(0)
   };
 }
+function createMinimalParseResultFromRemoteChunks(params) {
+  const chunks = params.chunks.map(toMinimalChunkFromRemoteChunk);
+  const typeCounts = countRemoteChunkTypes(params.chunks);
+  return {
+    manifest: {
+      version: "2.0",
+      jobId: params.response.jobId ?? params.revisionKey,
+      sourceFileName: params.documentId,
+      statistics: {
+        totalChunks: chunks.length,
+        textChunks: typeCounts.text,
+        imageChunks: typeCounts.image,
+        tableChunks: typeCounts.table,
+        pageChunks: typeCounts.page
+      }
+    },
+    chunks,
+    rawZip: Buffer.from(""),
+    namespace: params.response.namespace,
+    documentId: params.documentId,
+    textChunks: chunks.filter(
+      (chunk) => chunk.type === "text"
+    ),
+    imageChunks: chunks.filter(
+      (chunk) => chunk.type === "image"
+    ),
+    tableChunks: chunks.filter(
+      (chunk) => chunk.type === "table"
+    ),
+    pageChunks: chunks.filter(
+      (chunk) => chunk.type === "page"
+    ),
+    jobId: params.response.jobId ?? params.revisionKey,
+    statistics: {
+      totalChunks: chunks.length,
+      textChunks: typeCounts.text,
+      imageChunks: typeCounts.image,
+      tableChunks: typeCounts.table,
+      pageChunks: typeCounts.page
+    },
+    getChunk: (chunkId) => chunks.find((chunk) => chunk.chunkId === chunkId),
+    save: () => Promise.reject(new Error("Minimal remote reconstruction cannot be saved directly."))
+  };
+}
+function toMinimalChunkFromRemoteChunk(chunk) {
+  const baseChunk = {
+    chunkId: chunk.chunkId,
+    contentSource: chunk.contentSource ?? void 0,
+    content: chunk.content ?? "",
+    path: chunk.sourceChunkPath ?? chunk.sectionPath ?? "",
+    metadata: cloneMetadata(chunk.metadata)
+  };
+  if (chunk.chunkType === "image") {
+    return {
+      ...baseChunk,
+      type: "image",
+      filePath: chunk.filePath ?? "",
+      assetUrl: chunk.assetUrl ?? void 0,
+      data: Buffer.alloc(0),
+      format: inferContentTypeFromPath2(chunk.filePath ?? "").replace("image/", ""),
+      save: () => Promise.resolve(chunk.filePath ?? "")
+    };
+  }
+  if (chunk.chunkType === "table") {
+    return {
+      ...baseChunk,
+      type: "table",
+      filePath: chunk.filePath ?? "",
+      assetUrl: chunk.assetUrl ?? void 0,
+      html: chunk.content ?? "",
+      save: () => Promise.resolve(chunk.filePath ?? "")
+    };
+  }
+  if (chunk.chunkType === "page") {
+    return {
+      ...baseChunk,
+      type: "page"
+    };
+  }
+  return {
+    ...baseChunk,
+    type: "text"
+  };
+}
 function createStoredKnowledgeDocument(params) {
   return {
     localDocumentId: params.documentId,
-    jobId: params.manifest.jobId || params.revisionKey,
-    documentId: params.manifest.documentId ?? params.documentId,
-    namespace: params.manifest.namespace,
-    sourceFileName: params.manifest.sourceFileName,
-    chunkCount: params.manifest.totalChunks,
-    typeCounts: params.typeCounts,
+    jobId: params.storedResult.manifest.jobId || params.revisionKey,
+    documentId: params.documentId,
+    sourceFileName: params.storedResult.manifest.sourceFileName,
+    chunkCount: params.storedResult.chunks.length,
+    typeCounts: params.storedResult.typeCounts,
     resultDirectoryPath: `parsed-storage:${params.documentId}`,
-    createdAt: new Date(params.manifest.createdAt),
-    updatedAt: new Date(params.manifest.createdAt)
+    createdAt: new Date(params.storedResult.commit.committedAt),
+    updatedAt: new Date(params.storedResult.commit.committedAt)
   };
 }
-function isFreshManifest(manifest, revisionKey) {
-  return (manifest.revisionKey ?? manifest.jobId) === revisionKey;
-}
 function toRemoteReadChunk(chunk) {
   const metadata = cloneMetadata(chunk.metadata);
   return {
@@ -3513,22 +3540,60 @@ function toIndexedRemoteChunk(chunk) {
   const readChunk = toRemoteReadChunk(chunk);
   return toIndexedReadChunk(readChunk);
 }
-function toIndexedSnapshotChunk(chunk) {
-  return toIndexedReadChunk({
-    position: chunk.sortOrder,
-    chunkId: chunk.chunkId,
-    chunkType: chunk.chunkType,
-    contentSource: chunk.contentSource,
-    content: chunk.content,
-    readableContent: chunk.chunkType === "page" && typeof chunk.metadata.summary === "string" && chunk.metadata.summary.trim().length > 0 ? chunk.metadata.summary : chunk.content,
-    sectionPath: chunk.sectionPath ?? "",
-    sourceChunkPath: chunk.sourceChunkPath,
-    filePath: chunk.filePath,
-    assetUrl: chunk.assetUrl,
-    pageNumbers: getChunkPageNumbers(chunk.metadata),
-    metadata: cloneMetadata(chunk.metadata)
+function parseStoredResultChunks(params) {
+  const rawChunks = extractStoredChunkRecords(params.payload);
+  return rawChunks.map((record, index) => {
+    const metadata = readRecordMetadata(record);
+    const chunkType = readRecordString(record, "type", "chunkType", "chunk_type");
+    const content = readRecordString(record, "content") ?? "";
+    const sourceChunkPath = readRecordString(record, "path", "sourceChunkPath", "source_chunk_path") ?? "";
+    const chunk = {
+      position: index + 1,
+      chunkId: readRecordString(record, "chunkId", "chunk_id") ?? "",
+      chunkType: isKnowledgeChunkType(chunkType) ? chunkType : "text",
+      contentSource: readRecordString(record, "contentSource", "content_source"),
+      content,
+      readableContent: chunkType === "page" && typeof metadata.summary === "string" && metadata.summary.trim().length > 0 ? metadata.summary : content,
+      sectionPath: normalizeSectionPath(sourceChunkPath, params.sourceFileName),
+      sourceChunkPath,
+      filePath: readRecordString(record, "filePath", "file_path") ?? (typeof metadata.filePath === "string" ? metadata.filePath : void 0),
+      assetUrl: readRecordString(record, "assetUrl", "asset_url"),
+      pageNumbers: getChunkPageNumbers(metadata),
+      metadata
+    };
+    return toIndexedReadChunk(chunk);
   });
 }
+function extractStoredChunkRecords(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter(isRecord2);
+  }
+  if (isRecord2(payload) && Array.isArray(payload.chunks)) {
+    return payload.chunks.filter(isRecord2);
+  }
+  return [];
+}
+function readRecordString(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function readRecordNumber(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number") return value;
+  }
+  return void 0;
+}
+function readRecordMetadata(record) {
+  const metadata = record.metadata;
+  return isRecord2(metadata) ? keysToCamel(metadata) : {};
+}
+function isKnowledgeChunkType(value) {
+  return value === "text" || value === "image" || value === "table" || value === "page";
+}
 function toIndexedReadChunk(chunk) {
   return {
     source: createSyntheticChunk(chunk),
@@ -3582,204 +3647,105 @@ function getNextChunkPosition(chunks, selected) {
   }
   return chunks[chunks.indexOf(lastSelected) + 1]?.position;
 }
-function applyAssetUrlPolicyToReadChunks(chunks, assetUrlPolicy) {
-  if (assetUrlPolicy !== "none") {
-    return chunks.map((chunk) => ({
-      ...chunk,
-      metadata: cloneMetadata(chunk.metadata)
-    }));
-  }
-  return chunks.map((chunk) => ({
-    ...chunk,
-    assetUrl: void 0,
-    metadata: removeAssetUrlsFromMetadata(chunk.metadata)
-  }));
+async function applyStoredAssetUrlsToReadChunks(params) {
+  return Promise.all(
+    params.chunks.map(
+      (chunk) => applyStoredAssetUrlsToReadChunk({
+        ...params,
+        chunk
+      })
+    )
+  );
 }
-async function hardenReadChunkAssetUrls(params) {
+async function applyStoredAssetUrlsToReadChunk(params) {
   const metadata = cloneMetadata(params.chunk.metadata);
-  const assetUrl = await hardenPrimaryAssetUrl(params, metadata);
-  const pageAssets = await hardenPageAssetUrls(params, metadata);
-  if (pageAssets) {
-    metadata.pageAssets = pageAssets;
-  }
-  return {
-    ...params.chunk,
-    assetUrl,
-    metadata
-  };
-}
-async function hardenPrimaryAssetUrl(params, metadata) {
-  if (!params.chunk.assetUrl || !params.chunk.filePath) {
-    return void 0;
-  }
-  return writeDurableAssetUrl({
+  const storedAssetUrl = await getStoredObjectUrl({
     storageConfig: params.storageConfig,
     documentId: params.documentId,
     revisionKey: params.revisionKey,
-    sourcePath: params.chunk.filePath,
-    sourceUrl: params.chunk.assetUrl,
-    fallbackContentType: inferContentTypeFromPath(params.chunk.filePath),
-    metadata: {
-      chunkId: params.chunk.chunkId,
-      chunkType: params.chunk.chunkType,
-      sourcePath: params.chunk.filePath,
-      ...stringifyFlatMetadata(metadata)
-    }
+    path: params.chunk.filePath
   });
-}
-async function hardenPageAssetUrls(params, metadata) {
-  const pageAssets = toUnknownArray(metadata.pageAssets);
-  if (!pageAssets) {
-    return void 0;
-  }
-  const hardenedAssets = [];
-  for (const pageAsset of pageAssets) {
-    if (!isRecord2(pageAsset)) {
-      hardenedAssets.push(pageAsset);
-      continue;
-    }
-    const artifactRef = pageAsset.artifactRef;
-    const sourceUrl = pageAsset.assetUrl;
-    if (typeof artifactRef !== "string" || typeof sourceUrl !== "string") {
-      hardenedAssets.push(removeAssetUrlField(pageAsset));
-      continue;
-    }
-    const durableUrl = await writeDurableAssetUrl({
-      storageConfig: params.storageConfig,
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      sourcePath: artifactRef,
-      sourceUrl,
-      fallbackContentType: typeof pageAsset.contentType === "string" ? pageAsset.contentType : inferContentTypeFromPath(artifactRef),
-      metadata: {
-        chunkId: params.chunk.chunkId,
-        chunkType: params.chunk.chunkType,
-        sourcePath: artifactRef
-      }
-    });
-    const rest = removeAssetUrlField(pageAsset);
-    hardenedAssets.push(durableUrl ? { ...rest, assetUrl: durableUrl } : rest);
-  }
-  return hardenedAssets;
-}
-async function writeDurableAssetUrl(params) {
-  const existingUrl = await params.storageConfig.storage.getAssetUrl({
+  const pageAssets = await applyStoredPageAssetUrls({
+    storageConfig: params.storageConfig,
     documentId: params.documentId,
     revisionKey: params.revisionKey,
-    sourcePath: params.sourcePath
+    metadata
   });
-  if (existingUrl) {
-    return existingUrl;
-  }
-  try {
-    const fetched = await fetchAsset(params.sourceUrl, params.fallbackContentType);
-    const written = await params.storageConfig.storage.writeAsset({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      sourcePath: params.sourcePath,
-      body: fetched.body,
-      contentType: fetched.contentType,
-      metadata: params.metadata
-    });
-    return written.url ?? await params.storageConfig.storage.getAssetUrl({
-      documentId: params.documentId,
-      revisionKey: params.revisionKey,
-      sourcePath: params.sourcePath
-    }) ?? void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function fetchAsset(sourceUrl, fallbackContentType) {
-  const response = await fetch(sourceUrl);
-  if (!response.ok) {
-    throw new Error(`Unable to fetch parsed asset: ${response.status}`);
+  if (pageAssets) {
+    metadata.pageAssets = pageAssets;
+    delete metadata.page_assets;
   }
   return {
-    body: new Uint8Array(await response.arrayBuffer()),
-    contentType: response.headers.get("content-type") ?? fallbackContentType
+    ...params.chunk,
+    assetUrl: storedAssetUrl ?? params.chunk.assetUrl,
+    metadata
   };
 }
-function removeAssetUrlsFromMetadata(metadata) {
-  const cloned = cloneMetadata(metadata);
-  const pageAssets = toUnknownArray(cloned.pageAssets);
+async function applyStoredPageAssetUrls(params) {
+  const pageAssets = getStoredPageAssets(params.metadata);
   if (!pageAssets) {
-    return cloned;
+    return void 0;
   }
-  cloned.pageAssets = pageAssets.map((pageAsset) => {
-    if (!isRecord2(pageAsset)) {
+  return Promise.all(
+    pageAssets.map(async (pageAsset) => {
+      if (!isRecord2(pageAsset)) {
+        return pageAsset;
+      }
+      const artifactRef = readRecordString(pageAsset, "artifactRef", "artifact_ref");
+      if (typeof artifactRef !== "string") {
+        return pageAsset;
+      }
+      const storedAssetUrl = await getStoredObjectUrl({
+        storageConfig: params.storageConfig,
+        documentId: params.documentId,
+        revisionKey: params.revisionKey,
+        path: artifactRef
+      });
+      if (storedAssetUrl) {
+        return {
+          ...pageAsset,
+          artifactRef,
+          assetUrl: storedAssetUrl
+        };
+      }
       return pageAsset;
-    }
-    return removeAssetUrlField(pageAsset);
-  });
-  return cloned;
-}
-function removeAssetUrlField(value) {
-  const cloned = { ...value };
-  delete cloned.assetUrl;
-  return cloned;
-}
-function toSnapshotChunkPageFromReadChunks(params) {
-  return {
-    version: 1,
-    jobId: params.response.jobId ?? params.revisionKey,
-    revisionKey: params.revisionKey,
-    documentId: params.response.documentId,
-    namespace: params.response.namespace,
-    sourceFileName: params.response.documentId,
-    page: params.response.pagination.page,
-    pageSize: params.response.pagination.pageSize,
-    total: params.response.pagination.total,
-    totalPages: params.response.pagination.totalPages,
-    chunks: params.chunks.map(toSnapshotChunkFromReadChunk)
-  };
+    })
+  );
 }
-function toSnapshotChunkFromReadChunk(chunk) {
+function getStoredPageAssets(metadata) {
+  const pageAssets = toUnknownArray(metadata.pageAssets) ?? toUnknownArray(metadata.page_assets) ?? void 0;
+  return pageAssets?.map(normalizeStoredPageAsset);
+}
+function normalizeStoredPageAsset(pageAsset) {
+  if (!isRecord2(pageAsset)) {
+    return pageAsset;
+  }
+  const normalizedPageAsset = { ...pageAsset };
+  delete normalizedPageAsset.page_num;
+  delete normalizedPageAsset.artifact_ref;
+  delete normalizedPageAsset.asset_url;
+  delete normalizedPageAsset.content_type;
+  const pageNum = readRecordNumber(pageAsset, "pageNum", "page_num");
+  const artifactRef = readRecordString(pageAsset, "artifactRef", "artifact_ref");
+  const assetUrl = readRecordString(pageAsset, "assetUrl", "asset_url");
+  const contentType = readRecordString(pageAsset, "contentType", "content_type");
   return {
-    id: chunk.chunkId,
-    chunkId: chunk.chunkId,
-    chunkType: chunk.chunkType,
-    contentSource: chunk.contentSource,
-    content: chunk.content,
-    sectionPath: chunk.sectionPath,
-    sourceChunkPath: chunk.sourceChunkPath,
-    filePath: chunk.filePath,
-    sortOrder: chunk.position,
-    metadata: cloneMetadata(chunk.metadata),
-    assetUrl: chunk.assetUrl
+    ...normalizedPageAsset,
+    ...pageNum === void 0 ? {} : { pageNum },
+    ...artifactRef === void 0 ? {} : { artifactRef },
+    ...assetUrl === void 0 ? {} : { assetUrl },
+    ...contentType === void 0 ? {} : { contentType }
   };
 }
-function createRemoteSnapshotManifest(params) {
-  return {
-    version: 1,
-    kind: "knowhere-parsed-result-snapshot",
-    jobId: params.response.jobId ?? params.revisionKey,
+async function getStoredObjectUrl(params) {
+  if (!params.path) {
+    return void 0;
+  }
+  return await params.storageConfig.storage.getObjectUrl?.({
+    documentId: params.documentId,
     revisionKey: params.revisionKey,
-    documentId: params.response.documentId,
-    namespace: params.response.namespace,
-    sourceFileName: params.response.documentId,
-    totalChunks: params.response.pagination.total,
-    typeCounts: countSnapshotPagesTypes(params.chunkPages),
-    chunkPageSize: params.response.pagination.pageSize,
-    chunkPages: Array.from({ length: params.response.pagination.totalPages }, (_, index) => ({
-      page: index + 1,
-      pageSize: params.response.pagination.pageSize,
-      chunkCount: index + 1 === params.response.pagination.totalPages ? params.response.pagination.total - params.response.pagination.pageSize * (params.response.pagination.totalPages - 1) : params.response.pagination.pageSize,
-      key: `parsed/chunks/page-${index + 1}.json`
-    })),
-    assetUrlsByFilePath: {},
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function countSnapshotPagesTypes(pages) {
-  return pages.flatMap((page) => page.chunks).reduce(
-    (counts, chunk) => {
-      const chunkType = chunk.chunkType;
-      counts[chunkType] += 1;
-      return counts;
-    },
-    { text: 0, image: 0, table: 0, page: 0 }
-  );
+    path: params.path
+  }) ?? void 0;
 }
 function countRemoteChunkTypes(chunks) {
   return chunks.reduce(
@@ -3857,22 +3823,10 @@ function isOptionalNonNegativeInteger(value) {
 function cloneMetadata(metadata) {
   return { ...metadata };
 }
-function stringifyFlatMetadata(metadata) {
-  const entries = Object.entries(metadata).flatMap(([key, value]) => {
-    if (typeof value === "string") {
-      return [[key, value]];
-    }
-    if (typeof value === "number" || typeof value === "boolean") {
-      return [[key, String(value)]];
-    }
-    return [];
-  });
-  return Object.fromEntries(entries);
-}
 function toUnknownArray(value) {
   return Array.isArray(value) ? value : null;
 }
-function inferContentTypeFromPath(filePath) {
+function inferContentTypeFromPath2(filePath) {
   const extension = filePath.split(".").at(-1)?.toLowerCase();
   if (extension === "png") return "image/png";
   if (extension === "jpg" || extension === "jpeg") return "image/jpeg";
@@ -3882,6 +3836,9 @@ function inferContentTypeFromPath(filePath) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isDocumentChunkArray(value) {
+  return Array.isArray(value) && value.every(isRecord2);
+}
 function indexChunks(result) {
   return result.chunks.map((chunk, index) => {
     const filePath = getChunkFilePath2(chunk);
@@ -4327,51 +4284,59 @@ var Knowhere = class {
 var import_crypto3 = require("crypto");
 var import_fs4 = require("fs");
 var import_path4 = __toESM(require("path"));
+var syncProgressPath = ".knowhere-sdk/sync-progress.json";
 var DiskParsedDocumentStorage = class {
   rootDirectory;
   constructor(rootDirectory) {
     this.rootDirectory = rootDirectory;
   }
-  async readManifest(params) {
-    return this.readOptionalJson(
-      this.getManifestPath(params.documentId, params.revisionKey)
-    );
-  }
-  async writeManifest(params) {
-    await this.writeJson(
-      this.getManifestPath(params.documentId, params.revisionKey),
-      params.manifest
-    );
-  }
-  async readChunkPage(params) {
-    return this.readOptionalJson(
-      this.getChunkPagePath(params.documentId, params.revisionKey, params.page)
-    );
-  }
-  async writeChunkPage(params) {
-    await this.writeJson(
-      this.getChunkPagePath(params.documentId, params.revisionKey, params.page.page),
-      params.page
-    );
+  async readObject(params) {
+    const objectPath = this.getObjectPath(params);
+    try {
+      const body = await import_fs4.promises.readFile(objectPath);
+      const metadata = await this.readObjectMetadata(objectPath);
+      return {
+        ...params,
+        body,
+        contentType: metadata?.contentType,
+        contentLength: body.byteLength,
+        metadata: metadata?.metadata,
+        url: toFileUrl(objectPath)
+      };
+    } catch (error) {
+      if (isMissingFileError3(error)) {
+        return null;
+      }
+      throw error;
+    }
   }
-  async writeAsset(params) {
-    const assetPath = this.getAssetPath(params.documentId, params.revisionKey, params.sourcePath);
-    await import_fs4.promises.mkdir(import_path4.default.dirname(assetPath), { recursive: true });
-    await import_fs4.promises.writeFile(assetPath, params.body);
-    await this.writeJson(`${assetPath}.metadata.json`, {
+  async writeObject(params) {
+    const objectPath = this.getObjectPath(params);
+    await import_fs4.promises.mkdir(import_path4.default.dirname(objectPath), { recursive: true });
+    await import_fs4.promises.writeFile(objectPath, params.body);
+    await this.writeObjectMetadata(objectPath, {
       contentType: params.contentType,
-      metadata: params.metadata ?? {}
+      metadata: params.metadata
     });
     return {
-      sourcePath: params.sourcePath,
-      url: toFileUrl(assetPath)
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      path: params.path,
+      url: toFileUrl(objectPath)
     };
   }
-  async getAssetUrl(params) {
-    const assetPath = this.getAssetPath(params.documentId, params.revisionKey, params.sourcePath);
+  async headObject(params) {
+    const objectPath = this.getObjectPath(params);
     try {
-      await import_fs4.promises.access(assetPath);
-      return toFileUrl(assetPath);
+      const stat = await import_fs4.promises.stat(objectPath);
+      const metadata = await this.readObjectMetadata(objectPath);
+      return {
+        ...params,
+        contentType: metadata?.contentType,
+        contentLength: stat.size,
+        metadata: metadata?.metadata,
+        url: toFileUrl(objectPath)
+      };
     } catch (error) {
       if (isMissingFileError3(error)) {
         return null;
@@ -4379,53 +4344,54 @@ var DiskParsedDocumentStorage = class {
       throw error;
     }
   }
-  async readSyncProgress(params) {
-    return this.readOptionalJson(
-      this.getProgressPath(params.documentId, params.revisionKey)
-    );
-  }
-  async writeSyncProgress(params) {
-    await this.writeJson(this.getProgressPath(params.documentId, params.revisionKey), params);
+  async getObjectUrl(params) {
+    const head = await this.headObject(params);
+    return head?.url ?? null;
   }
-  getManifestPath(documentId, revisionKey) {
-    return import_path4.default.join(
-      this.getRevisionDirectory(documentId, revisionKey),
-      "manifest",
-      "current.json"
-    );
+  async deletePrefix(params) {
+    await import_fs4.promises.rm(this.getRevisionDirectory(params.documentId, params.revisionKey), {
+      recursive: true,
+      force: true
+    });
   }
-  getChunkPagePath(documentId, revisionKey, page) {
-    return import_path4.default.join(
-      this.getRevisionDirectory(documentId, revisionKey),
-      "chunks",
-      `page-${page}.json`
-    );
+  async readSyncProgress(params) {
+    return this.readOptionalJson({
+      ...params,
+      path: syncProgressPath
+    });
   }
-  getProgressPath(documentId, revisionKey) {
-    return import_path4.default.join(this.getRevisionDirectory(documentId, revisionKey), "sync-progress.json");
+  async writeSyncProgress(params) {
+    await this.writeObject({
+      documentId: params.documentId,
+      revisionKey: params.revisionKey,
+      path: syncProgressPath,
+      body: Buffer.from(JSON.stringify(params, null, 2), "utf8"),
+      contentType: "application/json; charset=utf-8"
+    });
   }
-  getAssetPath(documentId, revisionKey, sourcePath) {
-    const normalizedSourcePath = normalizeRelativeStoragePath(sourcePath);
-    const assetPath = import_path4.default.resolve(
-      this.getRevisionDirectory(documentId, revisionKey),
-      "assets",
-      normalizedSourcePath
-    );
-    const assetsDirectory = import_path4.default.resolve(
-      this.getRevisionDirectory(documentId, revisionKey),
-      "assets"
-    );
-    if (!isPathInsideDirectory2(assetPath, assetsDirectory)) {
-      throw new Error(`Parsed asset path resolves outside storage: ${sourcePath}`);
+  getObjectPath(params) {
+    const revisionDirectory = this.getRevisionDirectory(params.documentId, params.revisionKey);
+    const objectPath = import_path4.default.resolve(revisionDirectory, normalizeRelativeStoragePath(params.path));
+    if (!isPathInsideDirectory2(objectPath, revisionDirectory)) {
+      throw new Error(`Parsed document object path resolves outside storage: ${params.path}`);
     }
-    return assetPath;
+    return objectPath;
   }
   getRevisionDirectory(documentId, revisionKey) {
     return import_path4.default.join(this.rootDirectory, hashPathPart(documentId), hashPathPart(revisionKey));
   }
-  async readOptionalJson(filePath) {
+  async readOptionalJson(params) {
+    const object = await this.readObject(params);
+    if (!object) {
+      return null;
+    }
+    return JSON.parse(Buffer.from(object.body).toString("utf8"));
+  }
+  async readObjectMetadata(filePath) {
     try {
-      return JSON.parse(await import_fs4.promises.readFile(filePath, "utf8"));
+      return JSON.parse(
+        await import_fs4.promises.readFile(getMetadataPath(filePath), "utf8")
+      );
     } catch (error) {
       if (isMissingFileError3(error)) {
         return null;
@@ -4433,16 +4399,22 @@ var DiskParsedDocumentStorage = class {
       throw error;
     }
   }
-  async writeJson(filePath, value) {
-    await import_fs4.promises.mkdir(import_path4.default.dirname(filePath), { recursive: true });
-    await import_fs4.promises.writeFile(filePath, JSON.stringify(value, null, 2), {
+  async writeObjectMetadata(filePath, metadata) {
+    await import_fs4.promises.writeFile(getMetadataPath(filePath), JSON.stringify(metadata, null, 2), {
       encoding: "utf8",
       flag: "w"
     });
   }
 };
+function getMetadataPath(filePath) {
+  return `${filePath}.metadata.json`;
+}
 function hashPathPart(value) {
-  return (0, import_crypto3.createHash)("sha256").update(value).digest("hex").slice(0, 24);
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new Error("Parsed document storage path part must be a non-empty value.");
+  }
+  return (0, import_crypto3.createHash)("sha256").update(normalized).digest("hex").slice(0, 24);
 }
 function normalizeRelativeStoragePath(value) {
   const normalized = value.replaceAll("\\", "/").replace(/^\.\/+/, "");