wiki-graph-sdk 0.8.3 → 0.8.4

package/dist/archives.d.ts

@@ -1,219 +1,7 @@
-import { ChapterEntry, IndexArtifactKind, ReadonlyDocument, WikiGraphProgressCallback, SearchIndexQueryMode, QueryIndexScope, ArchiveFindOptions, ArchiveFindResult, ArchiveCollectionOptions, ArchiveCollectionResult, ArchiveSourceLocatorResult, readSearchIndexCapabilityStatus, rebuildArchiveSearchIndex, ChapterDetails, ChapterStage, setChapterSource, setChapterTitle, ChapterTree, applyChapterTree, ChapterTreeApplyResult, ArchivePage, ArchiveRelatedResult, ArchiveEvidence, ArchivePack, BookMeta } from 'wiki-graph-core';
-import { W as WikiGraphJobRuntime } from './jobs-CRK-DZ40.js';
-import { W as WikiGraphArchiveTarget } from './target-CZ7elwmj.js';
-export { a as WikiGraphArchiveOwnershipError } from './target-CZ7elwmj.js';
+export { h as WikiGraphArchiveChapterInspection, i as WikiGraphArchiveCover, j as WikiGraphArchiveCreateOptions, k as WikiGraphArchiveCreateResult, l as WikiGraphArchiveEvidenceOptions, m as WikiGraphArchiveExistsError, n as WikiGraphArchiveHandle, o as WikiGraphArchiveIndexArtifactInspection, p as WikiGraphArchiveIndexStatus, q as WikiGraphArchiveIndexSyncOptions, r as WikiGraphArchiveInspection, s as WikiGraphArchiveListOptions, W as WikiGraphArchiveManager, t as WikiGraphArchivePageOptions, u as WikiGraphArchiveRelatedOptions, v as WikiGraphArchiveScope, w as WikiGraphArchiveScopeOptions, x as WikiGraphArchiveSearchOptions, y as WikiGraphArchiveWriteOptions, z as WikiGraphChapterArtifactStatus, B as WikiGraphChapterMoveOptions, D as WikiGraphChapterResetStage, E as WikiGraphChapterSourceOptions, F as WikiGraphChapterTreeInput, G as WikiGraphOperationOptions, S as inspectWikiGraphArchive } from './index-DQzLAnjf.js';
+export { a as WikiGraphArchiveOwnershipError, W as WikiGraphArchiveTarget } from './target-CZ7elwmj.js';
+import 'wiki-graph-core';
+import './jobs-CRK-DZ40.js';
 import './default-worker.js';
 import './runtime-config.js';
 import 'zod';
