wiki-graph-sdk 0.8.2 → 0.8.4

package/README.md

@@ -40,13 +40,18 @@ const wikiGraph = createWikiGraphSDK({
       libraryRoot: "/path/to/home",
       documentStoreRoot: "/path/to/documents",
     }),
+    stateDir: "/path/to/state",
   },
 });
 ```
 
-Storage is scoped to the SDK instance. Platform services, including lifecycle,
-are process-wide; SDK instances in one process must use one compatible
-platform. `host.storage` and `stateDir` cannot be supplied together.
+Storage and SDK configuration state are scoped to the SDK instance. Platform
+services, including lifecycle, are process-wide; SDK instances in one process
+must use one compatible platform. The top-level `stateDir` remains a shorthand
+for the default Node host. When supplying `host.storage`, put the independent
+configuration root in the required `host.stateDir` field instead. A custom
+`host.storage` without `host.stateDir` is rejected rather than falling back to
+the current user's `~/.wikigraph` directory.
 
 Applications may replace the configured LLM and embedding implementations for
 one SDK instance:
@@ -73,6 +78,11 @@ Job event subscriptions observe durable work without coupling observation to
 cancellation. Call `job.cancel()` explicitly to cancel a job; unsubscribing
 only stops the current listener.
 
+`libraries.searchBuckets()` projects one shared search session into typed,
+independently paginated buckets. Continue one bucket with
+`libraries.continueSearchBucket()`; sibling cursors remain unchanged. The
+existing `libraries.search()` API keeps its sequential single-cursor result.
+
 Services that receive chapter job artifacts as files can apply an ordered,
 lazy sequence through the Node delivery boundary without importing Core:
 

package/dist/archives.cjs

@@ -41,7 +41,7 @@ module.exports = __toCommonJS(archive_exports);
 
 // src/archive/archive.ts
 var import_crypto2 = require("crypto");
-var import_promises4 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 var import_os3 = require("os");
 var import_path5 = require("path");
 var import_stream = require("stream");
@@ -50,7 +50,7 @@ var import_wiki_graph_core7 = require("wiki-graph-core");
 // src/conversions.ts
 var import_crypto = require("crypto");
 var import_fs = require("fs");
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_path4 = require("path");
 var import_wiki_graph_core3 = require("wiki-graph-core");
 
@@ -831,13 +831,15 @@ function getWikiGraphSDKRuntimeContext() {
   };
 }
 function getWikiGraphSDKStateDir() {
-  return getWikiGraphSDKRuntimeContext().stateDir;
+  const context = getWikiGraphSDKRuntimeContext();
+  return context.host?.stateDir ?? context.stateDir;
 }
 function getWikiGraphSDKProviders() {
   return getWikiGraphSDKRuntimeContext().providers ?? {};
 }
 
 // src/local-config.ts
+var import_promises2 = require("fs/promises");
 var import_path = require("path");
 var import_os = require("os");
 var LOCAL_CONFIG_SCHEMA_SQL = `
