wiki-graph-sdk 0.7.0

package/dist/index.cjs

@@ -0,0 +1,4760 @@
+globalThis.__WIKIGRAPH_DATA_DIR__ ??= require("path").resolve(__dirname, "data");
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DANGEROUS_RUNTIME_ENV_NAMES: () => DANGEROUS_RUNTIME_ENV_NAMES,
+  DEFAULT_EXTRACTION_PROMPT: () => import_wiki_graph_core8.DEFAULT_EXTRACTION_PROMPT,
+  DEFAULT_GENERATION_JOB_CONCURRENCY: () => DEFAULT_GENERATION_JOB_CONCURRENCY,
+  DEFAULT_GENERATION_REQUEST_CONCURRENCY: () => DEFAULT_GENERATION_REQUEST_CONCURRENCY,
+  DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT: () => import_wiki_graph_core8.DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT,
+  LLMPaymentRequiredError: () => import_wiki_graph_core16.LLMPaymentRequiredError,
+  LOCAL_CONFIG_SECTIONS: () => LOCAL_CONFIG_SECTIONS,
+  NodeDirectory: () => NodeDirectory,
+  NodeFile: () => NodeFile,
+  WIKI_GRAPH_URI_PREFIX: () => import_wiki_graph_core16.WIKI_GRAPH_URI_PREFIX,
+  WikiGraphArchiveExistsError: () => WikiGraphArchiveExistsError,
+  WikiGraphArchiveHandle: () => WikiGraphArchiveHandle,
+  WikiGraphArchiveManager: () => WikiGraphArchiveManager,
+  WikiGraphConfigManager: () => WikiGraphConfigManager,
+  WikiGraphContinuationManager: () => WikiGraphContinuationManager,
+  WikiGraphConversionManager: () => WikiGraphConversionManager,
+  WikiGraphError: () => import_wiki_graph_core16.WikiGraphError,
+  WikiGraphJob: () => WikiGraphJob,
+  WikiGraphJobManager: () => WikiGraphJobManager,
+  WikiGraphLibrary: () => WikiGraphLibrary,
+  WikiGraphLibraryManager: () => WikiGraphLibraryManager,
+  WikiGraphMaintenanceManager: () => WikiGraphMaintenanceManager,
+  WikiGraphSDK: () => WikiGraphSDK,
+  buildSearchIndexEmbeddingProvider: () => buildSearchIndexEmbeddingProvider,
+  buildWikiGraphLLMOptions: () => buildWikiGraphLLMOptions,
+  clearLocalConfigSection: () => clearLocalConfigSection,
+  createEntryRuntimeContext: () => createEntryRuntimeContext,
+  createGenerationPerformanceHints: () => createGenerationPerformanceHints,
+  createNodeTemplateEnvironment: () => createNodeTemplateEnvironment,
+  createNodeWikiGraphStorage: () => createNodeWikiGraphStorage,
+  createStageLLM: () => createStageLLM,
+  createWikiGraphArchiveInspectReport: () => createWikiGraphArchiveInspectReport,
+  createWikiGraphSDK: () => createWikiGraphSDK,
+  deleteLocalConfigValue: () => deleteLocalConfigValue,
+  embedQueryText: () => embedQueryText,
+  embedQueryTextWithLocalConfig: () => embedQueryTextWithLocalConfig,
+  ensureNodeWikiGraphPlatform: () => ensureNodeWikiGraphPlatform,
+  formatError: () => import_wiki_graph_core16.formatError,
+  formatGenerationPlanningDuration: () => formatGenerationPlanningDuration,
+  formatGenerationPlanningModel: () => formatGenerationPlanningModel,
+  formatLocatedChapterResourceUri: () => import_wiki_graph_core16.formatLocatedChapterResourceUri,
+  formatLocatedChapterSourceCollectionUri: () => import_wiki_graph_core16.formatLocatedChapterSourceCollectionUri,
+  formatLocatedChapterUri: () => import_wiki_graph_core16.formatLocatedChapterUri,
+  formatLocatedWikiGraphUri: () => import_wiki_graph_core16.formatLocatedWikiGraphUri,
+  formatWikiGraphCommandUri: () => import_wiki_graph_core16.formatWikiGraphCommandUri,
+  formatWikiGraphLibraryUri: () => import_wiki_graph_core16.formatWikiGraphLibraryUri,
+  getNodeResourcePath: () => getNodeResourcePath,
+  getWikiGraphSDKRuntimeContext: () => getWikiGraphSDKRuntimeContext,
+  getWikiGraphSDKStateDir: () => getWikiGraphSDKStateDir,
+  installNodeWikiGraphPlatform: () => installNodeWikiGraphPlatform,
+  isSourceLocatorScopeUri: () => import_wiki_graph_core16.isSourceLocatorScopeUri,
+  isWikiGraphLibraryUri: () => import_wiki_graph_core16.isWikiGraphLibraryUri,
+  loadRequiredStageConfig: () => loadRequiredStageConfig,
+  loadWikiGraphRuntimeConfig: () => loadWikiGraphRuntimeConfig,
+  maskLocalConfigSection: () => maskLocalConfigSection,
+  nodeWikiGraphPlatform: () => nodeWikiGraphPlatform,
+  nodeWikispineCommandRunner: () => nodeWikispineCommandRunner,
+  normalizeLocalConfigKey: () => normalizeLocalConfigKey,
+  parseChapterPath: () => import_wiki_graph_core16.parseChapterPath,
+  parseChapterTreeInput: () => import_wiki_graph_core16.parseChapterTreeInput,
+  parseChapterUriPath: () => import_wiki_graph_core16.parseChapterUriPath,
+  parseLocalConfigSection: () => parseLocalConfigSection,
+  parseLocatedWikiGraphUri: () => import_wiki_graph_core16.parseLocatedWikiGraphUri,
+  parseSourceTextJsonl: () => import_wiki_graph_core16.parseSourceTextJsonl,
+  parseWikiGraphLibraryUri: () => import_wiki_graph_core16.parseWikiGraphLibraryUri,
+  parseWikiGraphUriSyntax: () => import_wiki_graph_core16.parseWikiGraphUriSyntax,
+  planGenerationTask: () => planGenerationTask,
+  putLocalConfigValue: () => putLocalConfigValue,
+  readLocalConfigSection: () => readLocalConfigSection,
+  readWikiGraphEmbeddingConfig: () => readWikiGraphEmbeddingConfig,
+  replaceLocalConfigSection: () => replaceLocalConfigSection,
+  requireKnowledgeGraphWikispineConfig: () => requireKnowledgeGraphWikispineConfig,
+  resolveExtractionPrompt: () => import_wiki_graph_core8.resolveExtractionPrompt,
+  resolveHostedProviderEndpoint: () => resolveHostedProviderEndpoint,
+  resolveKnowledgeGraphRecallPrompt: () => import_wiki_graph_core8.resolveKnowledgeGraphRecallPrompt,
+  resolveWikiGraphArchiveLocation: () => resolveWikiGraphArchiveLocation,
+  resolveWikispineConfig: () => resolveWikispineConfig,
+  runWikiGraphQueueWorker: () => runWikiGraphQueueWorker,
+  validateLocalConfigSection: () => validateLocalConfigSection,
+  withNodeWikiGraphStorage: () => withNodeWikiGraphStorage,
+  withWikiGraphSDKRuntimeContext: () => withWikiGraphSDKRuntimeContext,
+  writeNodeFileHandle: () => writeNodeFileHandle
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/archive/archive.ts
+var import_crypto = require("crypto");
+var import_promises3 = require("fs/promises");
+var import_os3 = require("os");
+var import_path3 = require("path");
+var import_stream = require("stream");
+var import_wiki_graph_core5 = require("wiki-graph-core");
+
+// src/conversions.ts
+var import_promises2 = require("fs/promises");
+var import_wiki_graph_core2 = require("wiki-graph-core");
+
+// src/llm.ts
+var import_anthropic = require("@ai-sdk/anthropic");
+var import_google = require("@ai-sdk/google");
+var import_openai = require("@ai-sdk/openai");
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+function buildWikiGraphLLMOptions(config) {
+  const llm = config.llm;
+  if (llm?.provider === void 0 || llm.model === void 0) {
+    throw new Error(
+      "Missing LLM configuration. Set --llm for one run, or configure `wikg://local/config/llm` with provider and model."
+    );
+  }
+  return {
+    model: createLanguageModel(llm.provider, llm.model, {
+      apiKey: llm.apiKey,
+      baseURL: llm.baseURL,
+      name: llm.name
+    }),
+    ...config.concurrent?.request === void 0 ? {} : { concurrent: config.concurrent.request }
+  };
+}
+function createLanguageModel(provider, model, options) {
+  switch (provider) {
+    case "anthropic": {
+      const anthropic = (0, import_anthropic.createAnthropic)({
+        ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+        ...options.name === void 0 ? {} : { name: options.name }
+      });
+      return anthropic(model);
+    }
+    case "google": {
+      const google = (0, import_google.createGoogleGenerativeAI)({
+        ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+        ...options.name === void 0 ? {} : { name: options.name }
+      });
+      return google(model);
+    }
+    case "openai": {
+      if (options.baseURL !== void 0) {
+        throw new Error(
+          "openai does not accept llm.baseURL or baseURL in --llm JSON. Use openai-compatible for third-party OpenAI-style APIs."
+        );
+      }
+      const openai = (0, import_openai.createOpenAI)({
+        ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+        ...options.name === void 0 ? {} : { name: options.name }
+      });
+      return openai(model);
+    }
+    case "openai-compatible": {
+      if (options.baseURL === void 0) {
+        throw new Error(
+          "openai-compatible requires llm.baseURL or baseURL in --llm JSON."
+        );
+      }
+      const openaiCompatible = (0, import_openai_compatible.createOpenAICompatible)({
+        baseURL: options.baseURL,
+        name: options.name ?? createOpenAICompatibleName(options.baseURL),
+        ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey }
+      });
+      return openaiCompatible(model);
+    }
+  }
+}
+function createOpenAICompatibleName(baseURL) {
+  try {
+    return new URL(baseURL).hostname;
+  } catch {
+    return "openai-compatible";
+  }
+}
+
+// src/node-platform.ts
+var asyncHooks = __toESM(require("async_hooks"), 1);
+var crypto = __toESM(require("crypto"), 1);
+var fs = __toESM(require("fs"), 1);
+var fsPromises = __toESM(require("fs/promises"), 1);
+var os = __toESM(require("os"), 1);
+var pathModule = __toESM(require("path"), 1);
+var process2 = __toESM(require("process"), 1);
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+var sqlite3 = __toESM(require("sqlite3"), 1);
+var yauzl = __toESM(require("yauzl"), 1);
+var yazl = __toESM(require("yazl"), 1);
+var import_nunjucks = require("nunjucks");
+var import_platform = require("wiki-graph-core/platform");
+var nodeProcess = process2.default ?? process2;
+var nodeSqlite3 = sqlite3.default ?? sqlite3;
+var NODE_RESOURCE_KIND = /* @__PURE__ */ Symbol.for("wiki-graph-sdk.node-resource.v1");
+var NodeFile = class {
+  constructor(path, name = pathModule.basename(path)) {
+    this.path = path;
+    this.identity = encodeNodeResourceIdentity("file", path);
+    this.name = name;
+  }
+  path;
+  kind = "file";
+  [NODE_RESOURCE_KIND] = "file";
+  identity;
+  name;
+  async openReader() {
+    const handle = await fsPromises.open(this.path, "r");
+    let closed = false;
+    try {
+      const stats = await handle.stat();
+      if (!stats.isFile())
+        throw new Error("File reader requires a regular file");
+      const { size } = stats;
+      return {
+        size,
+        close: async () => {
+          if (!closed) await handle.close();
+          closed = true;
+        },
+        read: async (offset, length) => {
+          if (closed) throw new Error("Cannot read from a closed FileReader");
+          assertFileRange(offset, length, size);
+          const buffer = Buffer.allocUnsafe(length);
+          let bytesRead = 0;
+          while (bytesRead < length) {
+            const result = await handle.read(
+              buffer,
+              bytesRead,
+              length - bytesRead,
+              offset + bytesRead
+            );
+            if (result.bytesRead === 0) {
+              throw new Error("File changed while reading its byte range");
+            }
+            bytesRead += result.bytesRead;
+          }
+          return new Uint8Array(buffer.buffer, buffer.byteOffset, bytesRead);
+        }
+      };
+    } catch (error) {
+      await handle.close();
+      throw error;
+    }
+  }
+  async getLastModified() {
+    try {
+      return (await fsPromises.stat(this.path)).mtimeMs;
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async openWriter() {
+    await fsPromises.mkdir(pathModule.dirname(this.path), { recursive: true });
+    const temporary = `${this.path}.tmp-${crypto.randomUUID()}`;
+    const handle = await fsPromises.open(temporary, "wx");
+    let closed = false;
+    return {
+      write: async (data) => {
+        if (closed) throw new Error("Cannot write to a closed FileWriter");
+        await writeNodeFileHandle(handle, data);
+      },
+      writeAt: async (offset, data) => {
+        if (closed) throw new Error("Cannot write to a closed FileWriter");
+        assertFileOffset(offset);
+        await writeNodeFileHandle(handle, data, offset);
+      },
+      commit: async () => {
+        if (!closed) {
+          await handle.close();
+          await fsPromises.rename(temporary, this.path);
+        }
+        closed = true;
+      },
+      abort: async () => {
+        if (!closed) {
+          await handle.close();
+          await fsPromises.rm(temporary, { force: true });
+        }
+        closed = true;
+      }
+    };
+  }
+};
+async function writeNodeFileHandle(handle, data, position) {
+  const buffer = Buffer.from(data);
+  let written = 0;
+  while (written < buffer.byteLength) {
+    const result = await handle.write(
+      buffer,
+      written,
+      buffer.byteLength - written,
+      position === void 0 ? null : position + written
+    );
+    if (result.bytesWritten === 0) {
+      throw new Error("File writer made no progress");
+    }
+    written += result.bytesWritten;
+  }
+}
+function assertFileRange(offset, length, size) {
+  assertFileOffset(offset);
+  if (!Number.isSafeInteger(length) || length < 0) {
+    throw new RangeError(
+      "File read length must be a non-negative safe integer"
+    );
+  }
+  if (offset > size || length > size - offset) {
+    throw new RangeError("File read range exceeds the file size");
+  }
+}
+function assertFileOffset(offset) {
+  if (!Number.isSafeInteger(offset) || offset < 0) {
+    throw new RangeError("File offset must be a non-negative safe integer");
+  }
+}
+var NodeDirectory = class _NodeDirectory {
+  constructor(path) {
+    this.path = path;
+    this.identity = encodeNodeResourceIdentity("directory", path);
+    this.name = pathModule.basename(path);
+  }
+  path;
+  kind = "directory";
+  [NODE_RESOURCE_KIND] = "directory";
+  identity;
+  name;
+  async getFile(name) {
+    assertChildName(name);
+    const file = new NodeFile(pathModule.join(this.path, name));
+    try {
+      return (await fsPromises.stat(file.path)).isFile() ? file : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async getLastModified() {
+    try {
+      return (await fsPromises.stat(this.path)).mtimeMs;
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getDirectory(name) {
+    assertChildName(name);
+    const directory = new _NodeDirectory(pathModule.join(this.path, name));
+    try {
+      return (await fsPromises.stat(directory.path)).isDirectory() ? directory : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async list() {
+    const entries = await fsPromises.readdir(this.path, {
+      withFileTypes: true
+    });
+    return entries.map(
+      (entry) => entry.isDirectory() ? new _NodeDirectory(pathModule.join(this.path, entry.name)) : new NodeFile(pathModule.join(this.path, entry.name), entry.name)
+    );
+  }
+  async createFile(name) {
+    assertChildName(name);
+    await fsPromises.mkdir(this.path, { recursive: true });
+    const file = new NodeFile(pathModule.join(this.path, name));
+    await fsPromises.writeFile(file.path, "", { flag: "wx" });
+    return file;
+  }
+  async createDirectory(name) {
+    assertChildName(name);
+    await fsPromises.mkdir(this.path, { recursive: true });
+    const directory = new _NodeDirectory(pathModule.join(this.path, name));
+    await fsPromises.mkdir(directory.path);
+    return directory;
+  }
+  async remove(name, options) {
+    assertChildName(name);
+    await fsPromises.rm(pathModule.join(this.path, name), {
+      force: true,
+      recursive: options?.recursive === true
+    });
+  }
+};
+function encodeNodeResourceIdentity(kind, path) {
+  return `node-${kind}:${Buffer.from(pathModule.resolve(path), "utf8").toString("base64url")}`;
+}
+function decodeNodeResourceIdentity(identity, kind) {
+  const prefix = `node-${kind}:`;
+  if (!identity.startsWith(prefix)) {
+    return pathModule.isAbsolute(identity) ? identity : void 0;
+  }
+  try {
+    return Buffer.from(identity.slice(prefix.length), "base64url").toString(
+      "utf8"
+    );
+  } catch {
+    return void 0;
+  }
+}
+function getNodeResourcePath(resource) {
+  const brandedPath = getBrandedNodeResourcePath(resource, resource.kind);
+  if (brandedPath !== void 0) return brandedPath;
+  if (typeof resource === "object" && resource !== null && "path" in resource && typeof resource.path === "string") {
+    return resource.path;
+  }
+  throw new TypeError("Expected a Node File or Directory resource");
+}
+function assertChildName(name) {
+  if (name.length === 0 || name === "." || name === ".." || pathModule.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+    throw new TypeError(`Directory child must be a relative name: ${name}`);
+  }
+}
+var NodeDatabaseConnection = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  async close() {
+    await new Promise((resolve3, reject) => {
+      this.database.close((error) => {
+        if (error) reject(error);
+        else resolve3();
+      });
+    });
+  }
+  async execute(sql) {
+    await new Promise((resolve3, reject) => {
+      this.database.exec(sql, (error) => {
+        if (error) reject(error);
+        else resolve3();
+      });
+    });
+  }
+  async queryAll(sql, params = []) {
+    return await new Promise((resolve3, reject) => {
+      this.database.all(sql, [...params], (error, rows) => {
+        if (error) reject(error);
+        else resolve3(rows);
+      });
+    });
+  }
+  async queryOne(sql, params = []) {
+    return await new Promise((resolve3, reject) => {
+      this.database.get(sql, [...params], (error, row) => {
+        if (error) reject(error);
+        else resolve3(row);
+      });
+    });
+  }
+  async run(sql, params = []) {
+    await new Promise((resolve3, reject) => {
+      this.database.run(sql, [...params], (error) => {
+        if (error) reject(error);
+        else resolve3();
+      });
+    });
+  }
+};
+async function openNodeDatabase(file, options) {
+  const flags = (options.mode === "readonly" ? nodeSqlite3.OPEN_READONLY : nodeSqlite3.OPEN_READWRITE | (options.create ? nodeSqlite3.OPEN_CREATE : 0)) | nodeSqlite3.OPEN_FULLMUTEX;
+  return new NodeDatabaseConnection(await openNativeNodeDatabase(file, flags));
+}
+async function openNativeNodeDatabase(file, flags) {
+  const path = getBrandedNodeResourcePath(file, "file");
+  if (path === void 0) {
+    throw new TypeError("The Node database adapter requires a NodeFile");
+  }
+  return await new Promise((resolve3, reject) => {
+    const database = new nodeSqlite3.Database(path, flags, (error) => {
+      if (error) reject(error);
+      else resolve3(database);
+    });
+  });
+}
+async function openNodeZip(file) {
+  const path = getBrandedNodeResourcePath(file, "file");
+  if (path === void 0) {
+    throw new TypeError("The Node ZIP adapter requires a NodeFile");
+  }
+  const zipFile = await new Promise((resolve3, reject) => {
+    yauzl.open(
+      path,
+      { autoClose: false, lazyEntries: true },
+      (error, opened) => {
+        if (error || opened === void 0)
+          reject(error ?? new Error("Cannot open ZIP"));
+        else resolve3(opened);
+      }
+    );
+  });
+  const entries = await new Promise(
+    (resolve3, reject) => {
+      const discovered = /* @__PURE__ */ new Map();
+      const rejectAndClose = (error) => {
+        zipFile.close();
+        reject(
+          error instanceof Error ? error : new Error("Cannot scan ZIP central directory")
+        );
+      };
+      const resolveEntries = () => {
+        zipFile.off("error", rejectAndClose);
+        resolve3(discovered);
+      };
+      zipFile.on("entry", (entry) => {
+        if (!entry.fileName.endsWith("/")) {
+          discovered.set(entry.fileName, entry);
+        }
+        zipFile.readEntry();
+      });
+      zipFile.once("error", rejectAndClose);
+      zipFile.once("end", resolveEntries);
+      zipFile.readEntry();
+    }
+  );
+  let closed = false;
+  return {
+    close: () => {
+      if (!closed) zipFile.close();
+      closed = true;
+      return Promise.resolve();
+    },
+    copyEntry: async (name, target) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return false;
+      await copyNodeZipEntry(zipFile, entry, target);
+      return true;
+    },
+    getEntrySize: (name) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      return Promise.resolve(entries.get(name)?.uncompressedSize);
+    },
+    listEntries: () => Promise.resolve([...entries.keys()]),
+    readEntryRange: async (name, offset, length) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return void 0;
+      return await readNodeZipEntryRange(zipFile, entry, offset, length);
+    },
+    readEntry: async (name) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return void 0;
+      return await readNodeZipEntry(zipFile, entry);
+    }
+  };
+}
+async function copyNodeZipEntry(zipFile, entry, target) {
+  const writer = await target.openWriter();
+  try {
+    const stream = await openNodeZipEntryStream(zipFile, entry);
+    await writeNodeStream(stream, writer);
+    await writer.commit();
+  } catch (error) {
+    await writer.abort().catch(() => void 0);
+    throw error;
+  }
+}
+async function readNodeZipEntry(zipFile, entry) {
+  return await collectNodeStream(await openNodeZipEntryStream(zipFile, entry));
+}
+async function readNodeZipEntryRange(zipFile, entry, offset, length) {
+  assertFileRange(offset, length, entry.uncompressedSize);
+  if (length === 0) return new Uint8Array();
+  if (entry.compressionMethod !== 0) {
+    const content2 = await collectDecodedNodeStreamRange(
+      await openNodeZipEntryStream(zipFile, entry),
+      offset,
+      length
+    );
+    return new Uint8Array(
+      content2.buffer,
+      content2.byteOffset,
+      content2.byteLength
+    );
+  }
+  const content = await collectNodeStream(
+    await openNodeZipEntryStream(zipFile, entry, {
+      decompress: null,
+      decrypt: null,
+      end: offset + length,
+      start: offset
+    })
+  );
+  return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+}
+async function collectDecodedNodeStreamRange(input, offset, length) {
+  const chunks = [];
+  const end = offset + length;
+  let position = 0;
+  let collected = 0;
+  for await (const value of input) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    const chunkEnd = position + chunk.byteLength;
+    if (chunkEnd > offset && position < end) {
+      const selected = chunk.subarray(
+        Math.max(0, offset - position),
+        Math.min(chunk.byteLength, end - position)
+      );
+      chunks.push(selected);
+      collected += selected.byteLength;
+    }
+    position = chunkEnd;
+    if (position >= end) break;
+  }
+  if (collected !== length) {
+    throw new Error("ZIP entry changed while reading its byte range");
+  }
+  return Buffer.concat(chunks, collected);
+}
+async function openNodeZipEntryStream(zipFile, entry, options) {
+  return await new Promise((resolve3, reject) => {
+    const callback = (error, opened) => {
+      if (error || opened === void 0) {
+        reject(error ?? new Error(`Cannot read ZIP entry: ${entry.fileName}`));
+      } else {
+        resolve3(opened);
+      }
+    };
+    if (options === void 0) zipFile.openReadStream(entry, callback);
+    else zipFile.openReadStream(entry, options, callback);
+  });
+}
+async function writeNodeZip(file, entries) {
+  const zipFile = new yazl.ZipFile();
+  const writer = await file.openWriter();
+  const outputStream = zipFile.outputStream;
+  const outputDone = writeNodeStream(outputStream, writer);
+  const entryState = { cancelled: false, complete: false };
+  let iterator;
+  try {
+    iterator = getNodeZipEntryIterator(entries);
+    const entriesDone = addNodeZipEntries(zipFile, iterator, entryState);
+    await Promise.race([entriesDone, outputDone]);
+    if (!entryState.complete) {
+      throw new Error("ZIP output ended before entry production completed");
+    }
+    zipFile.end();
+    await outputDone;
+    await writer.commit();
+  } catch (error) {
+    entryState.cancelled = true;
+    if (!entryState.complete && iterator !== void 0) {
+      closeNodeZipEntryIterator(iterator);
+    }
+    if (!outputStream.destroyed) {
+      outputStream.destroy(
+        error instanceof Error ? error : new Error("Cannot write ZIP archive")
+      );
+    }
+    await outputDone.catch(() => void 0);
+    await writer.abort().catch(() => void 0);
+    throw error;
+  }
+}
+async function addNodeZipEntries(zipFile, iterator, state) {
+  while (!state.cancelled) {
+    const result = await iterator.next();
+    if (state.cancelled) return;
+    if (result.done) {
+      state.complete = true;
+      return;
+    }
+    if ("file" in result.value) {
+      zipFile.addReadStream(
+        createNodeFileReadStream(result.value.file),
+        result.value.name,
+        { compress: false }
+      );
+    } else if ("data" in result.value) {
+      zipFile.addBuffer(Buffer.from(result.value.data), result.value.name, {
+        compress: false
+      });
+    } else {
+      zipFile.addReadStream(
+        createNodeRangeReadStream(result.value),
+        result.value.name,
+        { compress: false, size: result.value.size }
+      );
+    }
+  }
+}
+function createNodeFileReadStream(file) {
+  return import_node_stream.Readable.from(
+    (async function* () {
+      const reader = await file.openReader();
+      try {
+        for (let offset = 0; offset < reader.size; ) {
+          const chunk = await reader.read(
+            offset,
+            Math.min(64 * 1024, reader.size - offset)
+          );
+          offset += chunk.byteLength;
+          yield chunk;
+        }
+      } finally {
+        await reader.close();
+      }
+    })()
+  );
+}
+function getBrandedNodeResourcePath(resource, kind) {
+  if (typeof resource !== "object" || resource === null) return void 0;
+  const candidate = resource;
+  return candidate[NODE_RESOURCE_KIND] === kind && typeof candidate.path === "string" ? candidate.path : void 0;
+}
+function createNodeRangeReadStream(entry) {
+  return import_node_stream.Readable.from(
+    (async function* () {
+      for (let offset = 0; offset < entry.size; ) {
+        const chunk = await entry.read(
+          offset,
+          Math.min(64 * 1024, entry.size - offset)
+        );
+        offset += chunk.byteLength;
+        yield chunk;
+      }
+    })()
+  );
+}
+function getNodeZipEntryIterator(entries) {
+  const asyncIterator = entries[Symbol.asyncIterator];
+  return asyncIterator === void 0 ? entries[Symbol.iterator]() : asyncIterator.call(entries);
+}
+function closeNodeZipEntryIterator(iterator) {
+  if (iterator.return === void 0) return;
+  try {
+    void Promise.resolve(iterator.return()).catch(() => void 0);
+  } catch {
+  }
+}
+async function writeNodeStream(input, writer) {
+  await (0, import_promises.pipeline)(
+    input,
+    new import_node_stream.Writable({
+      write: (chunk, _encoding, callback) => {
+        void writer.write(chunk).then(
+          () => callback(),
+          (error) => callback(
+            error instanceof Error ? error : new Error("Cannot stream ZIP archive")
+          )
+        );
+      }
+    })
+  );
+}
+async function collectNodeStream(input) {
+  return await new Promise((resolve3, reject) => {
+    const chunks = [];
+    input.on("data", (chunk) => chunks.push(chunk));
+    input.once("error", reject);
+    input.once("end", () => resolve3(Buffer.concat(chunks)));
+  });
+}
+var nodeWikiGraphPlatform = {
+  asyncContext: {
+    create: () => new asyncHooks.AsyncLocalStorage()
+  },
+  database: { open: openNodeDatabase },
+  lifecycle: {
+    instanceId: `node-process:${nodeProcess.pid}`,
+    isInstanceAlive: (instanceId) => {
+      const match = /^node-process:(\d+)$/u.exec(instanceId);
+      if (match === null) return Promise.resolve(void 0);
+      try {
+        nodeProcess.kill(Number(match[1]), 0);
+        return Promise.resolve(true);
+      } catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH") {
+          return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+      }
+    }
+  },
+  resources: {
+    getDirectory: (identity) => {
+      const path = decodeNodeResourceIdentity(identity, "directory");
+      return Promise.resolve(
+        path === void 0 ? void 0 : new NodeDirectory(path)
+      );
+    },
+    getFile: (identity) => {
+      const path = decodeNodeResourceIdentity(identity, "file");
+      return Promise.resolve(
+        path === void 0 ? void 0 : new NodeFile(path)
+      );
+    },
+    resolveLegacyDirectory: (reference) => {
+      const path = decodeNodeResourceIdentity(reference, "directory");
+      return Promise.resolve(
+        path === void 0 ? void 0 : new NodeDirectory(path)
+      );
+    }
+  },
+  templates: {
+    createEnvironment: (options) => new import_nunjucks.Environment(new NodeTemplateLoader(), options)
+  },
+  zip: {
+    open: openNodeZip,
+    write: writeNodeZip
+  }
+};
+var NodeTemplateLoader = class extends import_nunjucks.Loader {
+  #dataDirectory;
+  constructor(dataDirectory) {
+    super();
+    this.#dataDirectory = dataDirectory;
+  }
+  getSource(templateName) {
+    const name = (0, import_platform.normalizeTemplateName)(templateName);
+    const filePath = pathModule.join(
+      this.#dataDirectory ?? resolveNodeDataDirectory(),
+      name
+    );
+    return {
+      noCache: false,
+      path: name,
+      src: fs.readFileSync(filePath, "utf8")
+    };
+  }
+};
+function createNodeTemplateEnvironment(dataDirectory, options = {}) {
+  return new import_nunjucks.Environment(new NodeTemplateLoader(dataDirectory), {
+    autoescape: options.autoescape ?? true,
+    trimBlocks: options.trimBlocks ?? true
+  });
+}
+function resolveNodeDataDirectory() {
+  const injected = globalThis.__WIKIGRAPH_DATA_DIR__;
+  if (typeof injected === "string" && injected !== "") return injected;
+  let directory = nodeProcess.cwd();
+  while (true) {
+    for (const candidate of [
+      pathModule.join(directory, "data"),
+      pathModule.join(directory, "packages", "core", "data")
+    ]) {
+      try {
+        if (fs.statSync(candidate).isDirectory()) return candidate;
+      } catch {
+      }
+    }
+    const parent = pathModule.dirname(directory);
+    if (parent === directory)
+      throw new Error("Could not locate data directory");
+    directory = parent;
+  }
+}
+function createNodeWikiGraphStorage(stateRoot = pathModule.join(os.homedir(), ".wikigraph")) {
+  return {
+    library: new NodeDirectory(stateRoot),
+    documentStore: new NodeDirectory(pathModule.join(stateRoot, "documents"))
+  };
+}
+function installNodeWikiGraphPlatform(stateRoot) {
+  (0, import_platform.installWikiGraphPlatform)(nodeWikiGraphPlatform);
+  (0, import_platform.installWikiGraphStorage)(createNodeWikiGraphStorage(stateRoot));
+}
+function ensureNodeWikiGraphPlatform() {
+  (0, import_platform.installWikiGraphPlatform)(nodeWikiGraphPlatform);
+  try {
+    (0, import_platform.getWikiGraphStorage)();
+  } catch {
+    (0, import_platform.installWikiGraphStorage)(createNodeWikiGraphStorage());
+  }
+}
+async function withNodeWikiGraphStorage(stateRoot, operation) {
+  return await (0, import_platform.withWikiGraphStorage)(
+    stateRoot === void 0 ? void 0 : createNodeWikiGraphStorage(stateRoot),
+    operation
+  );
+}
+
+// src/runtime-config.ts
+var import_zod = require("zod");
+
+// src/local-config.ts
+var import_wiki_graph_core = require("wiki-graph-core");
+
+// src/runtime-context.ts
+var import_async_hooks = require("async_hooks");
+var RUNTIME_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("wiki-graph-sdk.runtime-context.v1");
+var runtimeContext = getRuntimeContextStorage();
+function getRuntimeContextStorage() {
+  const runtimeGlobal = globalThis;
+  const existing = runtimeGlobal[RUNTIME_CONTEXT_KEY];
+  if (existing !== void 0) {
+    return existing;
+  }
+  const storage = new import_async_hooks.AsyncLocalStorage();
+  Object.defineProperty(runtimeGlobal, RUNTIME_CONTEXT_KEY, {
+    configurable: false,
+    enumerable: false,
+    value: storage,
+    writable: false
+  });
+  return storage;
+}
+async function withWikiGraphSDKRuntimeContext(context, operation) {
+  return await runtimeContext.run(context, operation);
+}
+function getWikiGraphSDKRuntimeContext() {
+  return runtimeContext.getStore() ?? {
+    cwd: process.cwd(),
+    env: process.env,
+    envPolicy: "production"
+  };
+}
+function getWikiGraphSDKStateDir() {
+  return getWikiGraphSDKRuntimeContext().stateDir;
+}
+
+// src/local-config.ts
+var import_path = require("path");
+var import_os = require("os");
+var LOCAL_CONFIG_SECTIONS = [
+  "concurrent",
+  "embeddings",
+  "llm",
+  "wikimedia",
+  "wikispine"
+];
+var LOCAL_CONFIG_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS config_sections (
+  section TEXT PRIMARY KEY,
+  value_json TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+`;
+async function readLocalConfigSection(section) {
+  return await withLocalConfigDatabase(async (database) => {
+    return await readLocalConfigSectionInDatabase(database, section);
+  });
+}
+async function replaceLocalConfigSection(section, value) {
+  const normalized = validateLocalConfigSection(section, value);
+  return await withLocalConfigDatabase(async (database) => {
+    await writeLocalConfigSectionInDatabase(database, section, normalized);
+    return normalized;
+  });
+}
+async function putLocalConfigValue(section, key, value) {
+  return await withLocalConfigDatabase(async (database) => {
+    const current = await readLocalConfigSectionInDatabase(database, section);
+    const next = validateLocalConfigSection(section, {
+      ...current,
+      [normalizeLocalConfigKey(section, key)]: value
+    });
+    await writeLocalConfigSectionInDatabase(database, section, next);
+    return next;
+  });
+}
+async function deleteLocalConfigValue(section, key) {
+  return await withLocalConfigDatabase(async (database) => {
+    const current = await readLocalConfigSectionInDatabase(database, section);
+    const normalizedKey = normalizeLocalConfigKey(section, key);
+    const { [normalizedKey]: _removed, ...nextInput } = current;
+    const next = validateLocalConfigSection(section, nextInput);
+    await writeLocalConfigSectionInDatabase(database, section, next);
+    return next;
+  });
+}
+async function clearLocalConfigSection(section) {
+  return await replaceLocalConfigSection(section, {});
+}
+function parseLocalConfigSection(value) {
+  if (value === "embedding") {
+    return "embeddings";
+  }
+  return LOCAL_CONFIG_SECTIONS.find((section) => section === value);
+}
+function maskLocalConfigSection(section, value) {
+  if (section !== "llm" && section !== "embeddings" && section !== "wikimedia" && section !== "wikispine" || value.apiKey === void 0 && value.token === void 0) {
+    return value;
+  }
+  return {
+    ...value,
+    ...value.apiKey === void 0 ? {} : { apiKey: "****" },
+    ...value.token === void 0 ? {} : { token: "****" }
+  };
+}
+function normalizeLocalConfigKey(section, key) {
+  const normalized = key.trim();
+  if (normalized === "") {
+    throw new Error("Config key cannot be empty.");
+  }
+  if (section === "llm" || section === "embeddings") {
+    switch (normalized) {
+      case "api-key":
+        return "apiKey";
+      case "base-url":
+        return "baseURL";
+      default:
+        return normalized;
+    }
+  }
+  return normalized;
+}
+function validateLocalConfigSection(section, value) {
+  switch (section) {
+    case "embeddings":
+      return validateEmbeddingsConfig(value);
+    case "llm":
+      return validateLLMConfig(value);
+    case "concurrent":
+      return validateConcurrentConfig(value);
+    case "wikimedia":
+      return validateWikimediaConfig(value);
+    case "wikispine":
+      return validateWikispineConfig(value);
+  }
+}
+async function withLocalConfigDatabase(operation) {
+  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"
+      )
+    ),
+    LOCAL_CONFIG_SCHEMA_SQL
+  );
+  try {
+    return await operation(database);
+  } finally {
+    await database.close();
+  }
+}
+async function readLocalConfigSectionInDatabase(database, section) {
+  const value = await database.queryOne(
+    "SELECT value_json FROM config_sections WHERE section = ?",
+    [section],
+    (row) => String(row.value_json)
+  );
+  return value === void 0 ? {} : parseSectionJSON(section, value);
+}
+async function writeLocalConfigSectionInDatabase(database, section, value) {
+  await database.run(
+    `
+INSERT INTO config_sections (section, value_json, updated_at)
+VALUES (?, ?, ?)
+ON CONFLICT(section) DO UPDATE SET
+  value_json = excluded.value_json,
+  updated_at = excluded.updated_at
+`,
+    [section, JSON.stringify(value), Date.now()]
+  );
+}
+function parseSectionJSON(section, value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(
+      `Invalid local config JSON for ${section}: ${formatError(error)}`
+    );
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      `Invalid local config section ${section}: expected object.`
+    );
+  }
+  return validateLocalConfigSection(section, parsed);
+}
+function validateEmbeddingsConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "apiKey",
+    "baseURL",
+    "dimensions",
+    "model",
+    "name",
+    "provider"
+  ]);
+  const allowedProviders = /* @__PURE__ */ new Set(["openai", "openai-compatible"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown embeddings config key: ${key}`);
+    }
+    if (key === "dimensions") {
+      const parsed = typeof entry === "number" ? entry : typeof entry === "string" ? Number(entry) : NaN;
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error("embeddings.dimensions must be a positive integer.");
+      }
+      next[key] = parsed;
+      continue;
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`embeddings.${key} must be a non-empty string.`);
+    }
+    const normalized = entry.trim();
+    if (key === "provider" && !allowedProviders.has(normalized)) {
+      throw new Error(`Unknown embeddings.provider: ${normalized}`);
+    }
+    next[key] = normalized;
+  }
+  return next;
+}
+function validateLLMConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "apiKey",
+    "baseURL",
+    "model",
+    "name",
+    "provider"
+  ]);
+  const allowedProviders = /* @__PURE__ */ new Set([
+    "anthropic",
+    "google",
+    "openai",
+    "openai-compatible"
+  ]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown llm config key: ${key}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`llm.${key} must be a non-empty string.`);
+    }
+    const normalized = entry.trim();
+    if (key === "provider" && !allowedProviders.has(normalized)) {
+      throw new Error(`Unknown llm.provider: ${normalized}`);
+    }
+    next[key] = normalized;
+  }
+  return next;
+}
+function validateConcurrentConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set(["job", "request"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown concurrent config key: ${key}`);
+    }
+    const parsed = typeof entry === "number" ? entry : typeof entry === "string" ? Number(entry) : NaN;
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+      throw new Error(`concurrent.${key} must be a positive integer.`);
+    }
+    next[key] = parsed;
+  }
+  return next;
+}
+function validateWikispineConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set(["endpoint", "provider", "token"]);
+  const allowedProviders = /* @__PURE__ */ new Set(["cli", "fetch"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown wikispine config key: ${key}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`wikispine.${key} must be a non-empty string.`);
+    }
+    const normalized = entry.trim();
+    if (key === "provider" && !allowedProviders.has(normalized)) {
+      throw new Error(`Unknown wikispine.provider: ${normalized}`);
+    }
+    next[key] = normalized;
+  }
+  return next;
+}
+function validateWikimediaConfig(value) {
+  return validateEndpointConfig("wikimedia", value);
+}
+function validateEndpointConfig(section, value) {
+  const allowedKeys = /* @__PURE__ */ new Set(["endpoint", "token"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown ${section} config key: ${key}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`${section}.${key} must be a non-empty string.`);
+    }
+    next[key] = entry.trim();
+  }
+  return next;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/runtime-config.ts
+var WIKI_GRAPH_PROVIDER_VALUES = [
+  "anthropic",
+  "google",
+  "openai",
+  "openai-compatible"
+];
+var wikiGraphProviderSchema = import_zod.z.enum(WIKI_GRAPH_PROVIDER_VALUES);
+var inlineLLMConfigSchema = import_zod.z.object({
+  apiKey: import_zod.z.string().min(1).optional(),
+  baseURL: import_zod.z.string().min(1).optional(),
+  baseUrl: import_zod.z.string().min(1).optional(),
+  chatCompletionsUrl: import_zod.z.string().min(1).optional(),
+  llm: import_zod.z.object({
+    apiKey: import_zod.z.string().min(1).optional(),
+    baseURL: import_zod.z.string().min(1).optional(),
+    baseUrl: import_zod.z.string().min(1).optional(),
+    chatCompletionsUrl: import_zod.z.string().min(1).optional(),
+    model: import_zod.z.string().min(1).optional(),
+    name: import_zod.z.string().min(1).optional(),
+    provider: wikiGraphProviderSchema.optional()
+  }).optional(),
+  model: import_zod.z.string().min(1).optional(),
+  name: import_zod.z.string().min(1).optional(),
+  provider: wikiGraphProviderSchema.optional()
+});
+async function loadWikiGraphRuntimeConfig(options) {
+  const [embedding, localLLM, concurrent, wikimedia, wikispine] = await Promise.all([
+    readLocalConfigSection("embeddings"),
+    readLocalConfigSection("llm"),
+    readLocalConfigSection("concurrent"),
+    readLocalConfigSection("wikimedia"),
+    readLocalConfigSection("wikispine")
+  ]);
+  const inlineLLMConfig = options?.llmJSON === void 0 ? void 0 : parseInlineLLMConfig(options.llmJSON);
+  const llm = createLLMConfig({
+    apiKey: firstDefined(inlineLLMConfig?.apiKey, readString(localLLM.apiKey)),
+    baseURL: firstDefined(
+      inlineLLMConfig?.baseURL,
+      readString(localLLM.baseURL)
+    ),
+    model: firstDefined(inlineLLMConfig?.model, readString(localLLM.model)),
+    name: firstDefined(inlineLLMConfig?.name, readString(localLLM.name)),
+    provider: firstDefined(
+      inlineLLMConfig?.provider,
+      readProvider(localLLM.provider)
+    )
+  });
+  const requestConcurrent = readPositiveInteger(concurrent.request);
+  const jobConcurrent = readPositiveInteger(concurrent.job);
+  const envPolicy = getWikiGraphSDKRuntimeContext().envPolicy;
+  const wikispineConfig = resolveWikispineConfig(wikispine, envPolicy);
+  const wikimediaConfig = createWikimediaConfig(wikimedia, envPolicy);
+  const embeddingConfig = createEmbeddingConfig(embedding);
+  return {
+    ...jobConcurrent === void 0 && requestConcurrent === void 0 ? {} : {
+      concurrent: {
+        ...jobConcurrent === void 0 ? {} : { job: jobConcurrent },
+        ...requestConcurrent === void 0 ? {} : { request: requestConcurrent }
+      }
+    },
+    ...embeddingConfig === void 0 ? {} : { embedding: embeddingConfig },
+    ...llm === void 0 ? {} : { llm },
+    ...wikimediaConfig === void 0 ? {} : { wikimedia: wikimediaConfig },
+    ...wikispineConfig === void 0 ? {} : { wikispine: wikispineConfig }
+  };
+}
+function createWikimediaConfig(input, envPolicy) {
+  const endpoint = readString(input?.endpoint);
+  const token = readString(input?.token);
+  if (endpoint === void 0 && token === void 0) return void 0;
+  if (token === void 0) {
+    throw new Error(
+      "Remote Wikimedia access requires an API key. Configure `wikg://local/config/wikimedia` token with `put token --secret`."
+    );
+  }
+  return {
+    endpoint: endpoint ?? resolveHostedProviderEndpoint("wg-wikimedia", envPolicy),
+    token
+  };
+}
+function createEmbeddingConfig(input) {
+  const value = input ?? {};
+  const provider = readEmbeddingProvider(value.provider);
+  const apiKey = readString(value.apiKey);
+  const baseURL = readString(value.baseURL);
+  const dimensions = typeof value.dimensions === "number" && Number.isInteger(value.dimensions) && value.dimensions > 0 ? value.dimensions : void 0;
+  const model = readString(value.model);
+  const name = readString(value.name);
+  if (provider === void 0 || model === void 0 || provider === "openai-compatible" && baseURL === void 0 || provider === "openai" && baseURL !== void 0) {
+    return void 0;
+  }
+  return {
+    ...apiKey === void 0 ? {} : { apiKey },
+    ...baseURL === void 0 ? {} : { baseURL },
+    ...dimensions === void 0 ? {} : { dimensions },
+    ...model === void 0 ? {} : { model },
+    ...name === void 0 ? {} : { name },
+    ...provider === void 0 ? {} : { provider }
+  };
+}
+function parseInlineLLMConfig(value) {
+  const normalized = normalizeString(value);
+  if (normalized === void 0) {
+    throw new Error("--llm must be a non-empty JSON object.");
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(normalized);
+  } catch (error) {
+    throw new Error(`Invalid --llm JSON: ${formatError2(error)}`);
+  }
+  const parsed = inlineLLMConfigSchema.safeParse(parsedJson);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid --llm config: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+    );
+  }
+  const input = parsed.data.llm ?? parsed.data;
+  const provider = input.provider ?? inferInlineProvider(input);
+  const baseURL = resolveInlineBaseURL(input);
+  const config = createLLMConfig({
+    apiKey: input.apiKey,
+    baseURL,
+    model: input.model,
+    name: input.name,
+    provider
+  });
+  if (config === void 0) {
+    throw new Error("--llm must contain at least one supported LLM field.");
+  }
+  return config;
+}
+function inferInlineProvider(input) {
+  if (input.provider === void 0 && (input.baseURL !== void 0 || input.baseUrl !== void 0 || input.chatCompletionsUrl !== void 0)) {
+    return "openai-compatible";
+  }
+  return input.provider;
+}
+function inferBaseURLFromChatCompletionsURL(input) {
+  if (input.chatCompletionsUrl === void 0) {
+    return void 0;
+  }
+  const suffix = "/chat/completions";
+  if (!input.chatCompletionsUrl.endsWith(suffix)) {
+    throw new Error(
+      "--llm chatCompletionsUrl must end with /chat/completions when baseURL is not provided."
+    );
+  }
+  return input.chatCompletionsUrl.slice(0, -suffix.length);
+}
+function resolveInlineBaseURL(input) {
+  if (input.baseURL !== void 0) {
+    return input.baseURL;
+  }
+  if (input.baseUrl !== void 0) {
+    return input.baseUrl;
+  }
+  return inferBaseURLFromChatCompletionsURL(input);
+}
+function createLLMConfig(input) {
+  if (input.apiKey === void 0 && input.baseURL === void 0 && input.model === void 0 && input.name === void 0 && input.provider === void 0) {
+    return void 0;
+  }
+  return {
+    ...input.apiKey === void 0 ? {} : { apiKey: input.apiKey },
+    ...input.baseURL === void 0 ? {} : { baseURL: input.baseURL },
+    ...input.model === void 0 ? {} : { model: input.model },
+    ...input.name === void 0 ? {} : { name: input.name },
+    ...input.provider === void 0 ? {} : { provider: input.provider }
+  };
+}
+function readProvider(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const parsed = wikiGraphProviderSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function resolveWikispineConfig(value, envPolicy = getWikiGraphSDKRuntimeContext().envPolicy) {
+  const provider = readWikispineProvider(value.provider);
+  const endpoint = readString(value.endpoint);
+  const token = readString(value.token);
+  if (provider === void 0) {
+    return void 0;
+  }
+  if (provider === "cli") return { provider };
+  if (token === void 0) {
+    throw new Error(
+      "Remote WikiSpine access requires an API key. Configure `wikg://local/config/wikispine` token with `put token --secret`."
+    );
+  }
+  return {
+    endpoint: endpoint ?? resolveHostedProviderEndpoint("wikispine", envPolicy),
+    provider,
+    token
+  };
+}
+function resolveHostedProviderEndpoint(scope, envPolicy = getWikiGraphSDKRuntimeContext().envPolicy) {
+  const origin = envPolicy === "development" ? "https://pdf-craft-api.oomol.dev" : "https://api.pdfcraft.ai";
+  return `${origin}/v1/${scope}`;
+}
+function readWikispineProvider(value) {
+  return value === "cli" || value === "fetch" ? value : void 0;
+}
+function readEmbeddingProvider(value) {
+  return value === "openai" || value === "openai-compatible" ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function firstDefined(first, second) {
+  return first ?? second;
+}
+function normalizeString(value) {
+  const normalized = value?.trim();
+  return normalized === void 0 || normalized === "" ? void 0 : normalized;
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/runtime-path.ts
+var import_os2 = require("os");
+var import_path2 = require("path");
+function resolveWikiGraphRuntimePath(path) {
+  const context = getWikiGraphSDKRuntimeContext();
+  const environmentHome = context.env.HOME?.trim();
+  const home = environmentHome === void 0 || environmentHome === "" ? (0, import_os2.homedir)() : environmentHome;
+  if (path === "~") return home;
+  if (path.startsWith("~/")) return (0, import_path2.resolve)(home, path.slice(2));
+  return (0, import_path2.isAbsolute)(path) ? path : (0, import_path2.resolve)(context.cwd, path);
+}
+
+// src/conversions.ts
+var WikiGraphConversionManager = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  async convert(options) {
+    return await this.#runtime.run(async () => await this.#convert(options));
+  }
+  async #convert(options) {
+    const targetStage = options.targetStage ?? "summarized";
+    if (options.targetStage !== void 0 && options.output.format !== "wikg") {
+      throw new Error("targetStage is only supported for wikg output.");
+    }
+    if (options.targetStage !== void 0 && options.input.format === "wikg") {
+      throw new Error(
+        "targetStage is only supported when creating a wikg archive."
+      );
+    }
+    const requiresDigest = options.input.format !== "wikg";
+    const requiresLLM = requiresDigest && targetStage !== "planned" && targetStage !== "sourced";
+    const config = await loadWikiGraphRuntimeConfig({
+      ...options.llmJSON === void 0 ? {} : { llmJSON: options.llmJSON }
+    });
+    const app = new import_wiki_graph_core2.WikiGraph({
+      ...options.verbose === true ? { verbose: true } : {},
+      ...requiresLLM ? { llm: buildWikiGraphLLMOptions(config) } : {}
+    });
+    const documentDirectory = await prepareDigestDirectory(
+      options.digestDirectory,
+      requiresDigest
+    );
+    const write = async (archive) => {
+      await writeArchive(archive, options.output.path, options.output.format);
+    };
+    if (options.input.format === "wikg") {
+      if (!("path" in options.input)) {
+        throw new Error("wikg input requires a file path.");
+      }
+      await app.openSession(
+        new NodeFile(resolveWikiGraphRuntimePath(options.input.path)),
+        write
+      );
+    } else if ("stream" in options.input) {
+      await app.digestTextStreamSession(
+        {
+          ...documentDirectory === void 0 ? {} : { documentDirectory },
+          ...options.onProgress === void 0 ? {} : { onProgress: options.onProgress },
+          sourceFormat: options.input.format,
+          stream: options.input.stream,
+          ...(options.prompt ?? config.prompt) === void 0 ? {} : { extractionPrompt: options.prompt ?? config.prompt },
+          targetStage
+        },
+        write
+      );
+    } else {
+      const digestOptions = {
+        ...documentDirectory === void 0 ? {} : { documentDirectory },
+        file: new NodeFile(resolveWikiGraphRuntimePath(options.input.path)),
+        ...options.onProgress === void 0 ? {} : { onProgress: options.onProgress },
+        ...(options.prompt ?? config.prompt) === void 0 ? {} : { extractionPrompt: options.prompt ?? config.prompt },
+        targetStage
+      };
+      if (options.input.format === "epub") {
+        await app.digestEpubSession(digestOptions, write);
+      } else if (options.input.format === "markdown") {
+        await app.digestMarkdownSession(digestOptions, write);
+      } else {
+        await app.digestTxtSession(digestOptions, write);
+      }
+    }
+    return {
+      inputFormat: options.input.format,
+      outputFormat: options.output.format,
+      outputPath: options.output.path
+    };
+  }
+};
+async function prepareDigestDirectory(path, required) {
+  const normalized = path?.trim();
+  if (!required || normalized === void 0 || normalized === "")
+    return void 0;
+  const resolved = resolveWikiGraphRuntimePath(normalized);
+  await (0, import_promises2.rm)(resolved, { force: true, recursive: true });
+  return new NodeDirectory(resolved);
+}
+async function writeArchive(archive, path, format) {
+  const file = new NodeFile(resolveWikiGraphRuntimePath(path));
+  if (format === "epub") await archive.exportEpub(file);
+  else if (format === "wikg") await archive.saveAs(file);
+  else await archive.exportText(file);
+}
+
+// src/query-runtime.ts
+var import_wiki_graph_core3 = require("wiki-graph-core");
+
+// src/embedding.ts
+var import_ai = require("ai");
+var import_openai2 = require("@ai-sdk/openai");
+var import_openai_compatible2 = require("@ai-sdk/openai-compatible");
+var EMBEDDING_BATCH_SIZE = 10;
+async function readWikiGraphEmbeddingConfig() {
+  const config = await readLocalConfigSection("embeddings");
+  return {
+    ...typeof config.apiKey === "string" ? { apiKey: config.apiKey } : {},
+    ...typeof config.baseURL === "string" ? { baseURL: config.baseURL } : {},
+    ...typeof config.dimensions === "number" ? { dimensions: config.dimensions } : {},
+    ...typeof config.model === "string" ? { model: config.model } : {},
+    ...typeof config.name === "string" ? { name: config.name } : {},
+    ...typeof config.provider === "string" ? { provider: parseEmbeddingProvider(config.provider) } : {}
+  };
+}
+async function embedQueryText(value, config = {}) {
+  const normalized = value.trim();
+  if (normalized === "") {
+    throw new Error("Query text cannot be empty.");
+  }
+  const provider = requireEmbeddingProvider(config.provider);
+  const model = requireEmbeddingModel(config.model);
+  const embeddingModel = createEmbeddingModel(provider, model, config);
+  const providerOptions = createEmbeddingProviderOptions(provider, config);
+  const result = await (0, import_ai.embed)({
+    model: embeddingModel,
+    ...providerOptions === void 0 ? {} : { providerOptions },
+    value: normalized
+  });
+  return {
+    dimensions: result.embedding.length,
+    embedding: result.embedding,
+    model,
+    provider,
+    ...result.usage.tokens === void 0 ? {} : { usage: { tokens: result.usage.tokens } }
+  };
+}
+function buildSearchIndexEmbeddingProvider(config) {
+  const provider = requireEmbeddingProvider(config.provider);
+  const model = requireEmbeddingModel(config.model);
+  const embeddingModel = createEmbeddingModel(provider, model, config);
+  const providerOptions = createEmbeddingProviderOptions(provider, config);
+  return {
+    ...config.dimensions === void 0 ? {} : { dimensions: config.dimensions },
+    identity: createEmbeddingIdentity(provider, model, config),
+    model,
+    embedTexts: async (texts, options) => {
+      const embeddings = [];
+      let tokens = 0;
+      for (const batch of chunkTexts(texts, EMBEDDING_BATCH_SIZE)) {
+        options?.signal?.throwIfAborted();
+        const result = await (0, import_ai.embedMany)({
+          ...options?.signal === void 0 ? {} : { abortSignal: options.signal },
+          model: embeddingModel,
+          ...providerOptions === void 0 ? {} : { providerOptions },
+          values: [...batch]
+        });
+        embeddings.push(...result.embeddings);
+        tokens += result.usage.tokens ?? 0;
+      }
+      return {
+        embeddings,
+        ...tokens === 0 ? {} : { tokens }
+      };
+    }
+  };
+}
+function createEmbeddingIdentity(provider, model, config) {
+  return JSON.stringify({
+    ...config.baseURL === void 0 ? {} : { baseURL: config.baseURL },
+    ...config.dimensions === void 0 ? {} : { dimensions: config.dimensions },
+    model,
+    provider
+  });
+}
+function* chunkTexts(texts, size) {
+  for (let index = 0; index < texts.length; index += size) {
+    yield texts.slice(index, index + size);
+  }
+}
+async function embedQueryTextWithLocalConfig(value) {
+  return await embedQueryText(value, await readWikiGraphEmbeddingConfig());
+}
+function createEmbeddingModel(provider, model, config) {
+  switch (provider) {
+    case "openai": {
+      if (config.baseURL !== void 0) {
+        throw new Error(
+          "openai does not accept embeddings.baseURL. Use openai-compatible for third-party OpenAI-style embeddings APIs."
+        );
+      }
+      return (0, import_openai2.createOpenAI)({
+        ...config.apiKey === void 0 ? {} : { apiKey: config.apiKey },
+        ...config.name === void 0 ? {} : { name: config.name }
+      }).embeddingModel(model);
+    }
+    case "openai-compatible": {
+      if (config.baseURL === void 0) {
+        throw new Error("openai-compatible requires embeddings.baseURL.");
+      }
+      return (0, import_openai_compatible2.createOpenAICompatible)({
+        baseURL: config.baseURL,
+        name: config.name ?? createOpenAICompatibleName2(config.baseURL),
+        ...config.apiKey === void 0 ? {} : { apiKey: config.apiKey }
+      }).embeddingModel(model);
+    }
+  }
+}
+function createEmbeddingProviderOptions(provider, config) {
+  if (config.dimensions === void 0) {
+    return void 0;
+  }
+  return {
+    [getEmbeddingProviderOptionsName(provider, config)]: {
+      dimensions: config.dimensions
+    }
+  };
+}
+function getEmbeddingProviderOptionsName(provider, _config) {
+  if (provider === "openai") {
+    return "openai";
+  }
+  return "openaiCompatible";
+}
+function requireEmbeddingProvider(provider) {
+  if (provider !== void 0) {
+    return provider;
+  }
+  throw new Error(
+    "Missing embeddings configuration. Configure `wikg://local/config/embeddings` with provider and model."
+  );
+}
+function requireEmbeddingModel(model) {
+  if (model !== void 0) {
+    return model;
+  }
+  throw new Error(
+    "Missing embeddings.model. Configure `wikg://local/config/embeddings` before using Dense search."
+  );
+}
+function parseEmbeddingProvider(value) {
+  switch (value) {
+    case "openai":
+    case "openai-compatible":
+      return value;
+    default:
+      throw new Error(
+        `Invalid embeddings.provider: ${value}. Expected openai or openai-compatible.`
+      );
+  }
+}
+function createOpenAICompatibleName2(baseURL) {
+  try {
+    return new URL(baseURL).hostname;
+  } catch {
+    return "openai-compatible";
+  }
+}
+
+// src/query-runtime.ts
+async function createConfiguredEmbeddingProvider() {
+  const config = await readWikiGraphEmbeddingConfig();
+  if (config.provider === void 0 || config.model === void 0 || config.provider === "openai-compatible" && config.baseURL === void 0 || config.provider === "openai" && config.baseURL !== void 0) {
+    return void 0;
+  }
+  return buildSearchIndexEmbeddingProvider(config);
+}
+async function withConfiguredWikimediaResolver(objectUri, operation) {
+  if (!objectUri.endsWith("/wikipage")) return await operation({});
+  const config = await loadWikiGraphRuntimeConfig();
+  const resolver = await (0, import_wiki_graph_core3.openWikimediaResolver)(
+    config.wikimedia === void 0 ? { kind: "local" } : {
+      endpoint: config.wikimedia.endpoint,
+      kind: "remote",
+      token: config.wikimedia.token
+    }
+  );
+  try {
+    return await operation({ wikimediaResolver: resolver });
+  } finally {
+    await resolver.close();
+  }
+}
+
+// src/archive/inspect.ts
+var import_wiki_graph_core4 = require("wiki-graph-core");
+
+// src/planning.ts
+var DEFAULT_GENERATION_JOB_CONCURRENCY = 3;
+var DEFAULT_GENERATION_REQUEST_CONCURRENCY = 6;
+function planGenerationTask(task, words, chapters, concurrent, model) {
+  const profile = getGenerationPlanningProfile(task);
+  const calls = Math.max(chapters, Math.ceil(words / profile.wordsPerCall));
+  const effectiveConcurrency = Math.max(
+    1,
+    task === "reading-graph" ? 1 : concurrent.request
+  );
+  const callBatches = Math.ceil(calls / effectiveConcurrency);
+  const wordSeconds = words * profile.secondsPerWord;
+  return {
+    model,
+    timeSeconds: {
+      max: Math.ceil(callBatches * profile.maxSecondsPerCall + wordSeconds),
+      min: Math.ceil(callBatches * profile.minSecondsPerCall + wordSeconds)
+    },
+    tokens: {
+      cacheableInput: Math.ceil(words * profile.cacheableInputTokenPerWord),
+      input: Math.ceil(words * profile.inputTokenPerWord),
+      output: Math.ceil(words * profile.outputTokenPerWord)
+    }
+  };
+}
+function createGenerationPerformanceHints(input) {
+  if (!input.hasJobWork) {
+    return [];
+  }
+  const hints = [];
+  const recommendedRequest = input.concurrent.request < 4 ? DEFAULT_GENERATION_REQUEST_CONCURRENCY : input.concurrent.request < 8 ? 8 : void 0;
+  if (input.hasRequestWork && recommendedRequest !== void 0) {
+    hints.push({
+      configKey: "request",
+      configValue: recommendedRequest,
+      current: input.concurrent.request,
+      kind: "request",
+      message: "LLM request concurrency can often be higher. Use at least 4; 6-8 is usually faster when the provider allows it.",
+      recommended: recommendedRequest
+    });
+  }
+  if (input.concurrent.job < 4 && input.chapters > 1) {
+    hints.push({
+      configKey: "job",
+      configValue: 4,
+      current: input.concurrent.job,
+      kind: "job",
+      message: "Multiple chapters need work and job concurrency is below 4. Raising it lets chapter jobs run in parallel.",
+      recommended: 4
+    });
+  }
+  return hints;
+}
+function formatGenerationPlanningModel(llm) {
+  if (llm?.model === void 0) {
+    return "not configured";
+  }
+  return llm.provider === void 0 ? llm.model : `${llm.provider}/${llm.model}`;
+}
+function formatGenerationPlanningDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  return `${Math.round(minutes / 60)}h`;
+}
+function getGenerationPlanningProfile(task) {
+  switch (task) {
+    case "index-fts":
+      return {
+        cacheableInputTokenPerWord: 0,
+        inputTokenPerWord: 0,
+        maxSecondsPerCall: 1,
+        minSecondsPerCall: 0,
+        outputTokenPerWord: 0,
+        secondsPerWord: 5e-4,
+        wordsPerCall: 1e5
+      };
+    case "index-embedding-source":
+    case "index-embedding-summary":
+      return {
+        cacheableInputTokenPerWord: 0,
+        inputTokenPerWord: 0,
+        maxSecondsPerCall: 10,
+        minSecondsPerCall: 1,
+        outputTokenPerWord: 0,
+        secondsPerWord: 2e-3,
+        wordsPerCall: 1e4
+      };
+    case "knowledge-graph":
+      return {
+        cacheableInputTokenPerWord: 60,
+        inputTokenPerWord: 80,
+        maxSecondsPerCall: 35,
+        minSecondsPerCall: 15,
+        outputTokenPerWord: 25,
+        secondsPerWord: 0.02,
+        wordsPerCall: 35
+      };
+    case "reading-graph":
+      return {
+        cacheableInputTokenPerWord: 20,
+        inputTokenPerWord: 25,
+        maxSecondsPerCall: 45,
+        minSecondsPerCall: 15,
+        outputTokenPerWord: 4,
+        secondsPerWord: 0.01,
+        wordsPerCall: 160
+      };
+    case "reading-summary":
+      return {
+        cacheableInputTokenPerWord: 45,
+        inputTokenPerWord: 55,
+        maxSecondsPerCall: 25,
+        minSecondsPerCall: 10,
+        outputTokenPerWord: 4,
+        secondsPerWord: 0.01,
+        wordsPerCall: 110
+      };
+  }
+}
+
+// src/archive/inspect.ts
+async function createWikiGraphArchiveInspectReport(document, options) {
+  const { archiveUri } = options;
+  const [
+    chapters,
+    summaryWords,
+    indexCacheCurrent,
+    config,
+    ftsArtifactCoverage,
+    sourceEmbeddingArtifactCoverage,
+    summaryEmbeddingArtifactCoverage
+  ] = await Promise.all([
+    readInspectChapters(document, options.chapterId),
+    readSummaryWords(document, options.chapterId),
+    (0, import_wiki_graph_core4.isArchiveSearchIndexCurrent)(document),
+    loadWikiGraphRuntimeConfig(),
+    readIndexArtifactCoverage(document, "fts", options.chapterId),
+    readIndexArtifactCoverage(document, "embedding-source", options.chapterId),
+    readIndexArtifactCoverage(document, "embedding-summary", options.chapterId)
+  ]);
+  const selectedChapter = options.chapterId === void 0 ? void 0 : chapters[0];
+  const scopeUri = selectedChapter === void 0 ? archiveUri : formatInspectLocatedChapterUri(archiveUri, selectedChapter);
+  const concurrent = {
+    job: config.concurrent?.job ?? DEFAULT_GENERATION_JOB_CONCURRENCY,
+    request: config.concurrent?.request ?? DEFAULT_GENERATION_REQUEST_CONCURRENCY
+  };
+  const planningModel = formatGenerationPlanningModel(config.llm);
+  const contentChapters = chapters.filter(
+    (chapter) => chapter.stage !== "planned"
+  );
+  const sourceWords = sumWords(contentChapters);
+  const readingGraphCovered = contentChapters.filter(
+    (chapter) => chapter.readingGraphReady
+  );
+  const knowledgeGraphCovered = contentChapters.filter(
+    (chapter) => chapter.knowledgeGraphReady
+  );
+  const summaryCovered = contentChapters.filter(
+    (chapter) => chapter.summaryReady
+  );
+  const ftsArtifactCovered = filterChaptersByCurrentIndexArtifact(
+    contentChapters,
+    ftsArtifactCoverage
+  );
+  const sourceEmbeddingArtifactCovered = filterChaptersByCurrentIndexArtifact(
+    contentChapters,
+    sourceEmbeddingArtifactCoverage
+  );
+  const summaryEmbeddingArtifactCovered = filterChaptersByCurrentIndexArtifact(
+    contentChapters,
+    summaryEmbeddingArtifactCoverage
+  );
+  const queryBlockedContentChapters = contentChapters.filter(
+    (chapter) => !ftsArtifactCovered.includes(chapter) && !sourceEmbeddingArtifactCovered.includes(chapter)
+  );
+  const queryBlockedChapters = queryBlockedContentChapters.map(
+    (chapter) => createInspectChapterReference(archiveUri, chapter)
+  );
+  const queryReady = queryBlockedChapters.length === 0;
+  const improvements = createInspectImprovements({
+    concurrent,
+    contentChapters,
+    indexCacheCurrent,
+    planningModel,
+    queryBlockedChapters: queryBlockedContentChapters,
+    summaryCovered,
+    knowledgeGraphCovered,
+    readingGraphCovered
+  });
+  const performanceHints = createGenerationPerformanceHints({
+    chapters: Math.max(
+      0,
+      ...improvements.map((improvement) => improvement.missingChapters ?? 0)
+    ),
+    concurrent,
+    hasJobWork: improvements.some(
+      (improvement) => improvement.planning !== void 0
+    ),
+    hasRequestWork: improvements.some(
+      (improvement) => improvement.planning !== void 0
+    )
+  });
+  return {
+    archiveUri,
+    uri: scopeUri,
+    scope: options.chapterId === void 0 ? { type: "archive" } : { chapterId: options.chapterId, type: "chapter" },
+    content: {
+      chapters: {
+        content: contentChapters.length,
+        planned: chapters.length - contentChapters.length,
+        total: chapters.length
+      },
+      sourceWords,
+      summaryWords
+    },
+    localIndexCache: {
+      current: indexCacheCurrent,
+      ...!queryReady ? {
+        blockedBy: "missing-search-artifacts",
+        impact: "The cache cannot be built until every content chapter has a current FTS or source embedding artifact."
+      } : indexCacheCurrent ? {} : {
+        impact: "The next archive query may need to sync index cache first.",
+        resource: "local CPU/disk time only; no provider calls."
+      },
+      status: !queryReady ? "blocked" : indexCacheCurrent ? "current" : "missing-or-outdated",
+      syncAvailable: queryReady && !indexCacheCurrent
+    },
+    coverage: {
+      ftsIndexArtifact: createInspectCoverage(
+        ftsArtifactCovered,
+        contentChapters
+      ),
+      knowledgeGraph: createInspectCoverage(
+        knowledgeGraphCovered,
+        contentChapters
+      ),
+      readingGraph: createInspectCoverage(readingGraphCovered, contentChapters),
+      summary: createInspectCoverage(summaryCovered, contentChapters),
+      sourceEmbeddingIndexArtifact: createInspectCoverage(
+        sourceEmbeddingArtifactCovered,
+        contentChapters
+      ),
+      summaryEmbeddingIndexArtifact: createInspectCoverage(
+        summaryEmbeddingArtifactCovered,
+        contentChapters
+      )
+    },
+    query: {
+      ready: queryReady
+    },
+    searchArtifacts: {
+      blockedChapters: queryBlockedChapters,
+      ...!queryReady ? {
+        resource: "local CPU/disk time only; no provider calls."
+      } : {},
+      ready: queryReady,
+      status: queryReady ? "ready" : "incomplete"
+    },
+    retrievalGuidance: formatRetrievalGuidance({
+      indexCacheCurrent,
+      knowledgeGraphCovered,
+      readingGraphCovered,
+      contentChapters,
+      queryReady,
+      sourceWords
+    }),
+    improvements,
+    performanceHints,
+    summaryCoverageNote: "Summary coverage means a current summary artifact exists for the chapter; it does not guarantee that every source topic is represented in the summary text."
+  };
+}
+function createInspectChapterReference(archiveUri, chapter) {
+  return {
+    chapterId: chapter.chapterId,
+    locatedUri: formatInspectLocatedChapterUri(archiveUri, chapter),
+    title: chapter.title,
+    uri: chapter.uri
+  };
+}
+function formatInspectLocatedChapterUri(archiveUri, chapter) {
+  return `${archiveUri.replace(/\/+$/u, "")}/${chapter.uri.replace(/^wikg:\/\//u, "")}`;
+}
+async function readInspectChapters(document, chapterId) {
+  const chapters = chapterId === void 0 ? await (0, import_wiki_graph_core4.listChapters)(document) : (await (0, import_wiki_graph_core4.listChapters)(document)).filter(
+    (chapter) => chapter.chapterId === chapterId
+  );
+  if (chapterId !== void 0 && chapters.length === 0) {
+    throw new Error(`Chapter ${chapterId} does not exist.`);
+  }
+  return await Promise.all(
+    chapters.map(async (chapter) => {
+      const serial = await document.serials.getById(chapter.chapterId);
+      return {
+        ...chapter,
+        knowledgeGraphReady: serial?.knowledgeGraphReady === true,
+        readingGraphReady: serial?.topologyReady === true,
+        summaryReady: chapter.stage === "summarized"
+      };
+    })
+  );
+}
+async function readSummaryWords(document, chapterId) {
+  return await document.readDatabase(
+    async (database) => await database.queryOne(
+      `
+          SELECT COALESCE(SUM(words_count), 0) AS words
+          FROM text_sentence_records
+          WHERE kind = 2
+            ${chapterId === void 0 ? "" : "AND chapter_id = ?"}
+        `,
+      chapterId === void 0 ? void 0 : [chapterId],
+      (row) => Number(row.words)
+    ) ?? 0
+  );
+}
+async function readIndexArtifactCoverage(document, kind, chapterId) {
+  const coverage = await document.indexArtifacts.listCoverage(kind);
+  return chapterId === void 0 ? coverage : coverage.filter((item) => item.serialId === chapterId);
+}
+function filterChaptersByCurrentIndexArtifact(chapters, coverage) {
+  const currentChapterIds = new Set(
+    coverage.filter((item) => item.current).map((item) => item.serialId)
+  );
+  return chapters.filter((chapter) => currentChapterIds.has(chapter.chapterId));
+}
+function createInspectCoverage(covered, total) {
+  const coveredWords = sumWords(covered);
+  const totalWords = sumWords(total);
+  return {
+    coveredChapters: covered.length,
+    coveredWords,
+    percent: formatPercent(coveredWords, totalWords),
+    totalChapters: total.length,
+    totalWords
+  };
+}
+function formatRetrievalGuidance(input) {
+  if (input.sourceWords === 0 || input.contentChapters.length === 0) {
+    return [
+      "Source content: empty.",
+      "Add source text before using query coverage or graph-based retrieval."
+    ];
+  }
+  const lines = [
+    input.queryReady ? `Query: available; local index cache is ${input.indexCacheCurrent ? "current" : "missing or outdated and can be synced from artifacts"}.` : "Query: unavailable until every content chapter has a current FTS or source embedding artifact."
+  ];
+  lines.push(
+    formatObjectSearchGuidance(
+      "Reading Graph object retrieval",
+      input.readingGraphCovered,
+      input.contentChapters
+    )
+  );
+  lines.push(
+    formatObjectSearchGuidance(
+      "Entity/triple retrieval",
+      input.knowledgeGraphCovered,
+      input.contentChapters
+    )
+  );
+  return lines;
+}
+function formatObjectSearchGuidance(label, covered, total) {
+  const coveredWords = sumWords(covered);
+  const totalWords = sumWords(total);
+  const ratio = totalWords === 0 ? 0 : coveredWords / totalWords;
+  const coverage = formatPercent(coveredWords, totalWords);
+  if (ratio >= 1) {
+    return `${label}: covers all source content; it can represent the full scope for object retrieval.`;
+  }
+  if (ratio >= 0.9) {
+    return `${label}: covers ${coverage}; use it as the main path, but source --query is needed for uncovered content.`;
+  }
+  if (ratio >= 0.5) {
+    return `${label}: covers ${coverage}; use it as leads, not as a full-scope substitute for source --query.`;
+  }
+  return `${label}: covers ${coverage}; build missing graph coverage before relying on object retrieval.`;
+}
+function createInspectImprovements(input) {
+  const improvements = [];
+  if (input.contentChapters.length === 0) {
+    improvements.push({
+      kind: "add-source",
+      recommendation: "No source content is available yet; add or import source text before graph or summary generation.",
+      title: "Add source content"
+    });
+    return improvements;
+  }
+  if (input.queryBlockedChapters.length > 0) {
+    improvements.push({
+      kind: "build",
+      missingChapters: input.queryBlockedChapters.length,
+      missingWords: sumWords(input.queryBlockedChapters),
+      recommendation: "Build local FTS artifacts to make this scope queryable. This does not call a provider.",
+      task: "index-fts",
+      title: "Enable query with local FTS"
+    });
+  } else if (!input.indexCacheCurrent) {
+    improvements.push({
+      kind: "sync-index",
+      recommendation: "Sync the index cache from chapter index artifacts so query starts without a lazy cache rebuild.",
+      title: "Sync index cache"
+    });
+  }
+  improvements.push(
+    ...createGraphImprovement({
+      concurrent: input.concurrent,
+      covered: input.readingGraphCovered,
+      planningModel: input.planningModel,
+      task: "reading-graph",
+      title: "Complete Reading Graph coverage",
+      total: input.contentChapters
+    })
+  );
+  improvements.push(
+    ...createGraphImprovement({
+      concurrent: input.concurrent,
+      covered: input.knowledgeGraphCovered,
+      planningModel: input.planningModel,
+      task: "knowledge-graph",
+      title: "Complete Knowledge Graph coverage",
+      total: input.contentChapters
+    })
+  );
+  improvements.push(
+    ...createGraphImprovement({
+      concurrent: input.concurrent,
+      covered: input.summaryCovered,
+      planningModel: input.planningModel,
+      task: "reading-summary",
+      title: "Complete Summary coverage",
+      total: input.contentChapters
+    })
+  );
+  return improvements;
+}
+function createGraphImprovement(input) {
+  const coveredIds = new Set(input.covered.map((chapter) => chapter.chapterId));
+  const missing = input.total.filter(
+    (chapter) => !coveredIds.has(chapter.chapterId)
+  );
+  if (missing.length === 0) {
+    return [];
+  }
+  const missingWords = sumWords(missing);
+  return [
+    {
+      kind: "build",
+      missingChapters: missing.length,
+      missingWords,
+      planning: planGenerationTask(
+        input.task,
+        missingWords,
+        missing.length,
+        input.concurrent,
+        input.planningModel
+      ),
+      recommendation: formatImprovementRecommendation(
+        input.covered,
+        input.total,
+        missingWords
+      ),
+      task: input.task,
+      title: input.title
+    }
+  ];
+}
+function formatImprovementRecommendation(covered, total, missingWords) {
+  const totalWords = sumWords(total);
+  const coveredWords = sumWords(covered);
+  if (totalWords === 0) {
+    return "No source content is available.";
+  }
+  if (total.length === 1 || coveredWords / totalWords >= 0.9 || missingWords <= 1e3) {
+    return "Queue the full scope to finish the remaining gap.";
+  }
+  return "Queue selected chapters first if only part of the scope matters.";
+}
+function sumWords(chapters) {
+  return chapters.reduce((total, chapter) => total + chapter.words, 0);
+}
+function formatPercent(numerator, denominator) {
+  if (denominator === 0) {
+    return "n/a";
+  }
+  const percent = numerator / denominator * 100;
+  return `${Number.isInteger(percent) ? percent.toFixed(0) : percent.toFixed(1)}%`;
+}
+
+// src/archive/archive.ts
+var WikiGraphArchiveExistsError = class extends Error {
+  code = "WIKI_GRAPH_ARCHIVE_EXISTS";
+  path;
+  constructor(path) {
+    super(`Archive already exists: ${path}`);
+    this.name = "WikiGraphArchiveExistsError";
+    this.path = path;
+  }
+};
+var WikiGraphArchiveManager = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  async create(options) {
+    return await this.#runtime.run(async () => {
+      const path = resolveWikiGraphRuntimePath(options.path);
+      if (options.replace !== true && await nodePathExists(path)) {
+        throw new WikiGraphArchiveExistsError(path);
+      }
+      const outputPath = (0, import_path3.join)(
+        (0, import_path3.dirname)(path),
+        `.${(0, import_path3.basename)(path)}.${(0, import_crypto.randomUUID)()}.tmp.wikg`
+      );
+      try {
+        if (options.importPath === void 0) {
+          await createEmptyArchiveFile(outputPath);
+        } else {
+          await new WikiGraphConversionManager(this.#runtime).convert({
+            input: { format: "epub", path: options.importPath },
+            ...options.onProgress === void 0 ? {} : { onProgress: options.onProgress },
+            output: { format: "wikg", path: outputPath },
+            targetStage: "sourced"
+          });
+        }
+        if (options.replace === true) {
+          await (0, import_promises3.rename)(outputPath, path);
+        } else {
+          try {
+            await (0, import_promises3.link)(outputPath, path);
+          } catch (error) {
+            if (isNodeEEXISTError(error)) {
+              throw new WikiGraphArchiveExistsError(path);
+            }
+            throw error;
+          }
+        }
+        return { locatedUri: (0, import_wiki_graph_core5.formatLocatedWikiGraphUri)(path), path };
+      } finally {
+        await (0, import_promises3.rm)(outputPath, { force: true, recursive: true });
+      }
+    }, options.signal);
+  }
+  async open(uriOrPath, options = {}) {
+    const location = await this.#runtime.run(
+      async () => await resolveWikiGraphArchiveLocation(uriOrPath),
+      options.signal
+    );
+    return new WikiGraphArchiveHandle(this.#runtime, location);
+  }
+};
+var WikiGraphArchiveHandle = class {
+  #runtime;
+  #location;
+  constructor(runtime, location) {
+    this.#runtime = runtime;
+    this.#location = location;
+  }
+  get archiveKey() {
+    return this.#location.archiveKey;
+  }
+  get indexScope() {
+    return this.#location.indexScope;
+  }
+  get locatedUri() {
+    return this.#location.locatedUri;
+  }
+  get objectUri() {
+    return (0, import_wiki_graph_core5.parseLocatedWikiGraphUri)(this.#location.locatedUri).objectUri ?? "wikg://";
+  }
+  get path() {
+    return this.#location.archivePath;
+  }
+  async inspect(options = {}) {
+    return await this.#readDocument(
+      async (document) => await createWikiGraphArchiveInspectReport(document, {
+        archiveUri: this.#location.publicArchiveUri ?? this.locatedUri,
+        ...options.chapterId === void 0 ? {} : { chapterId: options.chapterId }
+      }),
+      options
+    );
+  }
+  async search(query, options = {}) {
+    const embeddingProvider = await this.#runtime.run(
+      createConfiguredEmbeddingProvider,
+      options.signal
+    );
+    return await this.#writeDocument(
+      async (document) => {
+        const chapters = await this.#resolveQueryChapters(document, options);
+        await ensureArchiveSearchIndex(document, {
+          ...chapters === void 0 ? {} : { chapters },
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        });
+        return await (0, import_wiki_graph_core5.findArchiveObjects)(document, query, {
+          ...withoutOperationAndScope(options),
+          archiveKey: this.archiveKey,
+          ...chapters === void 0 ? {} : { chapters },
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        });
+      },
+      {
+        searchIndexWritebackPolicy: "cache",
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+  }
+  async list(options = {}) {
+    return await this.#readDocument(async (document) => {
+      if ((0, import_wiki_graph_core5.isSourceLocatorScopeUri)(this.objectUri)) {
+        return await (0, import_wiki_graph_core5.listArchiveSourceLocators)(document, this.objectUri, {
+          ...options.cursor === void 0 ? {} : { cursor: options.cursor },
+          ...options.limit === void 0 ? {} : { limit: options.limit }
+        });
+      }
+      const chapters = await this.#resolveScope(document, options);
+      return await (0, import_wiki_graph_core5.listArchiveCollection)(document, {
+        ...withoutOperationAndScope(options),
+        ...chapters === void 0 ? {} : { chapters }
+      });
+    }, options);
+  }
+  async ensureSearchIndex(options = {}) {
+    const embeddingProvider = await this.#runtime.run(
+      createConfiguredEmbeddingProvider,
+      options.signal
+    );
+    await this.#writeDocument(
+      async (document) => {
+        const chapters = await this.#resolveScope(document, options);
+        await ensureArchiveSearchIndex(document, {
+          ...chapters === void 0 ? {} : { chapters },
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        });
+      },
+      {
+        searchIndexWritebackPolicy: "cache",
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+  }
+  async getSearchIndexStatus(options = {}) {
+    return await this.#readDocument(
+      async (document) => ({
+        capabilities: await (0, import_wiki_graph_core5.readSearchIndexCapabilityStatus)(document),
+        current: await (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document)
+      }),
+      options
+    );
+  }
+  async syncSearchIndex(options = {}) {
+    const rebuilt = await this.#writeDocument(
+      async (document) => {
+        const scope = options.skipUnindexed === true ? { chapters: await (0, import_wiki_graph_core5.listArchiveQueryableChapterIds)(document) } : {};
+        if (scope.chapters?.length === 0) {
+          throw new Error(
+            "Wiki Graph index cache is not ready. No chapters have a current FTS artifact or source embedding artifact."
+          );
+        }
+        if (await (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document, scope)) return false;
+        await (0, import_wiki_graph_core5.rebuildArchiveSearchIndex)(document, options.onProgress, scope);
+        return true;
+      },
+      {
+        searchIndexWritebackPolicy: "cache",
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+    await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core5.deleteArchiveSearchSessions)(this.path),
+      options.signal
+    );
+    return { rebuilt };
+  }
+  async cleanSearchIndex(options = {}) {
+    const status = await this.#writeDocument(
+      async (document) => {
+        await document.deleteSearchIndexDatabase();
+        return {
+          capabilities: {
+            dense: { current: false },
+            indexes: "missing"
+          },
+          current: false
+        };
+      },
+      {
+        searchIndexWritebackPolicy: "cache",
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+    await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core5.deleteArchiveSearchSessions)(this.path),
+      options.signal
+    );
+    return status;
+  }
+  async listChapters(options = {}) {
+    return await this.#readDocument(
+      async (document) => await (0, import_wiki_graph_core5.listChapters)(document),
+      options
+    );
+  }
+  async getChapter(path, options = {}) {
+    return await this.#readDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      return requireChapter(await (0, import_wiki_graph_core5.listChapters)(document), chapterId);
+    }, options);
+  }
+  async addChapter(options) {
+    return await this.#writeDocument(async (document) => {
+      const parentChapterId = await resolveOptionalChapterPath(
+        document,
+        options.parentPath
+      );
+      await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+        archive: this.#location.archiveFile,
+        operation: "Adding chapter",
+        scope: { kind: "archive" }
+      });
+      let details = await (0, import_wiki_graph_core5.addChapter)(document, {
+        ...parentChapterId === void 0 ? {} : { parentChapterId },
+        ...options.title === void 0 ? {} : { title: options.title }
+      });
+      if (options.source !== void 0) {
+        details = await (0, import_wiki_graph_core5.setChapterSource)(
+          document,
+          details.chapterId,
+          asTextStream(options.source)
+        );
+      }
+      return details;
+    });
+  }
+  async getChapterArtifact(path, kind) {
+    return await this.#readDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      const [artifact, revision] = await Promise.all([
+        document.indexArtifacts.get(chapterId, kind),
+        document.serials.getRevision(chapterId)
+      ]);
+      return {
+        ...artifact === void 0 ? {} : {
+          artifact: {
+            createdAt: artifact.createdAt,
+            metadata: artifact.metadata,
+            sourceRevision: artifact.sourceRevision
+          }
+        },
+        chapterId,
+        current: artifact?.sourceRevision === revision,
+        kind,
+        missing: artifact === void 0,
+        revision
+      };
+    });
+  }
+  async deleteChapterArtifact(path, kind) {
+    return await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      await document.indexArtifacts.delete(chapterId, kind);
+      return { chapterId, deleted: true, kind };
+    });
+  }
+  async moveChapter(path, options) {
+    return await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      const [afterChapterId, beforeChapterId, parentChapterId] = await Promise.all([
+        resolveOptionalChapterPath(document, options.afterPath),
+        resolveOptionalChapterPath(document, options.beforePath),
+        resolveOptionalChapterPath(document, options.parentPath)
+      ]);
+      await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+        archive: this.#location.archiveFile,
+        operation: "Moving chapter",
+        scope: { kind: "archive" }
+      });
+      return await (0, import_wiki_graph_core5.moveChapter)(document, chapterId, {
+        ...afterChapterId === void 0 ? {} : { afterChapterId },
+        ...beforeChapterId === void 0 ? {} : { beforeChapterId },
+        ...parentChapterId === void 0 ? {} : { parentChapterId },
+        ...options.first === void 0 ? {} : { first: options.first },
+        ...options.last === void 0 ? {} : { last: options.last },
+        ...options.root === void 0 ? {} : { root: options.root }
+      });
+    });
+  }
+  async removeChapter(path, recursive = false) {
+    await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+        archive: this.#location.archiveFile,
+        operation: "Removing chapter",
+        scope: { kind: "archive" }
+      });
+      await (0, import_wiki_graph_core5.removeChapter)(document, chapterId, { recursive });
+    });
+  }
+  async resetChapter(path, stage) {
+    return await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      await assertChapterResetAllowed(
+        this.#location.archiveFile,
+        chapterId,
+        stage
+      );
+      return await (0, import_wiki_graph_core5.resetChapter)(document, chapterId, stage);
+    });
+  }
+  async setChapterSource(path, source, options = {}) {
+    return await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+        archive: this.#location.archiveFile,
+        chapterIds: [chapterId],
+        operation: "Setting chapter source"
+      });
+      return await (0, import_wiki_graph_core5.setChapterSource)(
+        document,
+        chapterId,
+        asTextStream(source),
+        options
+      );
+    });
+  }
+  async setChapterSummary(path, summary) {
+    return await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+        archive: this.#location.archiveFile,
+        chapterIds: [chapterId],
+        operation: "Setting chapter summary",
+        requiresTarget: "reading-summary"
+      });
+      return await (0, import_wiki_graph_core5.setChapterSummary)(document, chapterId, summary);
+    });
+  }
+  async setChapterTitle(path, title) {
+    return await this.#writeDocument(async (document) => {
+      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+        archive: this.#location.archiveFile,
+        chapterIds: [chapterId],
+        operation: "Setting chapter title"
+      });
+      return await (0, import_wiki_graph_core5.setChapterTitle)(document, chapterId, title);
+    });
+  }
+  async getChapterTree() {
+    return await this.#readDocument(
+      async (document) => await (0, import_wiki_graph_core5.getChapterTree)(document)
+    );
+  }
+  async applyChapterTree(tree, options = {}) {
+    return await this.#writeDocument(
+      async (document) => {
+        if (options.dryRun !== true) {
+          await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+            archive: this.#location.archiveFile,
+            operation: "Changing chapter tree",
+            scope: { kind: "archive" }
+          });
+        }
+        return await (0, import_wiki_graph_core5.applyChapterTree)(document, tree, {
+          dryRun: options.dryRun ?? false
+        });
+      },
+      { refreshLibraryIndex: options.dryRun !== true }
+    );
+  }
+  async page(objectUri = this.objectUri, options = {}) {
+    return await this.#runtime.run(
+      async () => await withConfiguredWikimediaResolver(
+        objectUri,
+        async (wikimediaOptions) => await this.#readDocument(
+          async (document) => await (0, import_wiki_graph_core5.readArchivePage)(document, objectUri, {
+            ...withoutOperation(options),
+            ...wikimediaOptions
+          }),
+          options
+        )
+      ),
+      options.signal
+    );
+  }
+  async related(objectUri = this.objectUri, options = {}) {
+    if (options.query === void 0) {
+      return await this.#readDocument(async (document) => {
+        const chapters = await this.#resolveScope(document, {});
+        return await (0, import_wiki_graph_core5.listRelatedArchiveObjects)(document, objectUri, {
+          ...withoutOperation(options),
+          ...chapters === void 0 ? {} : { chapters }
+        });
+      }, options);
+    }
+    const embeddingProvider = await this.#runtime.run(
+      createConfiguredEmbeddingProvider,
+      options.signal
+    );
+    return await this.#writeDocument(
+      async (document) => {
+        const chapters = await this.#resolveQueryChapters(document, options);
+        await ensureArchiveSearchIndex(document, {
+          ...chapters === void 0 ? {} : { chapters },
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        });
+        return await (0, import_wiki_graph_core5.listRelatedArchiveObjects)(document, objectUri, {
+          ...withoutOperation(options),
+          ...chapters === void 0 ? {} : { chapters }
+        });
+      },
+      {
+        searchIndexWritebackPolicy: "cache",
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+  }
+  async evidence(objectUri = this.objectUri, options = {}) {
+    if (options.query === void 0) {
+      return await this.#readDocument(async (document) => {
+        const chapters = await this.#resolveScope(document, {});
+        return await (0, import_wiki_graph_core5.listArchiveEvidence)(document, objectUri, {
+          ...withoutOperation(options),
+          ...chapters === void 0 ? {} : { chapters }
+        });
+      }, options);
+    }
+    const embeddingProvider = await this.#runtime.run(
+      createConfiguredEmbeddingProvider,
+      options.signal
+    );
+    return await this.#writeDocument(
+      async (document) => {
+        const chapters = await this.#resolveQueryChapters(document, options);
+        await ensureArchiveSearchIndex(document, {
+          ...chapters === void 0 ? {} : { chapters },
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        });
+        return await (0, import_wiki_graph_core5.listArchiveEvidence)(document, objectUri, {
+          ...withoutOperation(options),
+          ...chapters === void 0 ? {} : { chapters }
+        });
+      },
+      {
+        searchIndexWritebackPolicy: "cache",
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      }
+    );
+  }
+  async pack(objectUri = this.objectUri, budget = 5e3, options = {}) {
+    return await this.#readDocument(
+      async (document) => await (0, import_wiki_graph_core5.packArchiveContext)(document, objectUri, budget),
+      options
+    );
+  }
+  async getMetadata(objectPath, options = {}) {
+    return await this.#readDocument(
+      async (document) => await document.metadata.getMap(objectPath),
+      options
+    );
+  }
+  async readBookMeta(options = {}) {
+    return await this.#readDocument(
+      async (document) => await document.readBookMeta(),
+      options
+    );
+  }
+  async replaceBookMeta(meta, options = {}) {
+    return await this.#writeDocument(async (document) => {
+      await document.replaceBookMeta(meta);
+      return meta;
+    }, options);
+  }
+  async readCover(options = {}) {
+    const app = new import_wiki_graph_core5.WikiGraph({});
+    return await this.#runtime.run(
+      async () => await app.openSession(
+        this.#location.archiveFile,
+        async (archive) => await archive.readCover()
+      ),
+      options.signal
+    );
+  }
+  async replaceMetadata(objectPath, value, options = {}) {
+    return await this.#writeDocument(async (document) => {
+      await document.metadata.replaceMap(
+        parseObjectMetadataTarget(objectPath),
+        value
+      );
+      return await document.metadata.getMap(objectPath);
+    }, options);
+  }
+  async putMetadata(objectPath, key, value, options = {}) {
+    return await this.#writeDocument(async (document) => {
+      await document.metadata.put(
+        parseObjectMetadataTarget(objectPath),
+        key,
+        value
+      );
+      return await document.metadata.getMap(objectPath);
+    }, options);
+  }
+  async deleteMetadata(objectPath, key, options = {}) {
+    return await this.#writeDocument(async (document) => {
+      await document.metadata.deleteKey(objectPath, key);
+      return await document.metadata.getMap(objectPath);
+    }, options);
+  }
+  async clearMetadata(objectPath, options = {}) {
+    return await this.#writeDocument(async (document) => {
+      await document.metadata.clear(objectPath);
+      return await document.metadata.getMap(objectPath);
+    }, options);
+  }
+  async resolveScope(options = {}) {
+    return await this.#readDocument(
+      async (document) => await resolveArchiveScope(document, this.objectUri, options.depth),
+      options
+    );
+  }
+  async #readDocument(operation, options = {}) {
+    return await this.#runtime.run(
+      async () => await new import_wiki_graph_core5.WikiGraphArchiveFile(this.#location.archiveFile).readDocument(
+        operation
+      ),
+      options.signal
+    );
+  }
+  async #writeDocument(operation, options = {}) {
+    return await this.#runtime.run(async () => {
+      const result = await new import_wiki_graph_core5.WikiGraphArchiveFile(
+        this.#location.archiveFile
+      ).write(operation, {
+        ...options.searchIndexWritebackPolicy === void 0 ? {} : {
+          searchIndexWritebackPolicy: options.searchIndexWritebackPolicy
+        }
+      });
+      if (options.refreshLibraryIndex !== false) {
+        await this.#refreshLibraryIndex(options.onIndexSyncError);
+      }
+      return result;
+    }, options.signal);
+  }
+  async #resolveScope(document, options) {
+    if (options.chapters !== void 0) return options.chapters;
+    return (await resolveArchiveScope(document, this.objectUri, options.depth))?.chapterIds;
+  }
+  async #resolveQueryChapters(document, options) {
+    const chapters = await this.#resolveScope(document, options);
+    if (options.skipUnindexed !== true) return chapters;
+    const queryable = await (0, import_wiki_graph_core5.listArchiveQueryableChapterIds)(document, {
+      ...chapters === void 0 ? {} : { chapters }
+    });
+    if (queryable.length === 0) {
+      throw new Error(
+        "Wiki Graph query is not ready. No chapters in this scope have a current FTS artifact or source embedding artifact."
+      );
+    }
+    return queryable;
+  }
+  async #refreshLibraryIndex(onError) {
+    if (this.#location.libraryDirtyTarget === void 0) return;
+    if (this.#location.libraryArchiveTarget !== void 0) {
+      await (0, import_wiki_graph_core5.finalizeWikiGraphLibraryArchiveWrite)({
+        target: this.#location.libraryArchiveTarget
+      });
+    }
+    try {
+      const state = await (0, import_wiki_graph_core5.readWikiGraphLibraryIndexState)(
+        this.#location.libraryDirtyTarget
+      );
+      if (state.status !== "missing") {
+        await (0, import_wiki_graph_core5.rebuildWikiGraphLibraryIndex)(this.#location.libraryDirtyTarget);
+      }
+    } catch (error) {
+      onError?.(error);
+    }
+  }
+};
+async function resolveWikiGraphArchiveLocation(uriOrPath) {
+  if (!uriOrPath.startsWith("wikg://")) {
+    return createPathLocation(resolveWikiGraphRuntimePath(uriOrPath));
+  }
+  const parsed = (0, import_wiki_graph_core5.parseLocatedWikiGraphUri)(uriOrPath);
+  const portableArchiveLocator = parsed.archivePath ?? uriOrPath;
+  const archiveLocator = portableArchiveLocator.startsWith("wikg://lib/") ? portableArchiveLocator : resolveWikiGraphRuntimePath(portableArchiveLocator);
+  const libraryArchiveTarget = archiveLocator.startsWith("wikg://lib/") ? (0, import_wiki_graph_core5.parseWikiGraphLibraryUri)(archiveLocator) : void 0;
+  const archiveFile = libraryArchiveTarget?.kind === "archive" ? await (0, import_wiki_graph_core5.resolveWikiGraphLibraryArchiveFile)(archiveLocator) : new NodeFile(archiveLocator);
+  const archivePath = getNodeResourcePath(archiveFile);
+  return {
+    archiveFile,
+    archiveKey: archivePath,
+    archivePath,
+    indexScope: { archiveKey: archivePath, archivePath, kind: "archive-index" },
+    ...libraryArchiveTarget?.kind === "archive" ? {
+      libraryArchiveTarget,
+      libraryDirtyTarget: {
+        isDefault: libraryArchiveTarget.isDefault,
+        kind: "scope",
+        ...libraryArchiveTarget.publicId === void 0 ? {} : { publicId: libraryArchiveTarget.publicId }
+      },
+      publicArchiveUri: portableArchiveLocator
+    } : {},
+    locatedUri: (0, import_wiki_graph_core5.formatLocatedWikiGraphUri)(archivePath, parsed.objectUri)
+  };
+}
+async function ensureArchiveSearchIndex(document, options = {}) {
+  const scope = options.chapters === void 0 ? {} : { chapters: options.chapters };
+  if (await (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document, scope)) return;
+  await (0, import_wiki_graph_core5.rebuildArchiveSearchIndex)(document, void 0, {
+    ...scope,
+    ...options.embeddingProvider === void 0 ? {} : { embeddingProvider: options.embeddingProvider }
+  });
+}
+async function resolveArchiveScope(document, objectUri, depth) {
+  const parsed = parseChapterScopePath(objectUri);
+  if (parsed === void 0 || parsed.kind === "collection" && depth === void 0) {
+    return void 0;
+  }
+  const chapters = await (0, import_wiki_graph_core5.listChapters)(document);
+  const entries = parsed.kind === "collection" ? chapters.filter((chapter) => chapter.depth <= depth) : selectChapterSubtree(
+    chapters,
+    await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, parsed.chapterPath),
+    depth
+  );
+  return { chapterIds: entries.map((entry) => entry.chapterId), entries };
+}
+function parseChapterScopePath(objectUri) {
+  if (objectUri === "wikg://chapter" || objectUri === "wikg://chapter/") {
+    return { kind: "collection" };
+  }
+  const match = /^wikg:\/\/chapter\/([^/].*?)(?:\/)?$/u.exec(objectUri);
+  return match?.[1] === void 0 ? void 0 : { chapterPath: decodeURIComponent(match[1]), kind: "chapter" };
+}
+function selectChapterSubtree(chapters, rootChapterId, depth) {
+  const root = chapters.find((chapter) => chapter.chapterId === rootChapterId);
+  if (root === void 0) {
+    throw new Error(`Chapter ${rootChapterId} does not exist.`);
+  }
+  const prefix = `${root.path}/`;
+  return chapters.filter(
+    (chapter) => chapter.chapterId === root.chapterId || chapter.path.startsWith(prefix) && (depth === void 0 || chapter.depth - root.depth <= depth)
+  );
+}
+function createPathLocation(path) {
+  return {
+    archiveFile: new NodeFile(path),
+    archiveKey: path,
+    archivePath: path,
+    indexScope: { archiveKey: path, archivePath: path, kind: "archive-index" },
+    locatedUri: (0, import_wiki_graph_core5.formatLocatedWikiGraphUri)(path)
+  };
+}
+async function createEmptyArchiveFile(path) {
+  const directoryPath = await (0, import_promises3.mkdtemp)(
+    (0, import_path3.join)((0, import_os3.tmpdir)(), "wikigraph-archive-write-")
+  );
+  try {
+    const directory = new NodeDirectory(directoryPath);
+    const document = await import_wiki_graph_core5.DirectoryDocument.open(directory);
+    try {
+      await document.openSession(async (openedDocument) => {
+        await openedDocument.writeToc({ items: [], version: import_wiki_graph_core5.TOC_FILE_VERSION });
+      });
+    } finally {
+      await document.release();
+    }
+    await (0, import_wiki_graph_core5.writeWikgArchive)(directory, new NodeFile(path));
+  } finally {
+    await (0, import_promises3.rm)(directoryPath, { force: true, recursive: true });
+  }
+}
+function isNodeEEXISTError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function nodePathExists(path) {
+  try {
+    await (0, import_promises3.stat)(path);
+    return true;
+  } catch (error) {
+    if (isNodeENOENTError(error)) return false;
+    throw error;
+  }
+}
+function isNodeENOENTError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function parseObjectMetadataTarget(objectPath) {
+  if (objectPath === "") {
+    return { kind: import_wiki_graph_core5.ObjectMetadataKind.Archive, objectPath };
+  }
+  const chapter = /^chapter\/([1-9][0-9]*)(?:\/.*)?$/u.exec(objectPath);
+  if (chapter?.[1] !== void 0) {
+    return {
+      chapterId: Number(chapter[1]),
+      kind: import_wiki_graph_core5.ObjectMetadataKind.Chapter,
+      objectPath
+    };
+  }
+  const chunk = /^chunk\/([1-9][0-9]*)$/u.exec(objectPath);
+  if (chunk?.[1] !== void 0) {
+    return {
+      chunkId: Number(chunk[1]),
+      kind: import_wiki_graph_core5.ObjectMetadataKind.Chunk,
+      objectPath
+    };
+  }
+  const entity = /^entity\/(Q[1-9][0-9]*)$/u.exec(objectPath);
+  if (entity?.[1] !== void 0) {
+    return {
+      entityQid: entity[1],
+      kind: import_wiki_graph_core5.ObjectMetadataKind.Entity,
+      objectPath
+    };
+  }
+  const triple = /^triple\/(Q[1-9][0-9]*)\/([^/]+)\/(Q[1-9][0-9]*)$/u.exec(
+    objectPath
+  );
+  if (triple?.[1] !== void 0) {
+    return {
+      kind: import_wiki_graph_core5.ObjectMetadataKind.Triple,
+      objectPath,
+      tripleObjectQid: triple[3],
+      triplePredicate: decodeURIComponent(triple[2]),
+      tripleSubjectQid: triple[1]
+    };
+  }
+  return { kind: import_wiki_graph_core5.ObjectMetadataKind.Object, objectPath };
+}
+function withoutOperation(options) {
+  const { signal: _signal, ...rest } = options;
+  return rest;
+}
+function withoutOperationAndScope(options) {
+  const {
+    chapters: _chapters,
+    depth: _depth,
+    signal: _signal,
+    ...rest
+  } = options;
+  return rest;
+}
+async function resolveOptionalChapterPath(document, path) {
+  return path === void 0 ? void 0 : await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+}
+function requireChapter(chapters, chapterId) {
+  const chapter = chapters.find((entry) => entry.chapterId === chapterId);
+  if (chapter === void 0) {
+    throw new Error(`Chapter internal id ${chapterId} does not exist.`);
+  }
+  return chapter;
+}
+function asTextStream(text) {
+  return import_stream.Readable.from([text]);
+}
+async function assertChapterResetAllowed(archive, chapterId, stage) {
+  if (stage === "planned") {
+    await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+      archive,
+      chapterIds: [chapterId],
+      operation: "Resetting chapter to planned"
+    });
+    return;
+  }
+  if (stage === "sourced") {
+    await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+      archive,
+      chapterIds: [chapterId],
+      operation: "Resetting chapter graph",
+      requiresTarget: "reading-graph"
+    });
+  }
+  await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+    archive,
+    chapterIds: [chapterId],
+    operation: "Resetting chapter summary",
+    requiresTarget: "reading-summary"
+  });
+}
+
+// src/wikispine.ts
+var import_child_process = require("child_process");
+var nodeWikispineCommandRunner = {
+  run: async ({ args, command, input, onStdout, signal }) => await new Promise((resolve3, reject) => {
+    signal?.throwIfAborted();
+    const child = (0, import_child_process.spawn)(command, [...args], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stderr = [];
+    let settled = false;
+    const settle = (operation) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      operation();
+    };
+    const abort = () => {
+      child.kill();
+      settle(() => reject(abortError(signal)));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      if (settled) return;
+      try {
+        onStdout(chunk);
+      } catch (error) {
+        child.kill();
+        settle(
+          () => reject(error instanceof Error ? error : new Error(String(error)))
+        );
+      }
+    });
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.on("error", (error) => {
+      settle(
+        () => reject(
+          new Error(`Failed to start wikispine command: ${error.message}`)
+        )
+      );
+    });
+    child.on("close", (exitCode) => {
+      settle(
+        () => resolve3({
+          exitCode,
+          stderr: Buffer.concat(stderr).toString("utf8")
+        })
+      );
+    });
+    child.stdin.end(input);
+  })
+};
+function abortError(signal) {
+  return signal?.reason instanceof Error ? signal.reason : new Error("WikiSpine command aborted.");
+}
+
+// src/config.ts
+var import_ai2 = require("ai");
+var import_wiki_graph_core6 = require("wiki-graph-core");
+var WikiGraphConfigManager = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  async get(section, options = {}) {
+    const value = await this.#runtime.run(
+      async () => await readLocalConfigSection(section)
+    );
+    return options.maskSecrets === true ? maskLocalConfigSection(section, value) : value;
+  }
+  async replace(section, value) {
+    return await this.#runtime.run(
+      async () => await replaceLocalConfigSection(section, value)
+    );
+  }
+  async put(section, key, value) {
+    return await this.#runtime.run(
+      async () => await putLocalConfigValue(section, key, value)
+    );
+  }
+  async delete(section, key) {
+    return await this.#runtime.run(
+      async () => await deleteLocalConfigValue(section, key)
+    );
+  }
+  async clear(section) {
+    return await this.#runtime.run(
+      async () => await clearLocalConfigSection(section)
+    );
+  }
+  async testLLM() {
+    return await this.#runtime.run(async () => {
+      const startedAt = Date.now();
+      const llm = await readLocalConfigSection("llm");
+      const config = {
+        ...typeof llm.apiKey === "string" ? { apiKey: llm.apiKey } : {},
+        ...typeof llm.baseURL === "string" ? { baseURL: llm.baseURL } : {},
+        ...typeof llm.model === "string" ? { model: llm.model } : {},
+        ...typeof llm.name === "string" ? { name: llm.name } : {},
+        ...typeof llm.provider === "string" ? { provider: parseProvider(llm.provider) } : {}
+      };
+      const options = buildWikiGraphLLMOptions({ llm: config });
+      const result = (0, import_ai2.streamText)({
+        maxRetries: 0,
+        messages: [{ content: "Reply with exactly: ok", role: "user" }],
+        model: options.model,
+        temperature: 0
+      });
+      const chunks = [];
+      for await (const chunk of result.textStream) chunks.push(chunk);
+      return {
+        durationMs: Date.now() - startedAt,
+        ...config.model === void 0 ? {} : { model: config.model },
+        ...config.provider === void 0 ? {} : { provider: config.provider },
+        response: chunks.join("").trim()
+      };
+    });
+  }
+  async testEmbedding() {
+    return await this.#runtime.run(async () => {
+      const startedAt = Date.now();
+      const result = await embedQueryText(
+        "Wiki Graph embedding connectivity test.",
+        await readWikiGraphEmbeddingConfig()
+      );
+      return {
+        dimensions: result.dimensions,
+        durationMs: Date.now() - startedAt,
+        model: result.model,
+        provider: result.provider,
+        ...result.usage?.tokens === void 0 ? {} : { tokens: result.usage.tokens }
+      };
+    });
+  }
+  async testWikispine() {
+    return await this.#runtime.run(async () => {
+      const value = await readLocalConfigSection("wikispine");
+      const resolved = resolveWikispineConfig(value);
+      if (resolved === void 0) {
+        throw new Error("WikiSpine provider is not configured.");
+      }
+      const result = await (0, import_wiki_graph_core6.testWikispineRuntime)({
+        ...resolved,
+        ...resolved.provider === "cli" ? { commandRunner: nodeWikispineCommandRunner } : {}
+      });
+      return {
+        durationMs: result.durationMs,
+        ...resolved.provider === "fetch" ? { endpoint: resolved.endpoint } : {},
+        ...result.metadata === void 0 ? {} : { metadata: result.metadata },
+        provider: resolved.provider
+      };
+    });
+  }
+};
+function parseProvider(value) {
+  if (value === "anthropic" || value === "google" || value === "openai" || value === "openai-compatible") {
+    return value;
+  }
+  throw new Error(
+    `Invalid llm.provider: ${value}. Expected anthropic, google, openai, or openai-compatible.`
+  );
+}
+
+// src/continuations.ts
+var import_wiki_graph_core7 = require("wiki-graph-core");
+var WikiGraphContinuationManager = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  async next(options) {
+    return await this.#runtime.run(
+      async () => await this.#next(options),
+      options.signal
+    );
+  }
+  async create(context, cursor) {
+    if (cursor === null || cursor === void 0) return null;
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core7.createContinuationCursor)(
+        createContinuationPayload(context, cursor)
+      )
+    );
+  }
+  async #next(options) {
+    const cursor = await (0, import_wiki_graph_core7.readContinuationCursor)(options.cursor);
+    const continuationCursor = options.format === void 0 ? cursor : { ...cursor, format: options.format };
+    const limit = options.limit ?? 20;
+    if (options.archive !== void 0) {
+      const explicit = await resolveWikiGraphArchiveLocation(options.archive);
+      const cursorArchivePath = getCursorArchivePath(cursor);
+      if (explicit.archivePath !== cursorArchivePath) {
+        throw new Error(
+          `Continuation cursor ${options.cursor} belongs to ${cursorArchivePath}, not ${explicit.archivePath}.`
+        );
+      }
+    }
+    const result = cursor.indexScope.kind === "library-index" ? await continueLibraryCursor(cursor, limit) : await continueArchiveCursor(cursor, limit);
+    const durableResult = await persistResultCursor(continuationCursor, result);
+    return {
+      cursor: continuationCursor,
+      format: continuationCursor.format,
+      kind: cursor.kind,
+      limit,
+      result: durableResult
+    };
+  }
+};
+async function continueArchiveCursor(cursor, limit) {
+  const location = await resolveWikiGraphArchiveLocation(
+    getCursorArchivePath(cursor)
+  );
+  return await new import_wiki_graph_core7.WikiGraphArchiveFile(location.archiveFile).readDocument(
+    async (document) => {
+      switch (cursor.kind) {
+        case "source-locators":
+          return await (0, import_wiki_graph_core7.listArchiveSourceLocators)(document, cursor.targetUri, {
+            cursor: cursor.cursor,
+            limit
+          });
+        case "collection":
+          return await (0, import_wiki_graph_core7.listArchiveCollection)(
+            document,
+            createCollectionOptions(cursor, limit)
+          );
+        case "search":
+          return await (0, import_wiki_graph_core7.findArchiveObjects)(
+            document,
+            cursor.query ?? "",
+            await createFindOptions(cursor, limit)
+          );
+        case "evidence":
+          return await (0, import_wiki_graph_core7.listArchiveEvidence)(document, cursor.targetUri, {
+            ...cursor.chapters === null ? {} : { chapters: cursor.chapters },
+            cursor: cursor.cursor,
+            limit,
+            order: cursor.order,
+            ...cursor.query === void 0 ? {} : { query: cursor.query },
+            ...cursor.skipUnindexed === void 0 ? {} : { skipUnindexed: cursor.skipUnindexed },
+            ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext }
+          });
+        case "related":
+          return await (0, import_wiki_graph_core7.listRelatedArchiveObjects)(document, cursor.targetUri, {
+            ...cursor.chapters === null ? {} : { chapters: cursor.chapters },
+            cursor: cursor.cursor,
+            ...cursor.evidenceLimit === void 0 ? {} : { evidenceLimit: cursor.evidenceLimit },
+            limit,
+            order: cursor.order,
+            ...cursor.query === void 0 ? {} : { query: cursor.query },
+            ...cursor.role === void 0 ? {} : { role: cursor.role },
+            ...cursor.skipUnindexed === void 0 ? {} : { skipUnindexed: cursor.skipUnindexed },
+            ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext }
+          });
+      }
+    }
+  );
+}
+async function continueLibraryCursor(cursor, limit) {
+  if (cursor.kind === "source-locators") {
+    throw new Error(
+      "Source locator cursors do not use the aggregate library index."
+    );
+  }
+  if (cursor.indexScope.kind !== "library-index") {
+    throw new Error("Internal error: expected a library index cursor.");
+  }
+  const target = await (0, import_wiki_graph_core7.resolveWikiGraphLibraryQueryTargetById)(
+    cursor.indexScope.libraryId
+  );
+  switch (cursor.kind) {
+    case "collection":
+      return await (requireLibraryQuery(cursor) === "archive-members" ? (0, import_wiki_graph_core7.listWikiGraphLibraryArchiveMembers)(
+        target,
+        createCollectionOptions(cursor, limit)
+      ) : (0, import_wiki_graph_core7.listWikiGraphLibraryObjects)(
+        target,
+        createCollectionOptions(cursor, limit)
+      ));
+    case "search":
+      return await (requireLibraryQuery(cursor) === "archive-members" ? (0, import_wiki_graph_core7.findWikiGraphLibraryArchiveMembers)(
+        target,
+        cursor.query ?? "",
+        await createFindOptions(cursor, limit)
+      ) : (0, import_wiki_graph_core7.findWikiGraphLibraryObjects)(
+        target,
+        cursor.query ?? "",
+        await createFindOptions(cursor, limit)
+      ));
+    case "evidence":
+      return await (0, import_wiki_graph_core7.listWikiGraphLibraryEvidence)(target, cursor.targetUri, {
+        cursor: cursor.cursor,
+        limit,
+        order: cursor.order,
+        ...cursor.query === void 0 ? {} : { query: cursor.query },
+        ...cursor.skipUnindexed === void 0 ? {} : { skipUnindexed: cursor.skipUnindexed },
+        ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext }
+      });
+    case "related":
+      return await (0, import_wiki_graph_core7.listRelatedWikiGraphLibraryObjects)(
+        target,
+        cursor.targetUri,
+        {
+          cursor: cursor.cursor,
+          ...cursor.evidenceLimit === void 0 ? {} : { evidenceLimit: cursor.evidenceLimit },
+          limit,
+          order: cursor.order,
+          ...cursor.query === void 0 ? {} : { query: cursor.query },
+          ...cursor.role === void 0 ? {} : { role: cursor.role },
+          ...cursor.skipUnindexed === void 0 ? {} : { skipUnindexed: cursor.skipUnindexed },
+          ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext }
+        }
+      );
+  }
+}
+function createCollectionOptions(cursor, limit) {
+  return {
+    ...cursor.backlinks === void 0 ? {} : { backlinks: cursor.backlinks },
+    ...cursor.chapters === null ? {} : { chapters: cursor.chapters },
+    cursor: cursor.cursor,
+    ...cursor.evidenceLimit === void 0 ? {} : { evidenceLimit: cursor.evidenceLimit },
+    ...cursor.ids === null ? {} : { ids: cursor.ids },
+    limit,
+    order: cursor.order,
+    ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext },
+    ...cursor.triplePattern === void 0 ? {} : { triplePattern: cursor.triplePattern },
+    ...cursor.types === null ? {} : {
+      types: cursor.types
+    }
+  };
+}
+async function createFindOptions(cursor, limit) {
+  const embeddingProvider = await createConfiguredEmbeddingProvider();
+  return {
+    archiveKey: cursor.archiveKey,
+    ...cursor.backlinks === void 0 ? {} : { backlinks: cursor.backlinks },
+    ...cursor.chapters == null ? {} : { chapters: cursor.chapters },
+    cursor: cursor.cursor,
+    ...cursor.evidenceLimit === void 0 ? {} : { evidenceLimit: cursor.evidenceLimit },
+    limit,
+    ...cursor.skipUnindexed === void 0 ? {} : { skipUnindexed: cursor.skipUnindexed },
+    ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext },
+    ...cursor.triplePattern === void 0 ? {} : { triplePattern: cursor.triplePattern },
+    ...cursor.types === null ? {} : { types: cursor.types },
+    ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+  };
+}
+function requireLibraryQuery(cursor) {
+  if ((cursor.kind === "collection" || cursor.kind === "search") && cursor.libraryQuery !== void 0) {
+    return cursor.libraryQuery;
+  }
+  throw new Error(
+    "Library continuation cursor is missing its typed query variant."
+  );
+}
+function getCursorArchivePath(cursor) {
+  return cursor.indexScope.kind === "archive-index" ? cursor.indexScope.archivePath : cursor.archivePath;
+}
+async function persistResultCursor(cursor, result) {
+  if (result.nextCursor === null) return result;
+  const nextCursor = await (0, import_wiki_graph_core7.createContinuationCursor)({
+    ...cursor,
+    cursor: result.nextCursor
+  });
+  return { ...result, nextCursor };
+}
+function createContinuationPayload(context, cursor) {
+  switch (context.continuationKind ?? "search") {
+    case "source-locators":
+      return {
+        archiveKey: context.archiveKey,
+        archivePath: context.archivePath,
+        cursor,
+        format: context.format,
+        indexScope: context.indexScope,
+        kind: "source-locators",
+        targetUri: requireTargetUri(context, "Source locator")
+      };
+    case "evidence":
+      return {
+        archiveKey: context.archiveKey,
+        archivePath: context.archivePath,
+        chapters: context.chapters ?? null,
+        cursor,
+        format: context.format,
+        indexScope: context.indexScope,
+        kind: "evidence",
+        order: context.order ?? "doc-asc",
+        ...context.query === void 0 ? {} : { query: context.query },
+        ...context.skipUnindexed === void 0 ? {} : { skipUnindexed: context.skipUnindexed },
+        ...context.sourceContext === void 0 ? {} : { sourceContext: context.sourceContext },
+        targetUri: requireTargetUri(context, "Evidence")
+      };
+    case "related":
+      return {
+        archiveKey: context.archiveKey,
+        archivePath: context.archivePath,
+        chapters: context.chapters ?? null,
+        cursor,
+        ...context.evidenceLimit === void 0 ? {} : { evidenceLimit: context.evidenceLimit },
+        format: context.format,
+        indexScope: context.indexScope,
+        kind: "related",
+        order: context.order ?? "doc-asc",
+        ...context.query === void 0 ? {} : { query: context.query },
+        ...context.role === void 0 ? {} : { role: context.role },
+        ...context.skipUnindexed === void 0 ? {} : { skipUnindexed: context.skipUnindexed },
+        ...context.sourceContext === void 0 ? {} : { sourceContext: context.sourceContext },
+        targetUri: requireTargetUri(context, "Related")
+      };
+    case "collection":
+      return {
+        archiveKey: context.archiveKey,
+        archivePath: context.archivePath,
+        ...context.backlinks === void 0 ? {} : { backlinks: context.backlinks },
+        chapters: context.chapters ?? null,
+        cursor,
+        ...context.evidenceLimit === void 0 ? {} : { evidenceLimit: context.evidenceLimit },
+        format: context.format,
+        ids: context.ids ?? null,
+        indexScope: context.indexScope,
+        kind: "collection",
+        ...createLibraryQueryPayload(context),
+        order: context.order ?? "doc-asc",
+        ...context.sourceContext === void 0 ? {} : { sourceContext: context.sourceContext },
+        ...context.triplePattern === void 0 ? {} : { triplePattern: context.triplePattern },
+        types: context.types
+      };
+    case "search":
+      return {
+        archiveKey: context.archiveKey,
+        archivePath: context.archivePath,
+        ...context.backlinks === void 0 ? {} : { backlinks: context.backlinks },
+        ...context.chapters === void 0 ? {} : { chapters: context.chapters },
+        cursor,
+        ...context.evidenceLimit === void 0 ? {} : { evidenceLimit: context.evidenceLimit },
+        format: context.format,
+        indexScope: context.indexScope,
+        kind: "search",
+        ...createLibraryQueryPayload(context),
+        ...context.query === void 0 ? {} : { query: context.query },
+        ...context.skipUnindexed === void 0 ? {} : { skipUnindexed: context.skipUnindexed },
+        ...context.sourceContext === void 0 ? {} : { sourceContext: context.sourceContext },
+        ...context.triplePattern === void 0 ? {} : { triplePattern: context.triplePattern },
+        types: context.types
+      };
+  }
+}
+function requireTargetUri(context, label) {
+  if (context.targetUri !== void 0) return context.targetUri;
+  throw new Error(`${label} continuation cursors require a target URI.`);
+}
+function createLibraryQueryPayload(context) {
+  if (context.indexScope.kind !== "library-index") return {};
+  if (context.libraryQuery !== void 0) {
+    return { libraryQuery: context.libraryQuery };
+  }
+  throw new Error(
+    "Library collection and search continuations require an explicit query variant."
+  );
+}
+
+// src/default-worker.ts
+var import_wiki_graph_core11 = require("wiki-graph-core");
+var import_worker3 = require("wiki-graph-core/worker");
+
+// src/stage.ts
+var import_wiki_graph_core8 = require("wiki-graph-core");
+var import_wiki_graph_core9 = require("wiki-graph-core");
+var import_wiki_graph_core10 = require("wiki-graph-core");
+function createStageLLM(config, options) {
+  const llmOptions = buildWikiGraphLLMOptions(config);
+  return new import_wiki_graph_core10.LLM({
+    sampling: (0, import_wiki_graph_core9.createDefaultWikiGraphSampling)({
+      ...llmOptions.temperature === void 0 ? {} : { temperature: llmOptions.temperature },
+      ...llmOptions.topP === void 0 ? {} : { topP: llmOptions.topP }
+    }),
+    ...llmOptions,
+    ...options?.cacheDirectory === void 0 ? {} : { cacheDirectory: options.cacheDirectory },
+    ...options?.logDirectory === void 0 ? {} : { logDirectory: options.logDirectory },
+    ...options?.onStreamProgress === void 0 ? {} : { onStreamProgress: options.onStreamProgress },
+    ...options?.onTokenUsage === void 0 ? {} : { onTokenUsage: options.onTokenUsage }
+  });
+}
+async function loadRequiredStageConfig(options) {
+  const config = await loadWikiGraphRuntimeConfig({
+    ...options.llmJSON === void 0 ? {} : { llmJSON: options.llmJSON }
+  });
+  if (config.llm?.provider === void 0 || config.llm.model === void 0) {
+    throw new Error(
+      "Missing LLM configuration. Set --llm for one run, or configure `wikg://local/config/llm` with provider and model."
+    );
+  }
+  return config;
+}
+
+// src/worker.ts
+var import_worker = require("wiki-graph-core/worker");
+var import_worker2 = require("wiki-graph-core/worker");
+async function runBuildJobWorker(options) {
+  installNodeWikiGraphPlatform();
+  const { stateDir, ...coreOptions } = options;
+  await withNodeWikiGraphStorage(
+    stateDir,
+    async () => await (0, import_worker.runBuildJobWorker)(coreOptions)
+  );
+}
+
+// src/default-worker.ts
+async function runWikiGraphQueueWorker(options = {}) {
+  const config = await loadWikiGraphRuntimeConfig();
+  await runBuildJobWorker({
+    concurrency: config.concurrent?.job ?? DEFAULT_GENERATION_JOB_CONCURRENCY,
+    executeJob: async (job, reporter, context) => {
+      await (0, import_wiki_graph_core11.withLoggingContext)(
+        { logDirectory: job.log, operation: "build-job" },
+        async () => await executeBuildJob(job, reporter, context)
+      );
+    },
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  });
+}
+async function executeBuildJob(job, reporter, context) {
+  const config = await loadWikiGraphRuntimeConfig({
+    ...job.llmJSON === void 0 ? {} : { llmJSON: job.llmJSON }
+  });
+  const execution = await openJobExecutor(
+    job,
+    config,
+    context.signal,
+    reporter
+  );
+  try {
+    if (job.target === "reading-summary") {
+      let stage = await readChapterStage(job);
+      if (stage === "sourced") {
+        await executeStep(job, "reading-graph", execution, reporter, context, {
+          ...execution.extractionPrompt === void 0 ? {} : { extractionPrompt: execution.extractionPrompt }
+        });
+        stage = await readChapterStage(job);
+      }
+      if (stage === "summarized") return;
+      if (stage !== "graphed") {
+        throw new Error(
+          `Chapter ${job.chapterId} is ${stage}. Cannot generate summary.`
+        );
+      }
+      await executeStep(job, "reading-summary", execution, reporter, context, {
+        ...job.prompt === void 0 ? {} : { prompt: job.prompt }
+      });
+      return;
+    }
+    if (job.target === "reading-graph") {
+      const stage = await readChapterStage(job);
+      if (stage === "graphed" || stage === "summarized") return;
+      if (stage !== "sourced") {
+        throw new Error(
+          `Chapter ${job.chapterId} is ${stage}. Cannot generate Reading Graph.`
+        );
+      }
+    }
+    if (job.target === "knowledge-graph") {
+      const stage = await readChapterStage(job);
+      if (stage === "planned") {
+        throw new Error(
+          `Chapter ${job.chapterId} is planned. Set source before generating Knowledge Graph.`
+        );
+      }
+    }
+    await executeStep(job, job.target, execution, reporter, context, {
+      ...job.target === "reading-graph" ? { extractionPrompt: execution.extractionPrompt } : {},
+      ...job.target === "knowledge-graph" ? { policyPrompt: execution.knowledgeGraphPrompt } : {}
+    });
+  } finally {
+    await execution.close();
+  }
+}
+async function executeStep(job, kind, execution, reporter, context, inputOptions) {
+  await reporter.throwIfStopped();
+  await reporter.stepStarted(kind);
+  if (kind === "reading-graph" || kind === "knowledge-graph") {
+    await assertCurrentFtsArtifact(job);
+  }
+  const stepWorkspace = await resetStepWorkspace(job.workspace, kind);
+  const inputFile = await stepWorkspace.createFile("input.jsonl");
+  const outputWorkspace = await stepWorkspace.createDirectory("output");
+  const revision = await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).readDocument(
+    async (document) => {
+      await (0, import_wiki_graph_core11.getChapterDetails)(document, job.chapterId);
+      return await (0, import_worker3.writeChapterJobInputFile)(
+        document,
+        job.chapterId,
+        kind,
+        inputFile,
+        inputOptions
+      );
+    }
+  );
+  await (0, import_wiki_graph_core11.recordBuildJobInputRevision)({
+    currentRevision: revision,
+    jobId: job.jobId,
+    ownerId: requireRunningJobOwnerId(job)
+  });
+  await reporter.updatePhase({
+    done: 0,
+    phase: kind.startsWith("index-") ? "indexing" : "grounding",
+    total: 1,
+    unit: "item"
+  });
+  const result = await execution.executor({
+    inputFile,
+    kind,
+    progress: reporter,
+    revision,
+    signal: context.signal,
+    workspace: outputWorkspace
+  });
+  if (result.revision !== revision) {
+    throw new Error(
+      `Chapter job returned revision ${result.revision}; expected ${revision}.`
+    );
+  }
+  await reporter.updatePhase({
+    done: 0,
+    phase: "committing",
+    total: 1,
+    unit: "item"
+  });
+  await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).write(async (document) => {
+    assertJobStillRunning(await (0, import_wiki_graph_core11.getBuildJob)(job.jobId));
+    await (0, import_worker3.applyChapterJobArtifactFile)(
+      document,
+      job.chapterId,
+      kind,
+      revision,
+      result.artifactFile
+    );
+  });
+  await reporter.updatePhase({
+    done: 1,
+    phase: "committing",
+    total: 1,
+    unit: "item"
+  });
+  await reporter.stepCompleted(kind);
+  assertJobStillRunning(await (0, import_wiki_graph_core11.getBuildJob)(job.jobId));
+}
+async function openJobExecutor(job, config, signal, reporter) {
+  const generation = !job.target.startsWith("index-");
+  const stageConfig = generation ? await loadRequiredStageConfig({
+    ...job.llmJSON === void 0 ? {} : { llmJSON: job.llmJSON }
+  }) : void 0;
+  const llm = stageConfig === void 0 ? void 0 : createStageLLM(stageConfig, {
+    cacheDirectory: job.cache,
+    logDirectory: job.log,
+    onTokenUsage: async (usage) => {
+      await reporter.addTokenUsage(usage);
+    }
+  });
+  const promptSource = job.prompt ?? stageConfig?.prompt;
+  const wikispine = job.target === "knowledge-graph" ? requireKnowledgeGraphWikispineConfig(config) : void 0;
+  const request = llm === void 0 ? void 0 : async (messages, index, maxRetries) => await llm.request(messages, {
+    retryIndex: index,
+    retryMax: maxRetries,
+    scope: import_wiki_graph_core11.WikiGraphScope.ReaderExtraction,
+    signal
+  });
+  if (request !== void 0 && llm !== void 0) {
+    request.lazy = async (operation) => await llm.request(async () => await operation(request));
+  }
+  const wikimediaResolver = job.target !== "knowledge-graph" ? void 0 : await (0, import_wiki_graph_core11.openWikimediaResolver)(
+    config.wikimedia === void 0 ? {
+      kind: "local",
+      llmRequest: requireValue(
+        request,
+        "Local Wikimedia resolution requires an LLM."
+      )
+    } : {
+      endpoint: config.wikimedia.endpoint,
+      kind: "remote",
+      token: config.wikimedia.token
+    }
+  );
+  const embeddingProvider = job.target === "index-embedding-source" || job.target === "index-embedding-summary" ? buildSearchIndexEmbeddingProvider(requireEmbeddingConfig(config)) : void 0;
+  return {
+    async close() {
+      await wikimediaResolver?.close();
+    },
+    executor: (0, import_worker3.createLocalChapterJobFileExecutor)({
+      ...embeddingProvider === void 0 ? {} : { embeddingProvider },
+      ...llm === void 0 ? {} : { llm },
+      ...wikimediaResolver === void 0 ? {} : { wikimediaResolver },
+      ...wikispine === void 0 ? {} : {
+        wikispine: {
+          ...wikispine,
+          ...wikispine.provider === "cli" ? { commandRunner: nodeWikispineCommandRunner } : {}
+        }
+      }
+    }),
+    ...promptSource === void 0 ? {} : { extractionPrompt: (0, import_wiki_graph_core8.resolveExtractionPrompt)(promptSource) },
+    ...promptSource === void 0 ? {} : {
+      knowledgeGraphPrompt: (0, import_wiki_graph_core8.resolveKnowledgeGraphRecallPrompt)(promptSource)
+    }
+  };
+}
+async function resetStepWorkspace(workspace, kind) {
+  const name = `chapter-job-${kind}`;
+  if (await workspace.getDirectory(name) !== void 0) {
+    await workspace.remove(name, { recursive: true });
+  }
+  return await workspace.createDirectory(name);
+}
+async function readChapterStage(job) {
+  return await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).readDocument(
+    async (document) => (await (0, import_wiki_graph_core11.getChapterDetails)(document, job.chapterId)).stage
+  );
+}
+async function assertCurrentFtsArtifact(job) {
+  await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).readDocument(async (document) => {
+    const revision = await document.serials.getRevision(job.chapterId);
+    const artifact = await document.indexArtifacts.get(job.chapterId, "fts");
+    if (artifact?.sourceRevision !== revision) {
+      throw new Error(
+        `Chapter ${job.chapterId} needs a current FTS index artifact before running ${job.target}.`
+      );
+    }
+  });
+}
+function requireEmbeddingConfig(config) {
+  if (config.embedding !== void 0) return config.embedding;
+  throw new Error(
+    "Missing embeddings configuration. Configure `wikg://local/config/embeddings` before building embedding index artifacts."
+  );
+}
+function requireKnowledgeGraphWikispineConfig(config) {
+  if (config.wikispine?.provider !== void 0) return config.wikispine;
+  throw new Error(
+    "Knowledge Graph requires WikiSpine. Configure `wikg://local/config/wikispine` with provider `cli` or `fetch` and test the provider before running the worker."
+  );
+}
+function requireRunningJobOwnerId(job) {
+  if (job.ownerId === void 0) {
+    throw new Error(`Build job ${job.jobId} has no running owner.`);
+  }
+  return job.ownerId;
+}
+function assertJobStillRunning(job) {
+  if (job.state !== "running") {
+    throw new Error(`Job ${job.jobId} is ${job.state}. Stop before flushing.`);
+  }
+}
+function requireValue(value, message) {
+  if (value === void 0) throw new Error(message);
+  return value;
+}
+
+// src/entry-context.ts
+var DANGEROUS_RUNTIME_ENV_NAMES = [
+  "WIKIGRAPH_DEV",
+  "WIKIGRAPH_ENV_POLICY",
+  "WIKIGRAPH_QUEUE_DISABLE_AUTOSTART",
+  "WIKIGRAPH_STATE_DIR"
+];
+function createEntryRuntimeContext(options) {
+  const environment = createMergedEnvironment(options.env);
+  if (options.envPolicy === "production") {
+    const blocked = DANGEROUS_RUNTIME_ENV_NAMES.filter(
+      (name) => environment[name] !== void 0
+    );
+    if (blocked.length > 0) {
+      throw new Error(
+        `Wiki Graph production entries do not support runtime env overrides: ${blocked.join(", ")}. Use the development entry or explicit SDK options instead.`
+      );
+    }
+    return {
+      env: environment,
+      envPolicy: options.envPolicy,
+      stateDir: options.stateDir
+    };
+  }
+  const envStateDir = environment.WIKIGRAPH_DEV ?? environment.WIKIGRAPH_STATE_DIR;
+  const stateDir = normalizeOptionalPath(options.stateDir ?? envStateDir);
+  if (stateDir === void 0) {
+    throw new Error(
+      "Wiki Graph development entries require an explicit runtime state directory."
+    );
+  }
+  const devProjectRoot = normalizeOptionalPath(options.devProjectRoot);
+  if (devProjectRoot === void 0) {
+    throw new Error(
+      "Wiki Graph development entries require an explicit project root."
+    );
+  }
+  return {
+    devProjectRoot,
+    env: environment,
+    envPolicy: options.envPolicy,
+    stateDir
+  };
+}
+function createMergedEnvironment(environment) {
+  if (environment === void 0) {
+    return { ...process.env };
+  }
+  return {
+    ...process.env,
+    ...environment
+  };
+}
+function normalizeOptionalPath(path) {
+  if (path === void 0 || path.trim() === "") {
+    return void 0;
+  }
+  return path;
+}
+
+// src/jobs.ts
+var import_wiki_graph_core12 = require("wiki-graph-core");
+var TERMINAL_STATES = /* @__PURE__ */ new Set(["canceled", "failed", "succeeded"]);
+var TERMINAL_EVENT_GRACE_READS = 3;
+var CORE_BUILD_JOB_BACKEND = {
+  add: async (options) => await (0, import_wiki_graph_core12.addBuildJob)(options),
+  boost: async (jobId) => await (0, import_wiki_graph_core12.boostBuildJob)(jobId),
+  cancel: async (jobId) => await (0, import_wiki_graph_core12.cancelBuildJob)(jobId),
+  get: async (jobId) => await (0, import_wiki_graph_core12.getBuildJob)(jobId),
+  list: async (options) => await (0, import_wiki_graph_core12.listBuildJobs)(options),
+  pause: async (jobId) => await (0, import_wiki_graph_core12.pauseBuildJob)(jobId),
+  readEventChunk: async (job, cursor) => await readIncrementalBuildJobEvents(job, cursor),
+  readEvents: async (job) => await (0, import_wiki_graph_core12.readBuildJobEvents)(job),
+  resume: async (jobId) => await (0, import_wiki_graph_core12.resumeBuildJob)(jobId),
+  setTarget: async (jobId, target) => await (0, import_wiki_graph_core12.updateBuildJobTarget)(jobId, target)
+};
+async function readIncrementalBuildJobEvents(job, cursor) {
+  let reader;
+  try {
+    reader = await job.events.openReader();
+  } catch {
+    return { cursor, events: await (0, import_wiki_graph_core12.readBuildJobEvents)(job) };
+  }
+  try {
+    const offset = cursor <= reader.size ? cursor : 0;
+    const content = new TextDecoder().decode(
+      await reader.read(offset, reader.size - offset)
+    );
+    return {
+      cursor: reader.size,
+      events: content.split("\n").filter((line) => line.trim() !== "").map((line) => JSON.parse(line))
+    };
+  } finally {
+    await reader.close();
+  }
+}
+var WikiGraphJobManager = class {
+  #runtime;
+  #backend;
+  #subscriptions = /* @__PURE__ */ new Set();
+  constructor(runtime, backend = CORE_BUILD_JOB_BACKEND) {
+    this.#runtime = runtime;
+    this.#backend = backend;
+  }
+  async create(options) {
+    const job = await this.#runtime.run(
+      async () => await this.#backend.add({
+        ...options,
+        archive: typeof options.archive === "string" ? new NodeFile(resolveWikiGraphRuntimePath(options.archive)) : options.archive
+      })
+    );
+    return this.#createHandle(job);
+  }
+  async clean() {
+    return await this.#runtime.run(async () => await (0, import_wiki_graph_core12.cleanBuildJobs)());
+  }
+  async get(jobId) {
+    return this.#createHandle(
+      await this.#runtime.run(async () => await this.#backend.get(jobId))
+    );
+  }
+  async resolveId(reference) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core12.resolveBuildJobId)(reference)
+    );
+  }
+  async list(options = {}) {
+    const jobs = await this.#runtime.run(async () => {
+      const normalized = {
+        ...options.activeOnly === void 0 ? {} : { activeOnly: options.activeOnly },
+        ...options.all === void 0 ? {} : { all: options.all },
+        ...options.archive === void 0 ? {} : {
+          archive: typeof options.archive === "string" ? new NodeFile(resolveWikiGraphRuntimePath(options.archive)) : options.archive
+        }
+      };
+      return await this.#backend.list(normalized);
+    });
+    return jobs.map((job) => this.#createHandle(job));
+  }
+  async resolveChapters(jobs) {
+    return await this.#runtime.run(async () => {
+      const jobsByArchive = /* @__PURE__ */ new Map();
+      for (const job of jobs) {
+        const archivePath = getBuildJobArchivePath(job);
+        const grouped = jobsByArchive.get(archivePath) ?? [];
+        grouped.push(job);
+        jobsByArchive.set(archivePath, grouped);
+      }
+      const entries = (await Promise.all(
+        [...jobsByArchive].map(async ([archivePath, archiveJobs]) => {
+          try {
+            const chapters = await new import_wiki_graph_core12.WikiGraphArchiveFile(
+              new NodeFile(archivePath)
+            ).readDocument(async (document) => await (0, import_wiki_graph_core12.listChapters)(document));
+            const chaptersById = new Map(
+              chapters.map((chapter) => [chapter.chapterId, chapter])
+            );
+            return archiveJobs.flatMap((job) => {
+              const chapter = chaptersById.get(job.chapterId);
+              return chapter === void 0 ? [] : [
+                [
+                  job.jobId,
+                  {
+                    locatedUri: (0, import_wiki_graph_core12.formatLocatedChapterUri)(
+                      archivePath,
+                      chapter.path
+                    ),
+                    title: chapter.title,
+                    uri: chapter.uri
+                  }
+                ]
+              ];
+            });
+          } catch {
+            return [];
+          }
+        })
+      )).flat();
+      return new Map(entries);
+    });
+  }
+  async resolveChapter(job) {
+    return (await this.resolveChapters([job])).get(job.jobId);
+  }
+  async enqueue(options) {
+    return await this.#runtime.run(async () => {
+      const location = await resolveWikiGraphArchiveLocation(options.archive);
+      const target = options.target ?? "reading-summary";
+      await validateQueueTargetConfig(target, options.llmJSON);
+      const selectedExplicitly = options.chapterId !== void 0 || options.chapterIds !== void 0 || options.chapterPath !== void 0 || options.depth !== void 0;
+      const candidates = await new import_wiki_graph_core12.WikiGraphArchiveFile(
+        location.archiveFile
+      ).readDocument(async (document) => {
+        const chapters = await (0, import_wiki_graph_core12.listChapters)(document);
+        const selected = await selectQueueChapters(document, chapters, options);
+        const checked = await Promise.all(
+          selected.map(async (chapter) => ({
+            chapter,
+            reason: await readQueueReadinessReason(document, chapter, target)
+          }))
+        );
+        return checked;
+      });
+      const created = [];
+      const skipped = [];
+      for (const candidate of candidates) {
+        if (candidate.reason !== void 0) {
+          if (selectedExplicitly && candidates.length === 1) {
+            throw new Error(
+              formatQueueReadinessError(
+                candidate.chapter,
+                target,
+                candidate.reason
+              )
+            );
+          }
+          skipped.push({
+            chapter: candidate.chapter,
+            reason: candidate.reason
+          });
+          continue;
+        }
+        try {
+          created.push({
+            chapter: candidate.chapter,
+            job: await this.create({
+              archive: location.archiveFile,
+              boost: options.boost ?? false,
+              chapterId: candidate.chapter.chapterId,
+              ...options.llmJSON === void 0 ? {} : { llmJSON: options.llmJSON },
+              ...options.prompt === void 0 ? {} : { prompt: options.prompt },
+              target
+            })
+          });
+        } catch (error) {
+          if (selectedExplicitly && candidates.length === 1) throw error;
+          skipped.push({
+            chapter: candidate.chapter,
+            reason: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      return { created, skipped };
+    });
+  }
+  async planEnqueue(options) {
+    return await this.#runtime.run(async () => {
+      const location = await resolveWikiGraphArchiveLocation(options.archive);
+      const target = options.target ?? "reading-summary";
+      await validateQueueTargetConfig(target, options.llmJSON);
+      const selectedExplicitly = options.chapterId !== void 0 || options.chapterIds !== void 0 || options.chapterPath !== void 0 || options.depth !== void 0;
+      const candidates = await new import_wiki_graph_core12.WikiGraphArchiveFile(
+        location.archiveFile
+      ).readDocument(async (document) => {
+        const chapters = await (0, import_wiki_graph_core12.listChapters)(document);
+        const selected = await selectQueueChapters(document, chapters, options);
+        return await Promise.all(
+          selected.map(async (chapter) => ({
+            chapter,
+            reason: await readQueueReadinessReason(document, chapter, target)
+          }))
+        );
+      });
+      if (selectedExplicitly && candidates.length === 1 && candidates[0]?.reason !== void 0) {
+        throw new Error(
+          formatQueueReadinessError(
+            candidates[0].chapter,
+            target,
+            candidates[0].reason
+          )
+        );
+      }
+      return {
+        ready: candidates.filter((item) => item.reason === void 0).map((item) => item.chapter),
+        skipped: candidates.flatMap(
+          (item) => item.reason === void 0 ? [] : [{ chapter: item.chapter, reason: item.reason }]
+        )
+      };
+    });
+  }
+  close() {
+    for (const controller of this.#subscriptions) controller.abort();
+    this.#subscriptions.clear();
+  }
+  trackSubscription(controller) {
+    this.#subscriptions.add(controller);
+    return () => this.#subscriptions.delete(controller);
+  }
+  #createHandle(snapshot) {
+    return new WikiGraphJob(this, this.#runtime, this.#backend, snapshot);
+  }
+};
+function getBuildJobArchivePath(job) {
+  const record = job;
+  if (record.archive !== void 0) {
+    return getNodeResourcePath(record.archive);
+  }
+  if (typeof record.archivePath === "string") return record.archivePath;
+  throw new TypeError("Build job is missing archive");
+}
+var WikiGraphJob = class {
+  #manager;
+  #runtime;
+  #backend;
+  #snapshot;
+  constructor(manager, runtime, backend, snapshot) {
+    this.#manager = manager;
+    this.#runtime = runtime;
+    this.#backend = backend;
+    this.#snapshot = snapshot;
+  }
+  get id() {
+    return this.#snapshot.jobId;
+  }
+  get snapshot() {
+    return this.#snapshot;
+  }
+  async status() {
+    return await this.#update(async () => await this.#backend.get(this.id));
+  }
+  async pause() {
+    return await this.#update(async () => await this.#backend.pause(this.id));
+  }
+  async resume() {
+    return await this.#update(async () => await this.#backend.resume(this.id));
+  }
+  async cancel() {
+    return await this.#update(async () => await this.#backend.cancel(this.id));
+  }
+  async boost() {
+    return await this.#update(async () => await this.#backend.boost(this.id));
+  }
+  async setTarget(target) {
+    return await this.#update(
+      async () => await this.#backend.setTarget(this.id, target)
+    );
+  }
+  async *events(options = {}) {
+    let seenSeq = 0;
+    let cursor = 0;
+    let job = this.#snapshot;
+    if (options.from === "now") {
+      job = await this.status();
+      const chunk = await this.#readEventChunkSafely(job, cursor);
+      const events = chunk.events;
+      cursor = chunk.cursor;
+      seenSeq = events.at(-1)?.seq ?? 0;
+      if (isTerminalState(job.state)) return;
+    }
+    let terminalReadsWithoutEvent = 0;
+    while (options.signal?.aborted !== true) {
+      const chunk = await this.#readEventChunkSafely(job, cursor);
+      const events = chunk.events;
+      cursor = chunk.cursor;
+      let sawTerminalEvent = false;
+      for (const event of events) {
+        if (event.seq <= seenSeq) continue;
+        seenSeq = event.seq;
+        sawTerminalEvent ||= isTerminalEvent(event);
+        yield event;
+      }
+      if (sawTerminalEvent) return;
+      job = await this.status();
+      if (isTerminalState(job.state)) {
+        terminalReadsWithoutEvent += 1;
+        if (terminalReadsWithoutEvent >= TERMINAL_EVENT_GRACE_READS) return;
+      } else {
+        terminalReadsWithoutEvent = 0;
+      }
+      await wait(options.pollIntervalMs ?? 1e3, options.signal);
+    }
+  }
+  subscribe(listener, options = {}) {
+    const controller = new AbortController();
+    const untrack = this.#manager.trackSubscription(controller);
+    const stopForwarding = forwardAbort(options.signal, controller);
+    void (async () => {
+      try {
+        for await (const event of this.events({
+          ...options,
+          signal: controller.signal
+        })) {
+          try {
+            await listener(event);
+          } catch (error) {
+            options.onError?.(error);
+          }
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) options.onError?.(error);
+      } finally {
+        stopForwarding();
+        untrack();
+      }
+    })();
+    return () => controller.abort();
+  }
+  async #update(operation) {
+    this.#snapshot = await this.#runtime.run(operation);
+    return this.#snapshot;
+  }
+  async #readEventChunk(job, cursor) {
+    return await this.#runtime.run(async () => {
+      if (this.#backend.readEventChunk !== void 0) {
+        return await this.#backend.readEventChunk(job, cursor);
+      }
+      const events = await this.#backend.readEvents?.(job);
+      return { cursor: 0, events: events ?? [] };
+    });
+  }
+  async #readEventChunkSafely(job, cursor) {
+    try {
+      return await this.#readEventChunk(job, cursor);
+    } catch {
+      return { cursor, events: [] };
+    }
+  }
+};
+async function selectQueueChapters(document, chapters, options) {
+  const ids = options.chapterIds ?? (options.chapterId === void 0 ? void 0 : [options.chapterId]);
+  if (ids !== void 0) {
+    const selected = new Set(ids);
+    for (const id of selected) requireQueueChapter(chapters, id);
+    return chapters.filter((chapter) => selected.has(chapter.chapterId));
+  }
+  if (options.chapterPath === void 0) {
+    return options.depth === void 0 ? chapters : chapters.filter((chapter) => chapter.depth <= options.depth);
+  }
+  const rootId = await (0, import_wiki_graph_core12.resolveChapterPathReadonly)(
+    document,
+    options.chapterPath
+  );
+  const root = requireQueueChapter(chapters, rootId);
+  const prefix = `${root.path}/`;
+  return chapters.filter(
+    (chapter) => chapter.chapterId === rootId || chapter.path.startsWith(prefix) && (options.depth === void 0 || chapter.depth - root.depth <= options.depth)
+  );
+}
+async function validateQueueTargetConfig(target, llmJSON) {
+  const config = target === "knowledge-graph" || target === "reading-graph" || target === "reading-summary" ? await loadRequiredStageConfig({
+    ...llmJSON === void 0 ? {} : { llmJSON }
+  }) : await loadWikiGraphRuntimeConfig({
+    ...llmJSON === void 0 ? {} : { llmJSON }
+  });
+  if ((target === "index-embedding-source" || target === "index-embedding-summary") && config.embedding === void 0) {
+    throw new Error(
+      "Missing embeddings configuration. Configure `wikg://local/config/embeddings` before queueing embedding index artifact jobs."
+    );
+  }
+  if (target === "knowledge-graph")
+    requireKnowledgeGraphWikispineConfig(config);
+}
+function requireQueueChapter(chapters, chapterId) {
+  const chapter = chapters.find((entry) => entry.chapterId === chapterId);
+  if (chapter === void 0)
+    throw new Error(`Chapter ${chapterId} does not exist.`);
+  return chapter;
+}
+async function readQueueReadinessReason(document, chapter, target) {
+  if (chapter.stage === "planned") {
+    return "planned";
+  }
+  if (target === "index-embedding-summary") {
+    const summary = await document.readSummary(chapter.chapterId);
+    if (summary === void 0 || summary.trim() === "") {
+      return "missing summary";
+    }
+  }
+  if (target === "knowledge-graph" || target === "reading-graph") {
+    const [artifact, revision] = await Promise.all([
+      document.indexArtifacts.get(chapter.chapterId, "fts"),
+      document.serials.getRevision(chapter.chapterId)
+    ]);
+    if (artifact?.sourceRevision !== revision) {
+      return "missing current FTS index artifact";
+    }
+  }
+  return void 0;
+}
+function formatQueueReadinessError(chapter, target, reason) {
+  if (reason === "planned") {
+    return `Chapter ${chapter.uri} is planned. Set source before queueing a build job.`;
+  }
+  if (reason === "missing summary") {
+    return `Chapter ${chapter.uri} has no summary. Build a reading summary before queueing a summary embedding index artifact job.`;
+  }
+  if (reason === "missing current FTS index artifact") {
+    return `Chapter ${chapter.uri} needs a current FTS index artifact before queueing ${target}.`;
+  }
+  return reason;
+}
+async function wait(milliseconds, signal) {
+  if (signal?.aborted === true) return;
+  await new Promise((resolve3) => {
+    let settled = false;
+    const complete = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", complete);
+      resolve3();
+    };
+    const timeout = setTimeout(complete, milliseconds);
+    signal?.addEventListener("abort", complete, { once: true });
+    if (signal?.aborted === true) complete();
+  });
+}
+function isTerminalState(state) {
+  return TERMINAL_STATES.has(state);
+}
+function isTerminalEvent(event) {
+  return event.type === "canceled" || event.type === "failed" || event.type === "succeeded";
+}
+function forwardAbort(source, target) {
+  if (source === void 0) return () => void 0;
+  const abort = () => target.abort(source.reason);
+  if (source.aborted) abort();
+  else source.addEventListener("abort", abort, { once: true });
+  return () => source.removeEventListener("abort", abort);
+}
+
+// src/libraries.ts
+var import_wiki_graph_core13 = require("wiki-graph-core");
+var import_promises4 = require("fs/promises");
+var WikiGraphLibraryManager = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  async create(folder) {
+    const record = await this.#runtime.run(async () => {
+      const path = resolveWikiGraphRuntimePath(folder);
+      await (0, import_promises4.mkdir)(path);
+      return await (0, import_wiki_graph_core13.createWikiGraphLibrary)({ folder: new NodeDirectory(path) });
+    });
+    return new WikiGraphLibrary(this.#runtime, record);
+  }
+  async get(uri = (0, import_wiki_graph_core13.formatWikiGraphLibraryUri)()) {
+    const target = requireLibraryTarget(uri);
+    const record = await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.resolveWikiGraphLibrary)(target)
+    );
+    return new WikiGraphLibrary(this.#runtime, record);
+  }
+  async addArchive(options) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.addWikiGraphLibraryArchive)({
+        inputFile: new NodeFile(
+          resolveWikiGraphRuntimePath(options.inputPath)
+        ),
+        target: requireLibraryTarget(options.target),
+        ...options.to === void 0 ? {} : { to: options.to }
+      })
+    );
+  }
+  async assertCurrent(target) {
+    await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.assertWikiGraphLibrarySchemaCurrent)(requireLibraryTarget(target))
+    );
+  }
+  async rebind(target, folder) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.rebindWikiGraphLibrary)({
+        folder: new NodeDirectory(resolveWikiGraphRuntimePath(folder)),
+        target: requireLibraryTarget(target)
+      })
+    );
+  }
+  async remove(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.removeWikiGraphLibrary)(requireLibraryTarget(target))
+    );
+  }
+  async scan(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.scanWikiGraphLibrary)(requireLibraryTarget(target))
+    );
+  }
+  async getArchive(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.getWikiGraphLibraryArchive)(requireLibraryTarget(target))
+    );
+  }
+  async moveArchive(options) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.moveWikiGraphLibraryArchive)({
+        target: requireLibraryTarget(options.target),
+        to: options.to
+      })
+    );
+  }
+  async removeArchive(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.removeWikiGraphLibraryArchive)({
+        target: requireLibraryTarget(target)
+      })
+    );
+  }
+  async indexState(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.readWikiGraphLibraryIndexState)(requireLibraryTarget(target))
+    );
+  }
+  async rebuildIndex(target, onProgress) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.rebuildWikiGraphLibraryIndex)(
+        requireLibraryTarget(target),
+        onProgress
+      )
+    );
+  }
+  async cleanIndex(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.cleanWikiGraphLibraryIndex)(requireLibraryTarget(target))
+    );
+  }
+  async getMetadata(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.getWikiGraphLibraryMetadata)(requireLibraryTarget(target))
+    );
+  }
+  async replaceMetadata(target, value) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.replaceWikiGraphLibraryMetadata)(
+        requireLibraryTarget(target),
+        value
+      )
+    );
+  }
+  async putMetadata(target, key, value) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.putWikiGraphLibraryMetadata)(
+        requireLibraryTarget(target),
+        key,
+        value
+      )
+    );
+  }
+  async deleteMetadata(target, key) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.deleteWikiGraphLibraryMetadataKey)(
+        requireLibraryTarget(target),
+        key
+      )
+    );
+  }
+  async clearMetadata(target) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.clearWikiGraphLibraryMetadata)(requireLibraryTarget(target))
+    );
+  }
+  async search(target, query, options = {}) {
+    return await this.#runtime.run(async () => {
+      const embeddingProvider = await createConfiguredEmbeddingProvider();
+      return await (0, import_wiki_graph_core13.findWikiGraphLibraryObjects)(
+        requireLibraryTarget(target),
+        query,
+        {
+          ...options,
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        }
+      );
+    });
+  }
+  async searchArchiveMembers(target, query, options = {}) {
+    return await this.#runtime.run(async () => {
+      const embeddingProvider = await createConfiguredEmbeddingProvider();
+      return await (0, import_wiki_graph_core13.findWikiGraphLibraryArchiveMembers)(
+        requireLibraryTarget(target),
+        query,
+        {
+          ...options,
+          ...embeddingProvider === void 0 ? {} : { embeddingProvider }
+        }
+      );
+    });
+  }
+  async objects(target, options = {}) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryObjects)(
+        requireLibraryTarget(target),
+        options
+      )
+    );
+  }
+  async archiveMembers(target, options = {}) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryArchiveMembers)(
+        requireLibraryTarget(target),
+        options
+      )
+    );
+  }
+  async page(target, objectUri, options = {}) {
+    return await this.#runtime.run(
+      async () => await withConfiguredWikimediaResolver(
+        objectUri,
+        async (wikimediaOptions) => await (0, import_wiki_graph_core13.readWikiGraphLibraryPage)(
+          requireLibraryTarget(target),
+          objectUri,
+          { ...options, ...wikimediaOptions }
+        )
+      )
+    );
+  }
+  async related(target, objectUri, options = {}) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.listRelatedWikiGraphLibraryObjects)(
+        requireLibraryTarget(target),
+        objectUri,
+        options
+      )
+    );
+  }
+  async evidence(target, objectUri, options = {}) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryEvidence)(
+        requireLibraryTarget(target),
+        objectUri,
+        options
+      )
+    );
+  }
+  async pack(target, objectUri, budget = 5e3) {
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.packWikiGraphLibraryContext)(
+        requireLibraryTarget(target),
+        objectUri,
+        budget
+      )
+    );
+  }
+  async list() {
+    const records = await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraries)()
+    );
+    return records.map((record) => new WikiGraphLibrary(this.#runtime, record));
+  }
+};
+var WikiGraphLibrary = class {
+  #runtime;
+  #record;
+  constructor(runtime, record) {
+    this.#runtime = runtime;
+    this.#record = record;
+  }
+  get snapshot() {
+    return this.#record;
+  }
+  get uri() {
+    return (0, import_wiki_graph_core13.formatWikiGraphLibraryUri)(
+      this.#record.isDefault ? void 0 : this.#record.publicId
+    );
+  }
+  async archives() {
+    const target = requireLibraryTarget(this.uri);
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryArchives)(target)
+    );
+  }
+  async scan() {
+    const target = requireLibraryTarget(this.uri);
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.scanWikiGraphLibrary)(target)
+    );
+  }
+  async remove() {
+    const target = requireLibraryTarget(this.uri);
+    return await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core13.removeWikiGraphLibrary)(target)
+    );
+  }
+};
+function requireLibraryTarget(value) {
+  if (typeof value !== "string") return value;
+  const target = (0, import_wiki_graph_core13.parseWikiGraphLibraryUri)(value);
+  if (target === void 0) {
+    throw new TypeError(`Invalid Wiki Graph library URI: ${value}`);
+  }
+  return target;
+}
+
+// src/maintenance.ts
+var import_wiki_graph_core14 = require("wiki-graph-core");
+var import_path4 = require("path");
+var WikiGraphMaintenanceManager = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  async upgrade(target) {
+    return await this.#runtime.run(
+      async () => {
+        if (target.kind === "home") {
+          return await (0, import_wiki_graph_core14.upgradeWikiGraphMaintenanceTarget)({ kind: "home" });
+        }
+        if (target.kind === "library") {
+          const parsed = (0, import_wiki_graph_core14.parseWikiGraphLibraryUri)(target.uri);
+          if (parsed === void 0 || parsed.kind === "archive") {
+            throw new Error(
+              `Invalid Wiki Graph library upgrade target: ${target.uri}`
+            );
+          }
+          return await (0, import_wiki_graph_core14.upgradeWikiGraphMaintenanceTarget)({
+            kind: "library",
+            target: parsed
+          });
+        }
+        const path = resolveWikiGraphRuntimePath(target.path);
+        return await (0, import_wiki_graph_core14.upgradeWikiGraphMaintenanceTarget)({
+          file: new NodeFile(path),
+          kind: "archive"
+        });
+      },
+      void 0,
+      { skipHomeBootstrap: target.kind === "home" }
+    );
+  }
+  async migrateLegacy(inputPath, outputPath = defaultWikgOutputPath(inputPath)) {
+    return await this.#runtime.run(async () => {
+      const resolvedInputPath = resolveWikiGraphRuntimePath(inputPath);
+      const resolvedOutputPath = resolveWikiGraphRuntimePath(outputPath);
+      await (0, import_wiki_graph_core14.migrateLegacySdpubToWikg)(
+        new NodeFile(resolvedInputPath),
+        new NodeFile(resolvedOutputPath, (0, import_path4.basename)(resolvedOutputPath))
+      );
+      return {
+        inputPath: resolvedInputPath,
+        outputPath: resolvedOutputPath
+      };
+    });
+  }
+};
+function defaultWikgOutputPath(inputPath) {
+  return inputPath.toLowerCase().endsWith(".sdpub") ? `${inputPath.slice(0, -".sdpub".length)}.wikg` : `${inputPath}.wikg`;
+}
+
+// src/sdk.ts
+var import_wiki_graph_core15 = require("wiki-graph-core");
+var WikiGraphSDK = class {
+  #context;
+  #homeReady;
+  archives;
+  conversions;
+  config;
+  continuations;
+  jobs;
+  libraries;
+  maintenance;
+  constructor(options = {}) {
+    ensureNodeWikiGraphPlatform();
+    this.#context = {
+      cwd: options.cwd ?? process.cwd(),
+      env: { ...process.env, ...options.env },
+      envPolicy: options.envPolicy ?? "production",
+      ...options.stateDir === void 0 ? {} : { stateDir: options.stateDir }
+    };
+    this.archives = new WikiGraphArchiveManager(this);
+    this.conversions = new WikiGraphConversionManager(this);
+    this.config = new WikiGraphConfigManager(this);
+    this.continuations = new WikiGraphContinuationManager(this);
+    this.jobs = new WikiGraphJobManager(this);
+    this.libraries = new WikiGraphLibraryManager(this);
+    this.maintenance = new WikiGraphMaintenanceManager(this);
+  }
+  async run(operation, signal, options = {}) {
+    throwIfAborted(signal);
+    const runWithContext = async () => await withWikiGraphSDKRuntimeContext(this.#context, async () => {
+      if (options.skipHomeBootstrap !== true) {
+        this.#homeReady ??= (0, import_wiki_graph_core15.ensureWikiGraphHomeSchemaCurrent)().catch(
+          (error) => {
+            this.#homeReady = void 0;
+            throw error;
+          }
+        );
+        await this.#homeReady;
+      }
+      return await operation();
+    });
+    const result = this.#context.stateDir === void 0 ? await runWithContext() : await withNodeWikiGraphStorage(
+      this.#context.stateDir,
+      runWithContext
+    );
+    throwIfAborted(signal);
+    return result;
+  }
+  close() {
+    this.jobs.close();
+  }
+};
+function throwIfAborted(signal) {
+  if (signal?.aborted !== true) return;
+  throw signal.reason instanceof Error ? signal.reason : new Error("The Wiki Graph SDK operation was aborted.");
+}
+function createWikiGraphSDK(options = {}) {
+  return new WikiGraphSDK(options);
+}
+
+// src/index.ts
+var import_wiki_graph_core16 = require("wiki-graph-core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DANGEROUS_RUNTIME_ENV_NAMES,
+  DEFAULT_EXTRACTION_PROMPT,
+  DEFAULT_GENERATION_JOB_CONCURRENCY,
+  DEFAULT_GENERATION_REQUEST_CONCURRENCY,
+  DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT,
+  LLMPaymentRequiredError,
+  LOCAL_CONFIG_SECTIONS,
+  NodeDirectory,
+  NodeFile,
+  WIKI_GRAPH_URI_PREFIX,
+  WikiGraphArchiveExistsError,
+  WikiGraphArchiveHandle,
+  WikiGraphArchiveManager,
+  WikiGraphConfigManager,
+  WikiGraphContinuationManager,
+  WikiGraphConversionManager,
+  WikiGraphError,
+  WikiGraphJob,
+  WikiGraphJobManager,
+  WikiGraphLibrary,
+  WikiGraphLibraryManager,
+  WikiGraphMaintenanceManager,
+  WikiGraphSDK,
+  buildSearchIndexEmbeddingProvider,
+  buildWikiGraphLLMOptions,
+  clearLocalConfigSection,
+  createEntryRuntimeContext,
+  createGenerationPerformanceHints,
+  createNodeTemplateEnvironment,
+  createNodeWikiGraphStorage,
+  createStageLLM,
+  createWikiGraphArchiveInspectReport,
+  createWikiGraphSDK,
+  deleteLocalConfigValue,
+  embedQueryText,
+  embedQueryTextWithLocalConfig,
+  ensureNodeWikiGraphPlatform,
+  formatError,
+  formatGenerationPlanningDuration,
+  formatGenerationPlanningModel,
+  formatLocatedChapterResourceUri,
+  formatLocatedChapterSourceCollectionUri,
+  formatLocatedChapterUri,
+  formatLocatedWikiGraphUri,
+  formatWikiGraphCommandUri,
+  formatWikiGraphLibraryUri,
+  getNodeResourcePath,
+  getWikiGraphSDKRuntimeContext,
+  getWikiGraphSDKStateDir,
+  installNodeWikiGraphPlatform,
+  isSourceLocatorScopeUri,
+  isWikiGraphLibraryUri,
+  loadRequiredStageConfig,
+  loadWikiGraphRuntimeConfig,
+  maskLocalConfigSection,
+  nodeWikiGraphPlatform,
+  nodeWikispineCommandRunner,
+  normalizeLocalConfigKey,
+  parseChapterPath,
+  parseChapterTreeInput,
+  parseChapterUriPath,
+  parseLocalConfigSection,
+  parseLocatedWikiGraphUri,
+  parseSourceTextJsonl,
+  parseWikiGraphLibraryUri,
+  parseWikiGraphUriSyntax,
+  planGenerationTask,
+  putLocalConfigValue,
+  readLocalConfigSection,
+  readWikiGraphEmbeddingConfig,
+  replaceLocalConfigSection,
+  requireKnowledgeGraphWikispineConfig,
+  resolveExtractionPrompt,
+  resolveHostedProviderEndpoint,
+  resolveKnowledgeGraphRecallPrompt,
+  resolveWikiGraphArchiveLocation,
+  resolveWikispineConfig,
+  runWikiGraphQueueWorker,
+  validateLocalConfigSection,
+  withNodeWikiGraphStorage,
+  withWikiGraphSDKRuntimeContext,
+  writeNodeFileHandle
+});
+//# sourceMappingURL=index.cjs.map