-
-interface WikiGraphArchiveIndexArtifactInspection {
-    readonly current: boolean;
-    readonly exists: boolean;
-    readonly kind: IndexArtifactKind;
-    readonly sourceRevision?: number;
-}
-interface WikiGraphArchiveChapterInspection {
-    readonly capabilities: {
-        readonly knowledgeGraph: {
-            readonly completed: boolean;
-        };
-        readonly readingGraph: {
-            readonly completed: boolean;
-        };
-        readonly readingSummary: {
-            readonly completed: boolean;
-        };
-    };
-    readonly chapter: ChapterEntry;
-    readonly indexes: {
-        readonly fts: WikiGraphArchiveIndexArtifactInspection;
-        readonly sourceEmbedding: WikiGraphArchiveIndexArtifactInspection;
-        readonly summaryEmbedding: WikiGraphArchiveIndexArtifactInspection;
-    };
-    readonly revision: number;
-    readonly summaryWords: number;
-}
-interface WikiGraphArchiveInspection {
-    readonly archiveUri: string;
-    readonly chapters: readonly WikiGraphArchiveChapterInspection[];
-    readonly localIndexCache: {
-        readonly current: boolean;
-    };
-    readonly scope: {
-        readonly chapterId?: number;
-        readonly type: "archive" | "chapter";
-    };
-    readonly uri: string;
-}
-declare function inspectWikiGraphArchive(document: ReadonlyDocument, options: {
-    readonly archiveUri: string;
-    readonly chapterId?: number;
-}): Promise<WikiGraphArchiveInspection>;
-
-interface WikiGraphOperationOptions {
-    readonly signal?: AbortSignal;
-}
-type SearchIndexCapabilityStatus = Awaited<ReturnType<typeof readSearchIndexCapabilityStatus>>;
-type SearchIndexProgressEvent = Parameters<NonNullable<Parameters<typeof rebuildArchiveSearchIndex>[1]>>[0];
-type WikiGraphChapterResetStage = Exclude<ChapterStage, "summarized">;
-type WikiGraphChapterSourceOptions = NonNullable<Parameters<typeof setChapterSource>[3]>;
-type WikiGraphChapterTreeInput = Parameters<typeof applyChapterTree>[1];
-interface WikiGraphArchiveCreateOptions extends WikiGraphOperationOptions {
-    readonly importPath?: string;
-    readonly onProgress?: WikiGraphProgressCallback;
-    readonly path: string;
-    readonly replace?: boolean;
-}
-interface WikiGraphArchiveCreateResult {
-    readonly locatedUri: string;
-    readonly path: string;
-}
-declare class WikiGraphArchiveExistsError extends Error {
-    readonly code = "WIKI_GRAPH_ARCHIVE_EXISTS";
-    readonly path: string;
-    constructor(path: string);
-}
-interface WikiGraphArchiveWriteOptions extends WikiGraphOperationOptions {
-    readonly onIndexSyncError?: (error: unknown) => void;
-    readonly refreshLibraryIndex?: boolean;
-    readonly searchIndexWritebackPolicy?: "archive" | "cache";
-}
-interface WikiGraphArchiveIndexStatus {
-    readonly capabilities: SearchIndexCapabilityStatus;
-    readonly current: boolean;
-}
-interface WikiGraphArchiveCover {
-    readonly data: Uint8Array;
-    readonly mediaType: string;
-    readonly path: string;
-}
-interface WikiGraphArchiveIndexSyncOptions extends WikiGraphOperationOptions {
-    readonly onProgress?: (event: SearchIndexProgressEvent) => void | Promise<void>;
-    readonly skipUnindexed?: boolean;
-}
-interface WikiGraphChapterArtifactStatus {
-    readonly artifact?: {
-        readonly createdAt: string;
-        readonly metadata: Readonly<Record<string, unknown>>;
-        readonly sourceRevision: number;
-    };
-    readonly chapterId: number;
-    readonly current: boolean;
-    readonly kind: IndexArtifactKind;
-    readonly missing: boolean;
-    readonly revision: number;
-}
-interface WikiGraphChapterMoveOptions {
-    readonly afterPath?: string;
-    readonly beforePath?: string;
-    readonly first?: boolean;
-    readonly last?: boolean;
-    readonly parentPath?: string;
-    readonly root?: boolean;
-}
-interface WikiGraphArchiveScopeOptions {
-    readonly chapters?: readonly number[];
-    readonly depth?: number;
-}
-interface WikiGraphArchiveSearchOptions extends Omit<ArchiveFindOptions, "archiveKey" | "chapters">, WikiGraphArchiveScopeOptions, WikiGraphOperationOptions {
-}
-interface WikiGraphArchiveListOptions extends Omit<ArchiveCollectionOptions, "chapters">, WikiGraphArchiveScopeOptions, WikiGraphOperationOptions {
-}
-interface WikiGraphArchivePageOptions extends WikiGraphOperationOptions {
-    readonly backlinks?: boolean;
-    readonly evidenceLimit?: number;
-    readonly order?: "doc-asc" | "doc-desc";
-    readonly sourceContext?: number;
-}
-interface WikiGraphArchiveRelatedOptions extends WikiGraphOperationOptions {
-    readonly cursor?: string;
-    readonly evidenceLimit?: number;
-    readonly limit?: number;
-    readonly order?: "doc-asc" | "doc-desc";
-    readonly query?: string;
-    readonly queryMode?: SearchIndexQueryMode;
-    readonly role?: "any" | "object" | "self" | "subject";
-    readonly skipUnindexed?: boolean;
-    readonly sourceContext?: number;
-}
-interface WikiGraphArchiveEvidenceOptions extends WikiGraphOperationOptions {
-    readonly cursor?: string;
-    readonly limit?: number;
-    readonly order?: "doc-asc" | "doc-desc";
-    readonly query?: string;
-    readonly queryMode?: SearchIndexQueryMode;
-    readonly skipUnindexed?: boolean;
-    readonly sourceContext?: number;
-}
-interface WikiGraphArchiveScope {
-    readonly chapterIds: readonly number[];
-    readonly entries: readonly ChapterEntry[];
-}
-declare class WikiGraphArchiveManager {
-    #private;
-    constructor(runtime: WikiGraphJobRuntime);
-    create(options: WikiGraphArchiveCreateOptions): Promise<WikiGraphArchiveCreateResult>;
-    open(target: WikiGraphArchiveTarget, options?: WikiGraphOperationOptions): Promise<WikiGraphArchiveHandle>;
-}
-declare class WikiGraphArchiveHandle {
-    #private;
-    constructor(runtime: WikiGraphJobRuntime, location: unknown);
-    get archiveKey(): string;
-    get indexScope(): QueryIndexScope;
-    get locatedUri(): string;
-    get objectUri(): string;
-    get path(): string;
-    get target(): WikiGraphArchiveTarget;
-    inspect(options?: WikiGraphOperationOptions & {
-        readonly chapterId?: number;
-    }): Promise<WikiGraphArchiveInspection>;
-    search(query: string, options?: WikiGraphArchiveSearchOptions): Promise<ArchiveFindResult>;
-    list(options?: WikiGraphArchiveListOptions): Promise<ArchiveCollectionResult | ArchiveSourceLocatorResult>;
-    ensureSearchIndex(options?: WikiGraphArchiveScopeOptions & WikiGraphOperationOptions): Promise<void>;
-    getSearchIndexStatus(options?: WikiGraphOperationOptions): Promise<WikiGraphArchiveIndexStatus>;
-    syncSearchIndex(options?: WikiGraphArchiveIndexSyncOptions): Promise<{
-        readonly rebuilt: boolean;
-    }>;
-    cleanSearchIndex(options?: WikiGraphOperationOptions): Promise<WikiGraphArchiveIndexStatus>;
-    /** Clear cached search sessions without changing the archive index. */
-    clearSearchSessions(options?: WikiGraphOperationOptions): Promise<void>;
-    listChapters(options?: WikiGraphOperationOptions): Promise<readonly ChapterEntry[]>;
-    getChapter(path: string, options?: WikiGraphOperationOptions): Promise<ChapterEntry>;
-    addChapter(options: {
-        readonly parentPath?: string;
-        readonly source?: string;
-        readonly title?: string;
-    }): Promise<ChapterDetails>;
-    getChapterArtifact(path: string, kind: IndexArtifactKind): Promise<WikiGraphChapterArtifactStatus>;
-    deleteChapterArtifact(path: string, kind: IndexArtifactKind): Promise<{
-        readonly chapterId: number;
-        readonly deleted: true;
-        readonly kind: IndexArtifactKind;
-    }>;
-    moveChapter(path: string, options: WikiGraphChapterMoveOptions): Promise<ChapterDetails>;
-    removeChapter(path: string, recursive?: boolean): Promise<void>;
-    resetChapter(path: string, stage: WikiGraphChapterResetStage): Promise<ChapterDetails>;
-    setChapterSource(path: string, source: string, options?: WikiGraphChapterSourceOptions): Promise<ChapterDetails>;
-    setChapterSummary(path: string, summary: string): Promise<ChapterDetails>;
-    setChapterTitle(path: string, title: Parameters<typeof setChapterTitle>[2]): Promise<ChapterDetails>;
-    getChapterTree(): Promise<ChapterTree>;
-    applyChapterTree(tree: WikiGraphChapterTreeInput, options?: {
-        readonly dryRun?: boolean;
-    }): Promise<ChapterTreeApplyResult>;
-    page(objectUri?: string, options?: WikiGraphArchivePageOptions): Promise<ArchivePage>;
-    related(objectUri?: string, options?: WikiGraphArchiveRelatedOptions): Promise<ArchiveRelatedResult>;
-    evidence(objectUri?: string, options?: WikiGraphArchiveEvidenceOptions): Promise<ArchiveEvidence>;
-    pack(objectUri?: string, budget?: number, options?: WikiGraphOperationOptions): Promise<ArchivePack>;
-    getMetadata(objectPath: string, options?: WikiGraphOperationOptions): Promise<Readonly<Record<string, unknown>>>;
-    readBookMeta(options?: WikiGraphOperationOptions): Promise<BookMeta | undefined>;
-    replaceBookMeta(meta: BookMeta, options?: WikiGraphArchiveWriteOptions): Promise<BookMeta>;
-    setArchiveTitle(title: string | null, options?: WikiGraphArchiveWriteOptions): Promise<string | null>;
-    readCover(options?: WikiGraphOperationOptions): Promise<WikiGraphArchiveCover | undefined>;
-    replaceMetadata(objectPath: string, value: Readonly<Record<string, unknown>>, options?: WikiGraphArchiveWriteOptions): Promise<Readonly<Record<string, unknown>>>;
-    putMetadata(objectPath: string, key: string, value: unknown, options?: WikiGraphArchiveWriteOptions): Promise<Readonly<Record<string, unknown>>>;
-    deleteMetadata(objectPath: string, key: string, options?: WikiGraphArchiveWriteOptions): Promise<Readonly<Record<string, unknown>>>;
-    clearMetadata(objectPath: string, options?: WikiGraphArchiveWriteOptions): Promise<Readonly<Record<string, unknown>>>;
-    resolveScope(options?: WikiGraphArchiveScopeOptions & WikiGraphOperationOptions): Promise<WikiGraphArchiveScope | undefined>;
-}
-
-export { type WikiGraphArchiveChapterInspection, type WikiGraphArchiveCover, type WikiGraphArchiveCreateOptions, type WikiGraphArchiveCreateResult, type WikiGraphArchiveEvidenceOptions, WikiGraphArchiveExistsError, WikiGraphArchiveHandle, type WikiGraphArchiveIndexArtifactInspection, type WikiGraphArchiveIndexStatus, type WikiGraphArchiveIndexSyncOptions, type WikiGraphArchiveInspection, type WikiGraphArchiveListOptions, WikiGraphArchiveManager, type WikiGraphArchivePageOptions, type WikiGraphArchiveRelatedOptions, type WikiGraphArchiveScope, type WikiGraphArchiveScopeOptions, type WikiGraphArchiveSearchOptions, WikiGraphArchiveTarget, type WikiGraphArchiveWriteOptions, type WikiGraphChapterArtifactStatus, type WikiGraphChapterMoveOptions, type WikiGraphChapterResetStage, type WikiGraphChapterSourceOptions, type WikiGraphChapterTreeInput, type WikiGraphOperationOptions, inspectWikiGraphArchive };