@@ -867,13 +869,10 @@ function validateLocalConfigSection(section, value) {
   }
 }
 async function withLocalConfigDatabase(operation) {
+  const stateDir = getWikiGraphSDKStateDir() ?? (0, import_path.join)((0, import_os.homedir)(), ".wikigraph");
+  await (0, import_promises2.mkdir)(stateDir, { recursive: true });
   const database = await (0, import_wiki_graph_core.openSharedStateDatabase)(
-    new NodeFile(
-      (0, import_path.join)(
-        getWikiGraphSDKStateDir() ?? (0, import_path.join)((0, import_os.homedir)(), ".wikigraph"),
-        "core.sqlite"
-      )
-    ),
+    new NodeFile((0, import_path.join)(stateDir, "core.sqlite")),
     LOCAL_CONFIG_SCHEMA_SQL
   );
   try {
@@ -1271,7 +1270,7 @@ function resolveWikiGraphRuntimePath(path) {
 }
 
 // src/archive/target.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_path3 = require("path");
 var import_wiki_graph_core2 = require("wiki-graph-core");
 var WikiGraphArchiveOwnershipError = class extends Error {
@@ -1370,7 +1369,7 @@ async function resolveLibraryLocation(target) {
 }
 async function canonicalPath(path) {
   try {
-    return await (0, import_promises2.realpath)(path);
+    return await (0, import_promises3.realpath)(path);
   } catch {
     const absolute = (0, import_path3.resolve)(path);
     const parent = (0, import_path3.dirname)(absolute);
@@ -1421,7 +1420,7 @@ function requireUnambiguousManagedMatch(path, matches) {
 }
 async function readFileIdentity(path) {
   try {
-    const value = await (0, import_promises2.stat)(path);
+    const value = await (0, import_promises3.stat)(path);
     return `${value.dev}:${value.ino}`;
   } catch {
     return void 0;
@@ -1545,7 +1544,7 @@ async function prepareDigestDirectory(path, required) {
   if (!required || normalized === void 0 || normalized === "")
     return void 0;
   const resolved = resolveWikiGraphRuntimePath(normalized);
-  await (0, import_promises3.rm)(resolved, { force: true, recursive: true });
+  await (0, import_promises4.rm)(resolved, { force: true, recursive: true });
   return new NodeDirectory(resolved);
 }
 async function writeArchive(archive, path, format) {
@@ -1901,6 +1900,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";
@@ -1938,10 +2167,10 @@ var WikiGraphArchiveManager = class {
           });
         }
         if (options.replace === true) {
-          await (0, import_promises4.rename)(outputPath, path);
+          await (0, import_promises5.rename)(outputPath, path);
         } else {
           try {
-            await (0, import_promises4.link)(outputPath, path);
+            await (0, import_promises5.link)(outputPath, path);
           } catch (error) {
             if (isNodeEEXISTError(error)) {
               throw new WikiGraphArchiveExistsError(path);
@@ -1951,7 +2180,7 @@ var WikiGraphArchiveManager = class {
         }
         return { locatedUri: (0, import_wiki_graph_core7.formatLocatedWikiGraphUri)(path), path };
       } finally {
-        await (0, import_promises4.rm)(outputPath, { force: true, recursive: true });
+        await (0, import_promises5.rm)(outputPath, { force: true, recursive: true });
       }
     }, options.signal);
   }
@@ -1988,6 +2217,14 @@ var WikiGraphArchiveHandle = class {
   get target() {
     return this.#location.target;
   }
+  async #persistCursor(cursor) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core7.createContinuationCursor)(cursor)
+    );
+  }
+  async #releaseCursor(cursor) {
+    await this.#runtime.run(async () => await (0, import_wiki_graph_core7.deleteContinuationCursor)(cursor));
+  }
   async inspect(options = {}) {
     return await this.#readDocument(
       async (document) => await inspectWikiGraphArchive(document, {
@@ -2002,7 +2239,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
@@ -2023,9 +2260,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 ((0, import_wiki_graph_core7.isSourceLocatorScopeUri)(this.objectUri)) {
         return await (0, import_wiki_graph_core7.listArchiveSourceLocators)(document, this.objectUri, {
           ...options.cursor === void 0 ? {} : { cursor: options.cursor },
@@ -2038,6 +2304,53 @@ var WikiGraphArchiveHandle = class {
         ...chapters === void 0 ? {} : { chapters }
       });
     }, options);
+    if ((0, import_wiki_graph_core7.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(
@@ -2314,19 +2627,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 (0, import_wiki_graph_core7.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
@@ -2346,25 +2670,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 (0, import_wiki_graph_core7.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
@@ -2384,6 +2730,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(
@@ -2572,7 +2929,7 @@ function selectChapterSubtree(chapters, rootChapterId, depth) {
   );
 }
 async function createEmptyArchiveFile(path) {
-  const directoryPath = await (0, import_promises4.mkdtemp)(
+  const directoryPath = await (0, import_promises5.mkdtemp)(
     (0, import_path5.join)((0, import_os3.tmpdir)(), "wikigraph-archive-write-")
   );
   try {
@@ -2587,7 +2944,7 @@ async function createEmptyArchiveFile(path) {
     }
     await (0, import_wiki_graph_core7.writeWikgArchive)(directory, new NodeFile(path));
   } finally {
-    await (0, import_promises4.rm)(directoryPath, { force: true, recursive: true });
+    await (0, import_promises5.rm)(directoryPath, { force: true, recursive: true });
   }
 }
 function isNodeEEXISTError(error) {
@@ -2595,7 +2952,7 @@ function isNodeEEXISTError(error) {
 }
 async function nodePathExists(path) {
   try {
-    await (0, import_promises4.stat)(path);
+    await (0, import_promises5.stat)(path);
     return true;
   } catch (error) {
     if (isNodeENOENTError(error)) return false;