wiki-graph-core 0.3.1 → 0.4.1

package/dist/text/summary-build/snapshot/serial-store.js

@@ -0,0 +1,92 @@
+import { compareNumber } from "./helpers.js";
+class SnapshotSerialStore {
+  #serial;
+  constructor(serial) {
+    this.#serial = serial;
+  }
+  getById(serialId) {
+    return Promise.resolve(
+      serialId === this.#serial.id ? this.#serial : void 0
+    );
+  }
+  getRevision(serialId) {
+    return Promise.resolve(
+      serialId === this.#serial.id ? this.#serial.revision : 0
+    );
+  }
+  getRevisions(serialIds) {
+    return Promise.resolve(
+      new Map(
+        serialIds.filter((serialId) => serialId === this.#serial.id).map((serialId) => [serialId, this.#serial.revision])
+      )
+    );
+  }
+  getChaptersRevision() {
+    return Promise.resolve(this.#serial.revision);
+  }
+  getMaxId() {
+    return Promise.resolve(this.#serial.id);
+  }
+  listIds() {
+    return Promise.resolve([this.#serial.id]);
+  }
+  listDocumentOrders() {
+    return Promise.resolve(
+      /* @__PURE__ */ new Map([[this.#serial.id, this.#serial.documentOrder]])
+    );
+  }
+}
+class SnapshotSerialFragments {
+  path = "";
+  serialId;
+  #fragmentsById;
+  constructor(serialId, fragments) {
+    this.serialId = serialId;
+    this.#fragmentsById = new Map(
+      fragments.filter((fragment) => fragment.serialId === serialId).map((fragment) => [fragment.fragmentId, fragment])
+    );
+  }
+  getFragment(fragmentId) {
+    const fragment = this.#fragmentsById.get(fragmentId);
+    if (fragment === void 0) {
+      throw new Error(`Fragment ${fragmentId} does not exist`);
+    }
+    return Promise.resolve(fragment);
+  }
+  listFragmentIds() {
+    return Promise.resolve([...this.#fragmentsById.keys()].sort(compareNumber));
+  }
+  async getSentence(sentenceIndex) {
+    const sentence = (await this.listSentences())[sentenceIndex];
+    if (sentence === void 0) {
+      throw new RangeError(`Sentence ${sentenceIndex} does not exist`);
+    }
+    return sentence;
+  }
+  async listSentencesInRange(startSentenceIndex, endSentenceIndex) {
+    return (await this.listSentences()).slice(
+      startSentenceIndex,
+      endSentenceIndex + 1
+    );
+  }
+  async listSentences() {
+    const fragments = await Promise.all(
+      (await this.listFragmentIds()).map(
+        async (fragmentId) => await this.getFragment(fragmentId)
+      )
+    );
+    return fragments.flatMap((fragment) => fragment.sentences);
+  }
+  async readText() {
+    const sentences = await this.listSentences();
+    if (sentences.length === 0) {
+      return void 0;
+    }
+    return sentences.map((sentence) => sentence.text).join("");
+  }
+}
+export {
+  SnapshotSerialFragments,
+  SnapshotSerialStore
+};
+//# sourceMappingURL=serial-store.js.map

package/dist/text/summary-build/snapshot/serial-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/summary-build/snapshot/serial-store.ts"],"sourcesContent":["import type {\n  FragmentRecord,\n  ReadonlySerialFragments,\n  ReadonlySerialStore,\n  SerialRecord,\n} from \"../../../document/index.js\";\nimport { compareNumber } from \"./helpers.js\";\n\nexport class SnapshotSerialStore implements ReadonlySerialStore {\n  readonly #serial: SerialRecord;\n\n  public constructor(serial: SerialRecord) {\n    this.#serial = serial;\n  }\n\n  public getById(serialId: number): Promise<SerialRecord | undefined> {\n    return Promise.resolve(\n      serialId === this.#serial.id ? this.#serial : undefined,\n    );\n  }\n\n  public getRevision(serialId: number): Promise<number> {\n    return Promise.resolve(\n      serialId === this.#serial.id ? this.#serial.revision : 0,\n    );\n  }\n\n  public getRevisions(\n    serialIds: readonly number[],\n  ): Promise<ReadonlyMap<number, number>> {\n    return Promise.resolve(\n      new Map(\n        serialIds\n          .filter((serialId) => serialId === this.#serial.id)\n          .map((serialId) => [serialId, this.#serial.revision] as const),\n      ),\n    );\n  }\n\n  public getChaptersRevision(): Promise<number> {\n    return Promise.resolve(this.#serial.revision);\n  }\n\n  public getMaxId(): Promise<number> {\n    return Promise.resolve(this.#serial.id);\n  }\n\n  public listIds(): Promise<number[]> {\n    return Promise.resolve([this.#serial.id]);\n  }\n\n  public listDocumentOrders(): Promise<ReadonlyMap<number, number>> {\n    return Promise.resolve(\n      new Map([[this.#serial.id, this.#serial.documentOrder]]),\n    );\n  }\n}\n\nexport class SnapshotSerialFragments implements ReadonlySerialFragments {\n  public readonly path = \"\";\n  public readonly serialId: number;\n  readonly #fragmentsById: Map<number, FragmentRecord>;\n\n  public constructor(serialId: number, fragments: readonly FragmentRecord[]) {\n    this.serialId = serialId;\n    this.#fragmentsById = new Map(\n      fragments\n        .filter((fragment) => fragment.serialId === serialId)\n        .map((fragment) => [fragment.fragmentId, fragment]),\n    );\n  }\n\n  public getFragment(fragmentId: number): Promise<FragmentRecord> {\n    const fragment = this.#fragmentsById.get(fragmentId);\n\n    if (fragment === undefined) {\n      throw new Error(`Fragment ${fragmentId} does not exist`);\n    }\n\n    return Promise.resolve(fragment);\n  }\n\n  public listFragmentIds(): Promise<readonly number[]> {\n    return Promise.resolve([...this.#fragmentsById.keys()].sort(compareNumber));\n  }\n\n  public async getSentence(sentenceIndex: number) {\n    const sentence = (await this.listSentences())[sentenceIndex];\n\n    if (sentence === undefined) {\n      throw new RangeError(`Sentence ${sentenceIndex} does not exist`);\n    }\n\n    return sentence;\n  }\n\n  public async listSentencesInRange(\n    startSentenceIndex: number,\n    endSentenceIndex: number,\n  ) {\n    return (await this.listSentences()).slice(\n      startSentenceIndex,\n      endSentenceIndex + 1,\n    );\n  }\n\n  public async listSentences() {\n    const fragments = await Promise.all(\n      (await this.listFragmentIds()).map(\n        async (fragmentId) => await this.getFragment(fragmentId),\n      ),\n    );\n\n    return fragments.flatMap((fragment) => fragment.sentences);\n  }\n\n  public async readText(): Promise<string | undefined> {\n    const sentences = await this.listSentences();\n\n    if (sentences.length === 0) {\n      return undefined;\n    }\n\n    return sentences.map((sentence) => sentence.text).join(\"\");\n  }\n}\n"],"mappings":"AAMA,SAAS,qBAAqB;AAEvB,MAAM,oBAAmD;AAAA,EACrD;AAAA,EAEF,YAAY,QAAsB;AACvC,SAAK,UAAU;AAAA,EACjB;AAAA,EAEO,QAAQ,UAAqD;AAClE,WAAO,QAAQ;AAAA,MACb,aAAa,KAAK,QAAQ,KAAK,KAAK,UAAU;AAAA,IAChD;AAAA,EACF;AAAA,EAEO,YAAY,UAAmC;AACpD,WAAO,QAAQ;AAAA,MACb,aAAa,KAAK,QAAQ,KAAK,KAAK,QAAQ,WAAW;AAAA,IACzD;AAAA,EACF;AAAA,EAEO,aACL,WACsC;AACtC,WAAO,QAAQ;AAAA,MACb,IAAI;AAAA,QACF,UACG,OAAO,CAAC,aAAa,aAAa,KAAK,QAAQ,EAAE,EACjD,IAAI,CAAC,aAAa,CAAC,UAAU,KAAK,QAAQ,QAAQ,CAAU;AAAA,MACjE;AAAA,IACF;AAAA,EACF;AAAA,EAEO,sBAAuC;AAC5C,WAAO,QAAQ,QAAQ,KAAK,QAAQ,QAAQ;AAAA,EAC9C;AAAA,EAEO,WAA4B;AACjC,WAAO,QAAQ,QAAQ,KAAK,QAAQ,EAAE;AAAA,EACxC;AAAA,EAEO,UAA6B;AAClC,WAAO,QAAQ,QAAQ,CAAC,KAAK,QAAQ,EAAE,CAAC;AAAA,EAC1C;AAAA,EAEO,qBAA2D;AAChE,WAAO,QAAQ;AAAA,MACb,oBAAI,IAAI,CAAC,CAAC,KAAK,QAAQ,IAAI,KAAK,QAAQ,aAAa,CAAC,CAAC;AAAA,IACzD;AAAA,EACF;AACF;AAEO,MAAM,wBAA2D;AAAA,EACtD,OAAO;AAAA,EACP;AAAA,EACP;AAAA,EAEF,YAAY,UAAkB,WAAsC;AACzE,SAAK,WAAW;AAChB,SAAK,iBAAiB,IAAI;AAAA,MACxB,UACG,OAAO,CAAC,aAAa,SAAS,aAAa,QAAQ,EACnD,IAAI,CAAC,aAAa,CAAC,SAAS,YAAY,QAAQ,CAAC;AAAA,IACtD;AAAA,EACF;AAAA,EAEO,YAAY,YAA6C;AAC9D,UAAM,WAAW,KAAK,eAAe,IAAI,UAAU;AAEnD,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,YAAY,UAAU,iBAAiB;AAAA,IACzD;AAEA,WAAO,QAAQ,QAAQ,QAAQ;AAAA,EACjC;AAAA,EAEO,kBAA8C;AACnD,WAAO,QAAQ,QAAQ,CAAC,GAAG,KAAK,eAAe,KAAK,CAAC,EAAE,KAAK,aAAa,CAAC;AAAA,EAC5E;AAAA,EAEA,MAAa,YAAY,eAAuB;AAC9C,UAAM,YAAY,MAAM,KAAK,cAAc,GAAG,aAAa;AAE3D,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,WAAW,YAAY,aAAa,iBAAiB;AAAA,IACjE;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,qBACX,oBACA,kBACA;AACA,YAAQ,MAAM,KAAK,cAAc,GAAG;AAAA,MAClC;AAAA,MACA,mBAAmB;AAAA,IACrB;AAAA,EACF;AAAA,EAEA,MAAa,gBAAgB;AAC3B,UAAM,YAAY,MAAM,QAAQ;AAAA,OAC7B,MAAM,KAAK,gBAAgB,GAAG;AAAA,QAC7B,OAAO,eAAe,MAAM,KAAK,YAAY,UAAU;AAAA,MACzD;AAAA,IACF;AAEA,WAAO,UAAU,QAAQ,CAAC,aAAa,SAAS,SAAS;AAAA,EAC3D;AAAA,EAEA,MAAa,WAAwC;AACnD,UAAM,YAAY,MAAM,KAAK,cAAc;AAE3C,QAAI,UAAU,WAAW,GAAG;AAC1B,aAAO;AAAA,IACT;AAEA,WAAO,UAAU,IAAI,CAAC,aAAa,SAAS,IAAI,EAAE,KAAK,EAAE;AAAA,EAC3D;AACF;","names":[]}

package/dist/text/summary-build/snapshot-io.d.ts

@@ -0,0 +1,14 @@
+import { SummaryInputSnapshotData } from './types.js';
+import '../../document/types.js';
+import '../../external/llm/client/core.js';
+import '../../external/llm/context.js';
+import '../../external/llm/cache.js';
+import '../../external/llm/types.js';
+import 'ai';
+import '../../runtime/common/language.js';
+import '../../runtime/common/llm-scope.js';
+
+declare function readSummaryInputSnapshot(filePath: string): Promise<SummaryInputSnapshotData>;
+declare function writeSummaryInputSnapshot(filePath: string, snapshot: SummaryInputSnapshotData): Promise<void>;
+
+export { readSummaryInputSnapshot, writeSummaryInputSnapshot };

package/dist/text/summary-build/snapshot-io.js

@@ -0,0 +1,25 @@
+import { readFile, writeFile } from "fs/promises";
+import {
+  summaryInputSnapshotSchema,
+  toChunkRecord,
+  toReadingEdgeRecord
+} from "./schema.js";
+async function readSummaryInputSnapshot(filePath) {
+  const snapshot = summaryInputSnapshotSchema.parse(
+    JSON.parse(await readFile(filePath, "utf8"))
+  );
+  return {
+    ...snapshot,
+    chunks: snapshot.chunks.map(toChunkRecord),
+    readingEdges: snapshot.readingEdges.map(toReadingEdgeRecord)
+  };
+}
+async function writeSummaryInputSnapshot(filePath, snapshot) {
+  await writeFile(filePath, `${JSON.stringify(snapshot)}
+`, "utf8");
+}
+export {
+  readSummaryInputSnapshot,
+  writeSummaryInputSnapshot
+};
+//# sourceMappingURL=snapshot-io.js.map

package/dist/text/summary-build/snapshot-io.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/text/summary-build/snapshot-io.ts"],"sourcesContent":["import { readFile, writeFile } from \"fs/promises\";\n\nimport {\n  summaryInputSnapshotSchema,\n  toChunkRecord,\n  toReadingEdgeRecord,\n} from \"./schema.js\";\nimport type { SummaryInputSnapshotData } from \"./types.js\";\n\nexport async function readSummaryInputSnapshot(\n  filePath: string,\n): Promise<SummaryInputSnapshotData> {\n  const snapshot = summaryInputSnapshotSchema.parse(\n    JSON.parse(await readFile(filePath, \"utf8\")),\n  );\n\n  return {\n    ...snapshot,\n    chunks: snapshot.chunks.map(toChunkRecord),\n    readingEdges: snapshot.readingEdges.map(toReadingEdgeRecord),\n  };\n}\n\nexport async function writeSummaryInputSnapshot(\n  filePath: string,\n  snapshot: SummaryInputSnapshotData,\n): Promise<void> {\n  await writeFile(filePath, `${JSON.stringify(snapshot)}\\n`, \"utf8\");\n}\n"],"mappings":"AAAA,SAAS,UAAU,iBAAiB;AAEpC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP,eAAsB,yBACpB,UACmC;AACnC,QAAM,WAAW,2BAA2B;AAAA,IAC1C,KAAK,MAAM,MAAM,SAAS,UAAU,MAAM,CAAC;AAAA,EAC7C;AAEA,SAAO;AAAA,IACL,GAAG;AAAA,IACH,QAAQ,SAAS,OAAO,IAAI,aAAa;AAAA,IACzC,cAAc,SAAS,aAAa,IAAI,mBAAmB;AAAA,EAC7D;AACF;AAEA,eAAsB,0BACpB,UACA,UACe;AACf,QAAM,UAAU,UAAU,GAAG,KAAK,UAAU,QAAQ,CAAC;AAAA,GAAM,MAAM;AACnE;","names":[]}

package/dist/text/summary-build/source.d.ts

@@ -0,0 +1,39 @@
+import { FragmentRecord } from '../../document/types.js';
+import { ReadonlyDocument } from '../../document/directory/types.js';
+import { ReaderTextStream } from '../reader/types.js';
+import '../source/meta.js';
+import 'zod';
+import '../source/toc.js';
+import '../source/types.js';
+import '../../document/database.js';
+import 'sqlite3';
+import '../../document/text-streams/serial.js';
+import '../../document/text-streams/draft.js';
+import '../../document/text-streams/types.js';
+import '../../document/stores/chunk.js';
+import '../../document/stores/types.js';
+import '../../document/stores/fragment-group.js';
+import '../../document/stores/graph-build-parameter.js';
+import '../../document/stores/mention-link.js';
+import '../../document/stores/mention.js';
+import '../../document/stores/object-metadata.js';
+import '../../document/stores/reading-edge.js';
+import '../../document/stores/serial.js';
+import '../../document/stores/snake/chunk.js';
+import '../../document/stores/snake/core.js';
+import '../../document/stores/snake/edge.js';
+import '../reader/attention/core.js';
+import '../reader/chunk-batch/types.js';
+import '../../runtime/common/language.js';
+import '../../external/llm/client/core.js';
+import '../../external/llm/context.js';
+import '../../external/llm/cache.js';
+import '../../external/llm/types.js';
+import 'ai';
+import '../reader/segment/types.js';
+
+declare function readSerialFragments(document: ReadonlyDocument, serialId: number): Promise<readonly FragmentRecord[]>;
+declare function readChapterSource(document: ReadonlyDocument, chapterId: number): ReaderTextStream;
+declare function collectReaderText(stream: ReaderTextStream): Promise<readonly string[]>;
+
+export { collectReaderText, readChapterSource, readSerialFragments };

package/dist/text/summary-build/source.js

@@ -0,0 +1,30 @@
+async function readSerialFragments(document, serialId) {
+  const fragments = document.getSerialFragments(serialId);
+  return await Promise.all(
+    (await fragments.listFragmentIds()).map(
+      async (fragmentId) => await fragments.getFragment(fragmentId)
+    )
+  );
+}
+async function* readChapterSource(document, chapterId) {
+  const fragments = document.getSerialFragments(chapterId);
+  for (const fragmentId of await fragments.listFragmentIds()) {
+    const fragment = await fragments.getFragment(fragmentId);
+    for (const sentence of fragment.sentences) {
+      yield sentence.text;
+    }
+  }
+}
+async function collectReaderText(stream) {
+  const text = [];
+  for await (const chunk of stream) {
+    text.push(chunk);
+  }
+  return text;
+}
+export {
+  collectReaderText,
+  readChapterSource,
+  readSerialFragments
+};
+//# sourceMappingURL=source.js.map

package/dist/text/summary-build/source.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/text/summary-build/source.ts"],"sourcesContent":["import type { FragmentRecord, ReadonlyDocument } from \"../../document/index.js\";\nimport type { ReaderTextStream } from \"../reader/index.js\";\n\nexport async function readSerialFragments(\n  document: ReadonlyDocument,\n  serialId: number,\n): Promise<readonly FragmentRecord[]> {\n  const fragments = document.getSerialFragments(serialId);\n\n  return await Promise.all(\n    (await fragments.listFragmentIds()).map(\n      async (fragmentId) => await fragments.getFragment(fragmentId),\n    ),\n  );\n}\n\nexport async function* readChapterSource(\n  document: ReadonlyDocument,\n  chapterId: number,\n): ReaderTextStream {\n  const fragments = document.getSerialFragments(chapterId);\n\n  for (const fragmentId of await fragments.listFragmentIds()) {\n    const fragment = await fragments.getFragment(fragmentId);\n\n    for (const sentence of fragment.sentences) {\n      yield sentence.text;\n    }\n  }\n}\n\nexport async function collectReaderText(\n  stream: ReaderTextStream,\n): Promise<readonly string[]> {\n  const text: string[] = [];\n\n  for await (const chunk of stream) {\n    text.push(chunk);\n  }\n\n  return text;\n}\n"],"mappings":"AAGA,eAAsB,oBACpB,UACA,UACoC;AACpC,QAAM,YAAY,SAAS,mBAAmB,QAAQ;AAEtD,SAAO,MAAM,QAAQ;AAAA,KAClB,MAAM,UAAU,gBAAgB,GAAG;AAAA,MAClC,OAAO,eAAe,MAAM,UAAU,YAAY,UAAU;AAAA,IAC9D;AAAA,EACF;AACF;AAEA,gBAAuB,kBACrB,UACA,WACkB;AAClB,QAAM,YAAY,SAAS,mBAAmB,SAAS;AAEvD,aAAW,cAAc,MAAM,UAAU,gBAAgB,GAAG;AAC1D,UAAM,WAAW,MAAM,UAAU,YAAY,UAAU;AAEvD,eAAW,YAAY,SAAS,WAAW;AACzC,YAAM,SAAS;AAAA,IACjB;AAAA,EACF;AACF;AAEA,eAAsB,kBACpB,QAC4B;AAC5B,QAAM,OAAiB,CAAC;AAExB,mBAAiB,SAAS,QAAQ;AAChC,SAAK,KAAK,KAAK;AAAA,EACjB;AAEA,SAAO;AACT;","names":[]}

package/dist/text/summary-build/types.d.ts

@@ -0,0 +1,34 @@
+import { ChunkRecord, SentenceGroupRecord, FragmentRecord, ReadingEdgeRecord, SerialRecord, SnakeChunkRecord, SnakeEdgeRecord, SnakeRecord } from '../../document/types.js';
+import { LLM } from '../../external/llm/client/core.js';
+import { Language } from '../../runtime/common/language.js';
+import { WikiGraphScope } from '../../runtime/common/llm-scope.js';
+import '../../external/llm/context.js';
+import '../../external/llm/cache.js';
+import '../../external/llm/types.js';
+import 'ai';
+
+interface ChapterSummaryInputSnapshot {
+    readonly filePath: string;
+    readonly objectsPath: string;
+}
+interface BuildChapterSummaryArtifactOptions {
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly readingGraphObjectsPath?: string;
+    readonly snapshotPath?: string;
+    readonly sourceDocumentPath?: string;
+    readonly userLanguage?: Language;
+    readonly workspacePath: string;
+}
+interface SummaryInputSnapshotData {
+    readonly chunks: readonly ChunkRecord[];
+    readonly fragmentGroups: readonly SentenceGroupRecord[];
+    readonly fragments: readonly FragmentRecord[];
+    readonly readingEdges: readonly ReadingEdgeRecord[];
+    readonly serial: SerialRecord;
+    readonly snakeChunks: readonly SnakeChunkRecord[];
+    readonly snakeEdges: readonly SnakeEdgeRecord[];
+    readonly snakes: readonly SnakeRecord[];
+}
+
+export type { BuildChapterSummaryArtifactOptions, ChapterSummaryInputSnapshot, SummaryInputSnapshotData };

package/dist/text/summary-build/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/text/summary-build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/worker-DWasYKWW.d.cts

@@ -0,0 +1,143 @@
+declare const BUILD_JOB_STATES: readonly ["queued", "running", "canceling", "paused", "succeeded", "failed", "canceled"];
+type BuildJobState = (typeof BUILD_JOB_STATES)[number];
+type BuildJobTarget = "knowledge-graph" | "reading-graph" | "reading-summary";
+type BuildJobProgressPhase = "committing" | "enrichment" | "grounding" | "matching" | "narrowing" | "relation-discovery" | "screening";
+type BuildJobProgressUnit = "candidate" | "char" | "item" | "page" | "qid" | "sentence" | "window" | "record";
+interface BuildJobProgressCounter {
+    readonly done: number;
+    readonly name: string;
+    readonly total: number;
+    readonly unit: BuildJobProgressUnit | "word";
+}
+interface BuildJobTokenUsage {
+    readonly cacheReadTokens?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+}
+interface BuildJob {
+    readonly archiveKey: string;
+    readonly archivePath: string;
+    readonly cachePath: string;
+    readonly chapterId: number;
+    readonly createdAt: number;
+    readonly currentStep?: BuildJobTarget;
+    readonly errorJSON?: string;
+    readonly eventsPath: string;
+    readonly finishedAt?: number;
+    readonly jobId: string;
+    readonly inputRevision?: number;
+    readonly logPath: string;
+    readonly llmJSON?: string;
+    readonly ownerId?: string;
+    readonly ownerPid?: number;
+    readonly prompt?: string;
+    readonly queueRank: number;
+    readonly state: BuildJobState;
+    readonly readingSummaryStartedAt?: number;
+    readonly target: BuildJobTarget;
+    readonly updatedAt: number;
+    readonly workspacePath: string;
+}
+type BuildJobEvent = {
+    readonly at: number;
+    readonly jobId: string;
+    readonly seq: number;
+    readonly state: BuildJobState;
+    readonly type: "created" | "paused" | "resumed" | "boosted" | "canceling";
+} | {
+    readonly at: number;
+    readonly jobId: string;
+    readonly seq: number;
+    readonly from: BuildJobTarget;
+    readonly to: BuildJobTarget;
+    readonly type: "target_changed";
+} | {
+    readonly at: number;
+    readonly jobId: string;
+    readonly seq: number;
+    readonly state: "running";
+    readonly type: "started";
+} | {
+    readonly at: number;
+    readonly jobId: string;
+    readonly seq: number;
+    readonly state: "queued";
+    readonly type: "requeued";
+} | {
+    readonly at: number;
+    readonly jobId: string;
+    readonly seq: number;
+    readonly step: BuildJobTarget;
+    readonly type: "step_started" | "step_completed";
+} | {
+    readonly at: number;
+    readonly counters: readonly BuildJobProgressCounter[];
+    readonly jobId: string;
+    readonly phase?: BuildJobProgressPhase;
+    readonly seq: number;
+    readonly step?: BuildJobTarget;
+    readonly tokens?: BuildJobTokenUsage;
+    readonly type: "status_snapshot";
+} | {
+    readonly at: number;
+    readonly error?: unknown;
+    readonly jobId: string;
+    readonly seq: number;
+    readonly state: "failed" | "canceled" | "succeeded";
+    readonly type: "failed" | "canceled" | "succeeded";
+};
+interface AddBuildJobOptions {
+    readonly archivePath: string;
+    readonly boost?: boolean;
+    readonly chapterId: number;
+    readonly jobId?: string;
+    readonly llmJSON?: string;
+    readonly prompt?: string;
+    readonly target: BuildJobTarget;
+}
+interface BuildJobListOptions {
+    readonly activeOnly?: boolean;
+    readonly all?: boolean;
+    readonly archivePath?: string;
+}
+interface BuildJobWorkerOptions {
+    readonly concurrency: number;
+    readonly executeJob: (job: BuildJob, reporter: BuildJobProgressReporter, context: BuildJobExecutionContext) => Promise<void>;
+    readonly idleTimeoutMs?: number;
+}
+interface BuildJobExecutionContext {
+    readonly signal: AbortSignal;
+}
+interface BuildJobProgressReporter {
+    addOutputCharacters(characters: number): Promise<void>;
+    addTokenUsage(usage: BuildJobTokenUsage): Promise<void>;
+    setTotals(input: {
+        readonly totalGraphWords?: number;
+        readonly totalReadingSummaryWords?: number;
+    }): Promise<void>;
+    stepCompleted(step: BuildJobTarget): Promise<void>;
+    stepStarted(step: BuildJobTarget): Promise<void>;
+    updateWords(input: {
+        readonly graphWords?: number;
+        readonly readingSummaryWords?: number;
+    }): Promise<void>;
+    updatePhase(input: {
+        readonly done: number;
+        readonly force?: boolean;
+        readonly phase: BuildJobProgressPhase;
+        readonly phaseDetail?: string;
+        readonly total: number;
+        readonly unit: BuildJobProgressUnit;
+    }): Promise<void>;
+    throwIfStopped(): Promise<void>;
+}
+type BuildJobConflictScope = {
+    readonly kind: "archive";
+} | {
+    readonly chapterIds: readonly number[];
+    readonly kind: "chapter";
+};
+
+declare function runBuildJobWorker(options: BuildJobWorkerOptions): Promise<void>;
+
+export { type AddBuildJobOptions as A, type BuildJob as B, type BuildJobListOptions as a, type BuildJobTarget as b, type BuildJobConflictScope as c, type BuildJobEvent as d, type BuildJobState as e, type BuildJobProgressReporter as f, type BuildJobExecutionContext as g, type BuildJobProgressCounter as h, type BuildJobWorkerOptions as i, runBuildJobWorker as r };