package/dist/archives.js

@@ -15,6 +15,8 @@ import {
   assertNoActiveBuildJobConflicts,
   assertNoActiveBuildJobs,
   deleteArchiveSearchSessions,
+  createContinuationCursor,
+  deleteContinuationCursor,
   DirectoryDocument,
   findArchiveObjects,
   formatLocatedWikiGraphUri as formatLocatedWikiGraphUri2,
@@ -1925,6 +1927,236 @@ async function writeWikiGraphArchiveLocation(location, operation, options = {})
   });
 }
 
+// src/pages.ts
+function createCursor(implementation) {
+  let released = false;
+  const assertLive = () => {
+    if (released) throw new Error("Cursor has been released.");
+  };
+  return {
+    pageClass: implementation.pageClass,
+    async next(options = {}) {
+      assertLive();
+      return await implementation.next(options);
+    },
+    async token() {
+      assertLive();
+      return await implementation.token();
+    },
+    async release() {
+      if (released) return;
+      released = true;
+      await implementation.release?.();
+    }
+  };
+}
+function createPageCursor(implementation) {
+  let token;
+  return createCursor({
+    pageClass: implementation.pageClass,
+    next: async (options) => await implementation.next(implementation.rawCursor, options),
+    token: async () => {
+      token ??= await implementation.createToken(implementation.rawCursor);
+      return token;
+    },
+    release: async () => {
+      if (token !== void 0) await implementation.releaseToken?.(token);
+      token = void 0;
+    }
+  });
+}
+
+// src/result-pages.ts
+var ArchiveFindPage = class _ArchiveFindPage {
+  result;
+  chapters;
+  items;
+  lens;
+  lensHint;
+  limit;
+  match;
+  rawNextCursor;
+  order;
+  query;
+  terms;
+  types;
+  #cursor;
+  constructor(result, cursor = null) {
+    this.result = result;
+    this.chapters = result.chapters;
+    this.items = result.items;
+    this.lens = result.lens;
+    this.lensHint = result.lensHint;
+    this.limit = result.limit;
+    this.match = result.match;
+    this.rawNextCursor = result.nextCursor;
+    this.order = result.order;
+    this.query = result.query;
+    this.terms = result.terms;
+    this.types = result.types;
+    this.#cursor = cursor;
+  }
+  static pageClass = _ArchiveFindPage;
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  nextCursor() {
+    return this.#cursor;
+  }
+};
+var ArchiveCollectionPage = class _ArchiveCollectionPage {
+  result;
+  chapters;
+  ids;
+  items;
+  limit;
+  rawNextCursor;
+  order;
+  types;
+  #cursor;
+  constructor(result, cursor = null) {
+    this.result = result;
+    this.chapters = result.chapters;
+    this.ids = result.ids;
+    this.items = result.items;
+    this.limit = result.limit;
+    this.rawNextCursor = result.nextCursor;
+    this.order = result.order;
+    this.types = result.types;
+    this.#cursor = cursor;
+  }
+  static pageClass = _ArchiveCollectionPage;
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  nextCursor() {
+    return this.#cursor;
+  }
+};
+var ArchiveEvidencePage = class _ArchiveEvidencePage {
+  result;
+  items;
+  limit;
+  rawNextCursor;
+  #cursor;
+  constructor(result, cursor = null) {
+    this.result = result;
+    this.items = result.items;
+    this.limit = result.limit;
+    this.rawNextCursor = result.nextCursor;
+    this.#cursor = cursor;
+  }
+  static pageClass = _ArchiveEvidencePage;
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  nextCursor() {
+    return this.#cursor;
+  }
+};
+var ArchiveRelatedPage = class _ArchiveRelatedPage {
+  result;
+  items;
+  limit;
+  rawNextCursor;
+  #cursor;
+  constructor(result, cursor = null) {
+    this.result = result;
+    this.items = result.items;
+    this.limit = result.limit;
+    this.rawNextCursor = result.nextCursor;
+    this.#cursor = cursor;
+  }
+  static pageClass = _ArchiveRelatedPage;
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  nextCursor() {
+    return this.#cursor;
+  }
+};
+var ArchiveSourceLocatorPage = class _ArchiveSourceLocatorPage {
+  result;
+  items;
+  limit;
+  rawNextCursor;
+  #cursor;
+  constructor(result, cursor = null) {
+    this.result = result;
+    this.items = result.items;
+    this.limit = result.limit;
+    this.rawNextCursor = result.nextCursor;
+    this.#cursor = cursor;
+  }
+  static pageClass = _ArchiveSourceLocatorPage;
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  nextCursor() {
+    return this.#cursor;
+  }
+};
+function createArchiveFindPage(result, next, createToken, releaseToken) {
+  return new ArchiveFindPage(
+    result,
+    result.nextCursor === null ? null : createPageCursor({
+      pageClass: ArchiveFindPage,
+      rawCursor: result.nextCursor,
+      next,
+      createToken,
+      releaseToken
+    })
+  );
+}
+function createArchiveCollectionPage(result, next, createToken, releaseToken) {
+  return new ArchiveCollectionPage(
+    result,
+    result.nextCursor === null ? null : createPageCursor({
+      pageClass: ArchiveCollectionPage,
+      rawCursor: result.nextCursor,
+      next,
+      createToken,
+      releaseToken
+    })
+  );
+}
+function createArchiveEvidencePage(result, next, createToken, releaseToken) {
+  return new ArchiveEvidencePage(
+    result,
+    result.nextCursor === null ? null : createPageCursor({
+      pageClass: ArchiveEvidencePage,
+      rawCursor: result.nextCursor,
+      next,
+      createToken,
+      releaseToken
+    })
+  );
+}
+function createArchiveRelatedPage(result, next, createToken, releaseToken) {
+  return new ArchiveRelatedPage(
+    result,
+    result.nextCursor === null ? null : createPageCursor({
+      pageClass: ArchiveRelatedPage,
+      rawCursor: result.nextCursor,
+      next,
+      createToken,
+      releaseToken
+    })
+  );
+}
+function createArchiveSourceLocatorPage(result, next, createToken, releaseToken) {
+  return new ArchiveSourceLocatorPage(
+    result,
+    result.nextCursor === null ? null : createPageCursor({
+      pageClass: ArchiveSourceLocatorPage,
+      rawCursor: result.nextCursor,
+      next,
+      createToken,
+      releaseToken
+    })
+  );
+}
+
 // src/archive/archive.ts
 var WikiGraphArchiveExistsError = class extends Error {
   code = "WIKI_GRAPH_ARCHIVE_EXISTS";
@@ -2012,6 +2244,14 @@ var WikiGraphArchiveHandle = class {
   get target() {
     return this.#location.target;
   }
+  async #persistCursor(cursor) {
+    return await this.#runtime.run(
+      async () => await createContinuationCursor(cursor)
+    );
+  }
+  async #releaseCursor(cursor) {
+    await this.#runtime.run(async () => await deleteContinuationCursor(cursor));
+  }
   async inspect(options = {}) {
     return await this.#readDocument(
       async (document) => await inspectWikiGraphArchive(document, {
@@ -2026,7 +2266,7 @@ var WikiGraphArchiveHandle = class {
       options.queryMode,
       options.signal
     );
-    return await this.#writeDocument(
+    const result = await this.#writeDocument(
       async (document) => {
         const chapters = await this.#resolveQueryChapters(document, options, {
           embeddingProvider
@@ -2047,9 +2287,38 @@ var WikiGraphArchiveHandle = class {
         ...options.signal === void 0 ? {} : { signal: options.signal }
       }
     );
+    return createArchiveFindPage(
+      result,
+      async (cursor, nextOptions) => await this.search(query, {
+        ...options,
+        cursor,
+        ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+        ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+      }),
+      (cursor) => this.#persistCursor({
+        archiveKey: this.archiveKey,
+        archivePath: this.path,
+        chapters: options.chapters ?? null,
+        cursor,
+        format: "json",
+        indexScope: this.indexScope,
+        kind: "search",
+        ...options.backlinks === void 0 ? {} : { backlinks: options.backlinks },
+        ...options.evidenceLimit === void 0 ? {} : { evidenceLimit: options.evidenceLimit },
+        ...options.match === void 0 ? {} : { match: options.match },
+        ...options.order === void 0 ? {} : { order: options.order },
+        query,
+        ...options.queryMode === void 0 ? {} : { queryMode: options.queryMode },
+        ...options.skipUnindexed === void 0 ? {} : { skipUnindexed: options.skipUnindexed },
+        ...options.sourceContext === void 0 ? {} : { sourceContext: options.sourceContext },
+        ...options.triplePattern === void 0 ? {} : { triplePattern: options.triplePattern },
+        types: options.types ?? null
+      }),
+      (token) => this.#releaseCursor(token)
+    );
   }
   async list(options = {}) {
-    return await this.#readDocument(async (document) => {
+    const result = await this.#readDocument(async (document) => {
       if (isSourceLocatorScopeUri(this.objectUri)) {
         return await listArchiveSourceLocators(document, this.objectUri, {
           ...options.cursor === void 0 ? {} : { cursor: options.cursor },
@@ -2062,6 +2331,53 @@ var WikiGraphArchiveHandle = class {
         ...chapters === void 0 ? {} : { chapters }
       });
     }, options);
+    if (isSourceLocatorScopeUri(this.objectUri)) {
+      return createArchiveSourceLocatorPage(
+        result,
+        async (cursor, nextOptions) => await this.list({
+          ...options,
+          cursor,
+          ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+          ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+        }),
+        (cursor) => this.#persistCursor({
+          archiveKey: this.archiveKey,
+          archivePath: this.path,
+          cursor,
+          format: "json",
+          indexScope: this.indexScope,
+          kind: "source-locators",
+          targetUri: this.objectUri
+        }),
+        (token) => this.#releaseCursor(token)
+      );
+    }
+    return createArchiveCollectionPage(
+      result,
+      async (cursor, nextOptions) => await this.list({
+        ...options,
+        cursor,
+        ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+        ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+      }),
+      (cursor) => this.#persistCursor({
+        archiveKey: this.archiveKey,
+        archivePath: this.path,
+        ...options.backlinks === void 0 ? {} : { backlinks: options.backlinks },
+        chapters: options.chapters ?? null,
+        cursor,
+        ...options.evidenceLimit === void 0 ? {} : { evidenceLimit: options.evidenceLimit },
+        format: "json",
+        ids: options.ids ?? null,
+        indexScope: this.indexScope,
+        kind: "collection",
+        order: options.order ?? "doc-asc",
+        ...options.sourceContext === void 0 ? {} : { sourceContext: options.sourceContext },
+        ...options.triplePattern === void 0 ? {} : { triplePattern: options.triplePattern },
+        types: options.types ?? null
+      }),
+      (token) => this.#releaseCursor(token)
+    );
   }
   async ensureSearchIndex(options = {}) {
     const embeddingProvider = await this.#runtime.run(
@@ -2338,19 +2654,30 @@ var WikiGraphArchiveHandle = class {
       if (options.queryMode !== void 0) {
         throw new Error("`queryMode` requires `query`.");
       }
-      return await this.#readDocument(async (document) => {
+      const result2 = await this.#readDocument(async (document) => {
         const chapters = await this.#resolveScope(document, {});
         return await listRelatedArchiveObjects(document, objectUri, {
           ...withoutOperation(options),
           ...chapters === void 0 ? {} : { chapters }
         });
       }, options);
+      return createArchiveRelatedPage(
+        result2,
+        async (cursor, nextOptions) => await this.related(objectUri, {
+          ...options,
+          cursor,
+          ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+          ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+        }),
+        (cursor) => Promise.resolve(cursor),
+        () => Promise.resolve()
+      );
     }
     const embeddingProvider = await this.#resolveQueryEmbeddingProvider(
       options.queryMode,
       options.signal
     );
-    return await this.#writeDocument(
+    const result = await this.#writeDocument(
       async (document) => {
         const chapters = await this.#resolveQueryChapters(document, options, {
           embeddingProvider
@@ -2370,25 +2697,47 @@ var WikiGraphArchiveHandle = class {
         ...options.signal === void 0 ? {} : { signal: options.signal }
       }
     );
+    return createArchiveRelatedPage(
+      result,
+      async (cursor, nextOptions) => await this.related(objectUri, {
+        ...options,
+        cursor,
+        ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+        ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+      }),
+      (cursor) => Promise.resolve(cursor),
+      () => Promise.resolve()
+    );
   }
   async evidence(objectUri = this.objectUri, options = {}) {
     if (options.query === void 0) {
       if (options.queryMode !== void 0) {
         throw new Error("`queryMode` requires `query`.");
       }
-      return await this.#readDocument(async (document) => {
+      const result2 = await this.#readDocument(async (document) => {
         const chapters = await this.#resolveScope(document, {});
         return await listArchiveEvidence(document, objectUri, {
           ...withoutOperation(options),
           ...chapters === void 0 ? {} : { chapters }
         });
       }, options);
+      return createArchiveEvidencePage(
+        result2,
+        async (cursor, nextOptions) => await this.evidence(objectUri, {
+          ...options,
+          cursor,
+          ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+          ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+        }),
+        (cursor) => Promise.resolve(cursor),
+        () => Promise.resolve()
+      );
     }
     const embeddingProvider = await this.#resolveQueryEmbeddingProvider(
       options.queryMode,
       options.signal
     );
-    return await this.#writeDocument(
+    const result = await this.#writeDocument(
       async (document) => {
         const chapters = await this.#resolveQueryChapters(document, options, {
           embeddingProvider
@@ -2408,6 +2757,17 @@ var WikiGraphArchiveHandle = class {
         ...options.signal === void 0 ? {} : { signal: options.signal }
       }
     );
+    return createArchiveEvidencePage(
+      result,
+      async (cursor, nextOptions) => await this.evidence(objectUri, {
+        ...options,
+        cursor,
+        ...nextOptions.limit === void 0 ? {} : { limit: nextOptions.limit },
+        ...nextOptions.signal === void 0 ? {} : { signal: nextOptions.signal }
+      }),
+      (cursor) => Promise.resolve(cursor),
+      () => Promise.resolve()
+    );
   }
   async pack(objectUri = this.objectUri, budget = 5e3, options = {}) {
     return await this.#readDocument(