wiki-graph 0.3.0 → 0.3.1

package/dist/index.d.cts

@@ -1,5 +1,6 @@
+import { LanguageModel, ModelMessage } from 'ai';
+import { Environment } from 'nunjucks';
 import * as Sqlite3Namespace from 'sqlite3';
-import { ModelMessage, LanguageModel } from 'ai';
 import { z } from 'zod';
 
 declare enum Language {
@@ -56,16 +57,16 @@ declare function formatLanguageForPrompt(code: LanguageCode): Language;
 declare function normalizeLanguageCode(language: Language | string | null | undefined): LanguageCode | undefined;
 declare function getWikipageLanguageCode(language: Language | string | null | undefined): "en" | "zh" | undefined;
 
-declare const SPINE_DIGEST_CONTEXT_VERSION = 1;
+declare const WIKI_GRAPH_CONTEXT_VERSION = 1;
 declare const TASK_STATUS_VERSION = 1;
-type SpineDigestTaskType = "source-to-graph" | "source-graph-to-summary";
-interface SpineDigestTaskIdentity {
+type WikiGraphTaskType = "source-to-graph" | "source-graph-to-summary";
+interface WikiGraphTaskIdentity {
     readonly normalizedSource: string;
     readonly parameters: unknown;
-    readonly taskType: SpineDigestTaskType;
+    readonly taskType: WikiGraphTaskType;
     readonly version?: number;
 }
-interface SpineDigestTaskContextOptions {
+interface WikiGraphTaskContextOptions {
     readonly rootDirPath: string;
 }
 interface TaskStatus {
@@ -74,25 +75,119 @@ interface TaskStatus {
     readonly status: "running" | "succeeded";
     readonly version: typeof TASK_STATUS_VERSION;
 }
-declare class SpineDigestTaskContext {
+declare class WikiGraphTaskContext {
     #private;
-    constructor(options: SpineDigestTaskContextOptions);
-    createTask(identity: SpineDigestTaskIdentity): SpineDigestTask;
-    runTask<T>(identity: SpineDigestTaskIdentity, operation: (task: SpineDigestTask) => Promise<T> | T): Promise<T>;
+    constructor(options: WikiGraphTaskContextOptions);
+    createTask(identity: WikiGraphTaskIdentity): WikiGraphTask;
+    runTask<T>(identity: WikiGraphTaskIdentity, operation: (task: WikiGraphTask) => Promise<T> | T): Promise<T>;
 }
-declare class SpineDigestTask {
+declare class WikiGraphTask {
     #private;
     constructor(id: string, path: string);
     get artifactDirPath(): string;
     get id(): string;
     get path(): string;
     readStatus(): Promise<TaskStatus | undefined>;
-    run<T>(operation: (task: SpineDigestTask) => Promise<T> | T): Promise<T>;
+    run<T>(operation: (task: WikiGraphTask) => Promise<T> | T): Promise<T>;
     remove(): Promise<void>;
 }
-declare function createSpineDigestTaskId(identity: SpineDigestTaskIdentity): string;
+declare function createWikiGraphTaskId(identity: WikiGraphTaskIdentity): string;
+
+interface PendingCacheEntry {
+    cacheKey: string;
+    response: string;
+}
+declare class LLMCache {
+    #private;
+    constructor(cacheDirPath: string);
+    createEntry(cacheKey: string, response: string): PendingCacheEntry;
+    read(cacheKey: string): Promise<string | undefined>;
+    write(entry: PendingCacheEntry): Promise<void>;
+}
 
 type LLMessage = ModelMessage;
+type LLMModel = LanguageModel;
+type TemperatureSetting = number | readonly number[];
+interface SamplingProfile {
+    readonly temperature?: TemperatureSetting;
+    readonly topP?: TemperatureSetting;
+}
+type SamplingScopeConfig<S extends string> = {
+    readonly [scope in S]: SamplingProfile;
+};
+interface LLMRequestOptions<S extends string> {
+    readonly signal?: AbortSignal;
+    readonly temperature?: TemperatureSetting;
+    readonly topP?: TemperatureSetting;
+    readonly scope?: S;
+    readonly useCache?: boolean;
+    readonly retryIndex?: number;
+    readonly retryMax?: number;
+}
+type LLMRequestFunction<S extends string> = (messages: readonly LLMessage[], options?: LLMRequestOptions<S>) => Promise<string>;
+type LLMLazyRequestOperation<S extends string, T> = (request: LLMRequestFunction<S>) => Promise<T>;
+type LLMStreamProgressCallback = (event: {
+    readonly outputCharacters: number;
+}) => void | Promise<void>;
+interface LLMTokenUsage {
+    readonly cacheReadTokens?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+}
+type LLMTokenUsageCallback = (usage: LLMTokenUsage) => void | Promise<void>;
+interface LLMOptions<S extends string> {
+    readonly model: LLMModel;
+    readonly dataDirPath: string;
+    readonly logDirPath?: string;
+    readonly cacheDirPath?: string;
+    readonly concurrent?: number;
+    readonly stream?: boolean;
+    readonly timeout?: number;
+    readonly temperature?: TemperatureSetting;
+    readonly topP?: TemperatureSetting;
+    readonly sampling?: SamplingScopeConfig<S>;
+    readonly retryTimes?: number;
+    readonly retryIntervalSeconds?: number;
+    readonly onStreamProgress?: LLMStreamProgressCallback;
+    readonly onTokenUsage?: LLMTokenUsageCallback;
+}
+
+interface LLMContextRequestInput<S extends string> {
+    messages: readonly LLMessage[];
+    options: LLMRequestOptions<S>;
+    pendingCacheEntries?: Map<string, PendingCacheEntry>;
+    logFiles?: string[];
+}
+type LLMContextRequest<S extends string> = (input: LLMContextRequestInput<S>) => Promise<string>;
+declare class LLMContext<S extends string> {
+    #private;
+    readonly sessionId: number;
+    constructor(sessionId: number, requestFn: LLMContextRequest<S>, cache?: LLMCache);
+    request(messages: readonly LLMessage[], options?: LLMRequestOptions<S>): Promise<string>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    run<T>(operation: (context: LLMContext<S>) => Promise<T>): Promise<T>;
+}
+
+declare class LLM<S extends string> {
+    #private;
+    readonly config: Readonly<{
+        concurrent: number;
+        provider?: string;
+        modelId: string;
+        sampling?: SamplingScopeConfig<S>;
+        stream: boolean;
+        timeout: number;
+        temperature: TemperatureSetting;
+        topP: TemperatureSetting;
+    }>;
+    constructor(options: LLMOptions<S>);
+    context(): LLMContext<S>;
+    withContext<T>(operation: (context: LLMContext<S>) => Promise<T>): Promise<T>;
+    request(messages: readonly LLMessage[], options?: LLMRequestOptions<S>): Promise<string>;
+    request<T>(operation: LLMLazyRequestOperation<S, T>): Promise<T>;
+    loadSystemPrompt(templateName: string, templateContext?: Record<string, unknown>): string;
+}
 
 declare class LLMPaymentRequiredError extends Error {
     readonly isRetryable = false;
@@ -100,6 +195,47 @@ declare class LLMPaymentRequiredError extends Error {
     constructor(message?: string, options?: ErrorOptions);
 }
 
+declare enum WikiGraphScope {
+    EditorCompress = "serial-generation/editor-compress",
+    EditorReview = "serial-generation/editor-review",
+    EditorReviewGuide = "serial-generation/editor-review-guide",
+    ReaderChoice = "serial-generation/reader-choice",
+    ReaderExtraction = "serial-generation/reader-extraction"
+}
+declare const WIKI_GRAPH_SCOPES: readonly [WikiGraphScope.EditorCompress, WikiGraphScope.EditorReview, WikiGraphScope.EditorReviewGuide, WikiGraphScope.ReaderChoice, WikiGraphScope.ReaderExtraction];
+declare const WIKI_GRAPH_EDITOR_SCOPES: Readonly<{
+    compress: WikiGraphScope.EditorCompress;
+    review: WikiGraphScope.EditorReview;
+    reviewGuide: WikiGraphScope.EditorReviewGuide;
+}>;
+declare const WIKI_GRAPH_READER_SCOPES: Readonly<{
+    choice: WikiGraphScope.ReaderChoice;
+    extraction: WikiGraphScope.ReaderExtraction;
+}>;
+
+declare function withLoggingContext<T>(input: {
+    readonly operation: string;
+    readonly logDirPath?: string;
+    readonly verbose?: boolean;
+}, operation: () => Promise<T>): Promise<T>;
+
+declare const CLI_PRIMARY_COMMAND = "wg";
+declare const CLI_FULL_COMMAND = "wikigraph";
+
+declare function resolveDataDirPath(): string;
+
+declare function createEnv(dirPath: string, options?: {
+    readonly autoescape?: boolean;
+    readonly trimBlocks?: boolean;
+}): Environment;
+
+declare function resolveWikiGraphHomeDirectoryPath(): string;
+declare function resolveWikiGraphCoreDatabasePath(): string;
+
+type WikiGraphTempCategory = "archive-open" | "archive-write" | "cli-output" | "sdpub-upgrade" | "stdin-create" | "url-create";
+declare function resolveWikiGraphStateRootPath(): string;
+declare function createWikiGraphTempDirectory(category: WikiGraphTempCategory): Promise<string>;
+
 type SqliteDatabase = Sqlite3Namespace.Database;
 type SqlBindValue = Buffer | Uint8Array | number | string | null;
 type SqlBindParams = readonly SqlBindValue[];
@@ -124,17 +260,26 @@ declare class Database {
     getLastInsertRowId(): Promise<number>;
 }
 
+declare function openSharedStateDatabase(databasePath: string, schemaSql: string, options?: {
+    readonly readonly?: boolean;
+}): Promise<Database>;
+declare function ensureSharedStateDatabaseInitialized(databasePath: string, schemaSql: string): Promise<void>;
+
 declare enum ChunkRetention {
     Verbatim = "verbatim",
     Detailed = "detailed",
     Focused = "focused",
     Relevant = "relevant"
 }
+declare const isChunkRetention: (value: string) => value is ChunkRetention;
+declare const expectChunkRetention: (value: string) => ChunkRetention;
 declare enum ChunkImportance {
     Critical = "critical",
     Important = "important",
     Helpful = "helpful"
 }
+declare const isChunkImportance: (value: string) => value is ChunkImportance;
+declare const expectChunkImportance: (value: string) => ChunkImportance;
 type SentenceId = readonly [chapterId: number, sentenceIndex: number];
 interface SentenceRecord {
     readonly text: string;
@@ -173,6 +318,7 @@ interface ChunkRecord {
     readonly wordsCount: number;
     readonly weight: number;
 }
+type CreateChunkRecord = Omit<ChunkRecord, "id">;
 interface ReadingEdgeRecord {
     readonly fromId: number;
     readonly toId: number;
@@ -211,6 +357,16 @@ interface SnakeRecord {
     readonly wordsCount: number;
     readonly weight: number;
 }
+interface CreateSnakeRecord {
+    readonly serialId: number;
+    readonly groupId: number;
+    readonly localSnakeId: number;
+    readonly size: number;
+    readonly firstLabel: string;
+    readonly lastLabel: string;
+    readonly wordsCount?: number;
+    readonly weight?: number;
+}
 interface SnakeChunkRecord {
     readonly snakeId: number;
     readonly chunkId: number;
@@ -228,7 +384,54 @@ interface SentenceGroupRecord {
     readonly endSentenceIndex: number;
     readonly fragmentId?: number;
 }
+declare const enum ObjectMetadataKind {
+    Archive = 1,
+    Chapter = 2,
+    Chunk = 3,
+    Entity = 4,
+    Triple = 5,
+    Object = 6
+}
+interface ObjectMetadataTarget {
+    readonly kind: ObjectMetadataKind;
+    readonly objectPath: string;
+    readonly chapterId?: number;
+    readonly chunkId?: number;
+    readonly entityQid?: string;
+    readonly tripleSubjectQid?: string;
+    readonly triplePredicate?: string;
+    readonly tripleObjectQid?: string;
+}
 
+declare const TEXT_STREAM_KIND: {
+    readonly source: 1;
+    readonly summary: 2;
+};
+type TextStreamName = keyof typeof TEXT_STREAM_KIND;
+interface TextStreamFileAccess {
+    deleteTree(path: string): Promise<void>;
+    ensureDirectory(path: string): Promise<void>;
+    listFiles(path: string): Promise<readonly string[]>;
+    readFile(path: string): Promise<Uint8Array | undefined>;
+    writeFile(path: string, content: string | Uint8Array, options: {
+        readonly overwrite?: boolean;
+    }): Promise<void>;
+}
+interface TextStreamSentenceSegmenter {
+    pipe(stream: Iterable<string>): AsyncIterable<{
+        readonly offset: number;
+        readonly text: string;
+        readonly wordsCount: number;
+    }>;
+}
+interface WriteTextStreamOptions {
+    readonly segmenter?: TextStreamSentenceSegmenter;
+}
+interface ReadonlyTextStreams {
+    getSentence(sentenceId: SentenceId): Promise<string>;
+    getSerial(serialId: number): ReadonlySerialTextStream;
+    getSummarySerial(serialId: number): ReadonlySerialTextStream;
+}
 interface ReadonlySerialTextStream {
     getFragment(fragmentId: number): Promise<FragmentRecord>;
     getSentence?(sentenceIndex: number): Promise<SentenceRecord>;
@@ -240,6 +443,106 @@ interface ReadonlySerialTextStream {
     readonly path: string;
     readonly serialId: number;
 }
+declare class TextStreams implements ReadonlyTextStreams {
+    #private;
+    constructor(documentPath: string, database: Database, fileAccess?: TextStreamFileAccess);
+    ensureCreated(): Promise<void>;
+    getSentence(sentenceId: SentenceId): Promise<string>;
+    getSerial(serialId: number): SerialTextStream;
+    getSummarySerial(serialId: number): SerialTextStream;
+}
+declare class SerialTextStream implements ReadonlySerialTextStream {
+    #private;
+    constructor(documentPath: string, database: Database, fileAccess: TextStreamFileAccess, stream: TextStreamName, serialId: number);
+    createDraft(): Promise<TextStreamDraft>;
+    getFragment(fragmentId: number): Promise<FragmentRecord>;
+    getSentence(sentenceIndex: number): Promise<SentenceRecord>;
+    listFragmentIds(): Promise<readonly number[]>;
+    listSentences(): Promise<readonly SentenceRecord[]>;
+    listSentencesInRange(startSentenceIndex: number, endSentenceIndex: number): Promise<readonly SentenceRecord[]>;
+    readTextInRange(startSentenceIndex: number, endSentenceIndex: number): Promise<string | undefined>;
+    readText(): Promise<string | undefined>;
+    writeTextStream(text: string, options?: WriteTextStreamOptions): Promise<void>;
+    delete(): Promise<void>;
+    get path(): string;
+    get serialId(): number;
+}
+declare class TextStreamDraft {
+    #private;
+    constructor(serialId: number, startSentenceIndex: number, callbacks: {
+        readonly discard: () => void;
+        readonly finalize: (startSentenceIndex: number, summary: string, sentences: readonly SentenceRecord[]) => Promise<FragmentRecord | undefined>;
+    });
+    addSentence(text: string, wordsCount: number, location?: {
+        readonly byteOffset: number;
+        readonly byteLength: number;
+    }): SentenceId;
+    commit(): Promise<FragmentRecord | undefined>;
+    commitWithText(text: string): Promise<FragmentRecord | undefined>;
+    discard(): void;
+    setSummary(summary: string): void;
+    get fragmentId(): number;
+}
+
+interface FragmentWriter {
+    write(path: string, content: string): Promise<void>;
+}
+interface FragmentFileAccess {
+    ensureDirectory(path: string): Promise<void>;
+    listFileContents?(path: string): Promise<ReadonlyMap<string, Uint8Array>>;
+    listFiles(path: string): Promise<readonly string[]>;
+    readFile(path: string): Promise<Uint8Array | undefined>;
+}
+interface ReadonlyFragments {
+    getSerial(serialId: number): ReadonlySerialFragments;
+    getSummarySerial(serialId: number): ReadonlySerialFragments;
+    getSentence(sentenceId: SentenceId): Promise<string>;
+    getSummary(serialId: number, fragmentId: number): Promise<string>;
+    getWordsCount(serialId: number, fragmentId: number): Promise<number>;
+    readonly path: string;
+}
+interface TextStreamWriteOptions {
+    readonly maxWordsCount?: number;
+}
+interface ReadonlySerialFragments {
+    getFragment(fragmentId: number): Promise<FragmentRecord>;
+    listFragmentIds(): Promise<readonly number[]>;
+    readonly serialId: number;
+    readonly path: string;
+}
+declare class Fragments implements ReadonlyFragments {
+    #private;
+    constructor(documentPath: string, writer?: FragmentWriter, fileAccess?: FragmentFileAccess);
+    ensureCreated(): Promise<void>;
+    getSerial(serialId: number): SerialFragments;
+    getSummarySerial(serialId: number): SerialFragments;
+    getSentence(sentenceId: SentenceId): Promise<string>;
+    getSummary(serialId: number, fragmentId: number): Promise<string>;
+    getWordsCount(serialId: number, fragmentId: number): Promise<number>;
+    get path(): string;
+}
+declare class SerialFragments implements ReadonlySerialFragments {
+    #private;
+    constructor(documentPath: string, serialId: number, rootDirectoryName?: string, writer?: FragmentWriter, fileAccess?: FragmentFileAccess);
+    createDraft(): Promise<FragmentDraft>;
+    getFragment(fragmentId: number): Promise<FragmentRecord>;
+    listFragmentIds(): Promise<readonly number[]>;
+    writeTextStream(text: string, options?: TextStreamWriteOptions): Promise<void>;
+    get serialId(): number;
+    get path(): string;
+}
+declare class FragmentDraft {
+    #private;
+    constructor(serialId: number, fragmentId: number, startSentenceIndex: number, callbacks: {
+        readonly discard: () => void;
+        readonly finalize: (fragmentId: number, startSentenceIndex: number, summary: string, sentences: readonly SentenceRecord[]) => Promise<FragmentRecord | undefined>;
+    });
+    addSentence(text: string, wordsCount: number): SentenceId;
+    commit(): Promise<FragmentRecord | undefined>;
+    discard(): void;
+    setSummary(summary: string): void;
+    get fragmentId(): number;
+}
 
 declare const bookMetaSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -259,6 +562,7 @@ declare const bookMetaSchema: z.ZodObject<{
 }, z.core.$strip>;
 type BookMeta = z.infer<typeof bookMetaSchema>;
 
+declare const TOC_FILE_VERSION = 1;
 interface TocItem {
     readonly title?: string | null | undefined;
     readonly serialId?: number | undefined;
@@ -345,7 +649,153 @@ interface ReadonlyFragmentGroupStore {
 interface ReadonlyObjectMetadataStore {
     getMap(objectPath: string): Promise<Readonly<Record<string, unknown>>>;
 }
+declare class ObjectMetadataStore implements ReadonlyObjectMetadataStore {
+    #private;
+    constructor(database: Database);
+    getMap(objectPath: string): Promise<Readonly<Record<string, unknown>>>;
+    replaceMap(target: ObjectMetadataTarget, map: Readonly<Record<string, unknown>>): Promise<void>;
+    put(target: ObjectMetadataTarget, key: string, value: unknown): Promise<void>;
+    deleteKey(objectPath: string, key: string): Promise<void>;
+    clear(objectPath: string): Promise<void>;
+    deleteChapterSubtree(chapterId: number): Promise<void>;
+    deleteDeletedChunks(): Promise<void>;
+    deleteDeletedEntitiesAndTriples(): Promise<void>;
+}
+declare class SerialStore implements ReadonlySerialStore {
+    #private;
+    constructor(database: Database);
+    create(): Promise<number>;
+    createWithId(serialId: number): Promise<void>;
+    ensure(serialId: number): Promise<void>;
+    getById(serialId: number): Promise<SerialRecord | undefined>;
+    getRevision(serialId: number): Promise<number>;
+    getRevisions(serialIds: readonly number[]): Promise<ReadonlyMap<number, number>>;
+    bumpRevision(serialId: number): Promise<void>;
+    bumpChaptersRevision(): Promise<void>;
+    getChaptersRevision(): Promise<number>;
+    getMaxId(): Promise<number>;
+    setTopologyReady(serialId: number, ready?: boolean, parameterHash?: string): Promise<void>;
+    setKnowledgeGraphReady(serialId: number, ready?: boolean, parameterHash?: string): Promise<void>;
+    listIds(): Promise<number[]>;
+    listDocumentOrders(): Promise<ReadonlyMap<number, number>>;
+    setDocumentOrders(entries: readonly {
+        readonly documentOrder: number;
+        readonly serialId: number;
+    }[]): Promise<void>;
+}
+declare class GraphBuildParameterStore implements ReadonlyGraphBuildParameterStore {
+    #private;
+    constructor(database: Database);
+    save(input: {
+        readonly language?: string;
+        readonly prompt: string;
+    }): Promise<GraphBuildParameterRecord>;
+    getByHash(hash: string): Promise<GraphBuildParameterRecord | undefined>;
+    deleteUnreferenced(): Promise<void>;
+}
+declare class ChunkStore implements ReadonlyChunkStore {
+    #private;
+    constructor(database: Database);
+    countAll(): Promise<number>;
+    create(record: CreateChunkRecord): Promise<ChunkRecord>;
+    save(record: ChunkRecord): Promise<void>;
+    getById(chunkId: number): Promise<ChunkRecord | undefined>;
+    listAll(): Promise<ChunkRecord[]>;
+    listBySentenceStartIndexes(serialId: number, sentenceStartIndexes: readonly number[]): Promise<ChunkRecord[]>;
+    listBySentenceRange(serialId: number, startSentenceIndex: number, endSentenceIndex: number): Promise<ChunkRecord[]>;
+    listBySerial(serialId: number): Promise<ChunkRecord[]>;
+    getMaxId(): Promise<number>;
+    listFragmentPairs(): Promise<ReadonlyArray<readonly [number, number]>>;
+}
+declare class ReadingEdgeStore implements ReadonlyReadingEdgeStore {
+    #private;
+    constructor(database: Database);
+    countAll(): Promise<number>;
+    save(record: ReadingEdgeRecord): Promise<void>;
+    listAll(): Promise<ReadingEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<ReadingEdgeRecord[]>;
+    listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]>;
+    listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
+}
+declare class SnakeStore implements ReadonlySnakeStore {
+    #private;
+    constructor(database: Database);
+    create(record: CreateSnakeRecord): Promise<number>;
+    getById(snakeId: number): Promise<SnakeRecord | undefined>;
+    listIdsByGroup(serialId: number, groupId: number): Promise<number[]>;
+    listBySerial(serialId: number): Promise<SnakeRecord[]>;
+}
+declare class MentionStore implements ReadonlyMentionStore {
+    #private;
+    constructor(database: Database);
+    save(record: MentionRecord): Promise<void>;
+    saveMany(records: readonly MentionRecord[]): Promise<void>;
+    getById(mentionId: string): Promise<MentionRecord | undefined>;
+    listAll(): Promise<MentionRecord[]>;
+    listByQid(qid: string): Promise<MentionRecord[]>;
+    listBySurfaces(surfaces: readonly string[]): Promise<MentionRecord[]>;
+    listBySurfaceTerms(terms: readonly string[]): Promise<MentionRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionRecord[]>;
+    deleteByChapter(chapterId: number): Promise<void>;
+}
+declare class MentionLinkStore implements ReadonlyMentionLinkStore {
+    #private;
+    constructor(database: Database);
+    save(record: MentionLinkRecord): Promise<void>;
+    saveMany(records: readonly MentionLinkRecord[]): Promise<void>;
+    getById(linkId: string): Promise<MentionLinkRecord | undefined>;
+    listByTriple(input: {
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<MentionLinkRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionLinkRecord[]>;
+    deleteByChapter(chapterId: number): Promise<void>;
+}
+declare class SnakeChunkStore implements ReadonlySnakeChunkStore {
+    #private;
+    constructor(database: Database);
+    save(record: SnakeChunkRecord): Promise<void>;
+    listChunkIds(snakeId: number): Promise<number[]>;
+    listBySnake(snakeId: number): Promise<SnakeChunkRecord[]>;
+}
+declare class SnakeEdgeStore implements ReadonlySnakeEdgeStore {
+    #private;
+    constructor(database: Database);
+    save(record: SnakeEdgeRecord): Promise<void>;
+    listIncoming(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listOutgoing(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listWithin(snakeIds: readonly number[]): Promise<SnakeEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<SnakeEdgeRecord[]>;
+}
+declare class FragmentGroupStore implements ReadonlyFragmentGroupStore {
+    #private;
+    constructor(database: Database);
+    save(record: SentenceGroupRecord): Promise<void>;
+    saveMany(records: readonly SentenceGroupRecord[]): Promise<void>;
+    listBySerial(serialId: number): Promise<SentenceGroupRecord[]>;
+    listSerialIds(): Promise<number[]>;
+    listGroupIdsForSerial(serialId: number): Promise<number[]>;
+}
 
+interface DocumentFileStore {
+    close(): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    deleteTree(path: string): Promise<void>;
+    ensureDirectory(path: string): Promise<void>;
+    initializeDatabaseSchema(): boolean;
+    markDatabaseDirty?(): void;
+    markSearchIndexDatabaseDirty?(): void;
+    openDatabaseReadonly(): boolean;
+    listFileContents?(path: string): Promise<ReadonlyMap<string, Uint8Array>>;
+    listFiles(path: string): Promise<readonly string[]>;
+    readFile(path: string): Promise<Uint8Array | undefined>;
+    resolveDatabasePath(documentPath: string): Promise<string>;
+    resolveSearchIndexDatabasePath?(documentPath: string): Promise<string>;
+    writeFile(path: string, content: string | Uint8Array, options: {
+        readonly overwrite?: boolean;
+    }): Promise<void>;
+}
 interface ReadonlyDocument {
     readonly chunks: ReadonlyChunkStore;
     readonly fragmentGroups: ReadonlyFragmentGroupStore;
@@ -370,6 +820,107 @@ interface ReadonlyDocument {
     readToc(): Promise<TocFile | undefined>;
     release(): Promise<void>;
 }
+interface DocumentContext {
+    complete(): void;
+    dispose(): Promise<void>;
+    ownSerial(serialId: number): void;
+    run<T>(operation: () => Promise<T> | T): Promise<T>;
+}
+interface Document extends ReadonlyDocument {
+    readonly chunks: ChunkStore;
+    readonly fragmentGroups: FragmentGroupStore;
+    readonly graphBuildParameters: GraphBuildParameterStore;
+    readonly readingEdges: ReadingEdgeStore;
+    readonly mentionLinks: MentionLinkStore;
+    readonly mentions: MentionStore;
+    readonly metadata: ObjectMetadataStore;
+    readonly serials: SerialStore;
+    readonly snakeChunks: SnakeChunkStore;
+    readonly snakeEdges: SnakeEdgeStore;
+    readonly snakes: SnakeStore;
+    createContext(): DocumentContext;
+    getSerialFragments(serialId: number): SerialTextStream;
+    getSummaryFragments(serialId: number): SerialTextStream;
+    createSerial(): Promise<number>;
+    clearSerialGraph(serialId: number): Promise<void>;
+    clearSerialSource(serialId: number): Promise<void>;
+    deleteSerial(serialId: number): Promise<void>;
+    deleteSearchIndexDatabase(): Promise<void>;
+    deleteSummary(serialId: number): Promise<void>;
+    flush(): Promise<void>;
+    openSession<T>(operation: (document: Document) => Promise<T> | T): Promise<T>;
+    peekNextSerialId(): Promise<number>;
+    replaceBookMeta(meta: BookMeta): Promise<void>;
+    replaceToc(toc: TocFile): Promise<void>;
+    writeBookMeta(meta: BookMeta): Promise<void>;
+    writeCover(cover: SourceAsset): Promise<void>;
+    writeSummary(serialId: number, summary: string): Promise<void>;
+    writeToc(toc: TocFile): Promise<void>;
+    writeSearchIndexDatabase<T>(operation: (database: Database) => Promise<T> | T): Promise<T>;
+}
+declare class DirectoryDocument implements Document {
+    #private;
+    readonly chunks: ChunkStore;
+    readonly fragmentGroups: FragmentGroupStore;
+    readonly graphBuildParameters: GraphBuildParameterStore;
+    readonly readingEdges: ReadingEdgeStore;
+    readonly mentionLinks: MentionLinkStore;
+    readonly mentions: MentionStore;
+    readonly metadata: ObjectMetadataStore;
+    readonly path: string;
+    readonly serials: SerialStore;
+    readonly snakeChunks: SnakeChunkStore;
+    readonly snakeEdges: SnakeEdgeStore;
+    readonly snakes: SnakeStore;
+    constructor(database: Database, textStreams: TextStreams, path: string, fileStore?: DocumentFileStore);
+    static open(documentPath: string, options?: {
+        readonly fileStore?: DocumentFileStore;
+    }): Promise<DirectoryDocument>;
+    static openSession<T>(documentPath: string, operation: (document: DirectoryDocument) => Promise<T> | T): Promise<T>;
+    getSerialFragments(serialId: number): SerialTextStream;
+    getSummaryFragments(serialId: number): SerialTextStream;
+    createContext(): DocumentContext;
+    createSerial(): Promise<number>;
+    clearSerialGraph(serialId: number): Promise<void>;
+    clearSerialSource(serialId: number): Promise<void>;
+    deleteSerial(serialId: number): Promise<void>;
+    deleteSummary(serialId: number): Promise<void>;
+    getSentence(sentenceId: SentenceId): Promise<string>;
+    openSession<T>(operation: (document: Document) => Promise<T> | T): Promise<T>;
+    readDatabase<T>(operation: (database: Database) => Promise<T> | T): Promise<T>;
+    readSearchIndexDatabase<T>(operation: (database: Database) => Promise<T> | T): Promise<T>;
+    writeSearchIndexDatabase<T>(operation: (database: Database) => Promise<T> | T): Promise<T>;
+    deleteSearchIndexDatabase(): Promise<void>;
+    peekNextSerialId(): Promise<number>;
+    readBookMeta(): Promise<BookMeta | undefined>;
+    readCover(): Promise<SourceAsset | undefined>;
+    readSummary(serialId: number): Promise<string | undefined>;
+    readToc(): Promise<TocFile | undefined>;
+    writeBookMeta(meta: BookMeta): Promise<void>;
+    replaceBookMeta(meta: BookMeta): Promise<void>;
+    writeCover(cover: SourceAsset): Promise<void>;
+    writeSummary(serialId: number, summary: string): Promise<void>;
+    writeToc(toc: TocFile): Promise<void>;
+    replaceToc(toc: TocFile): Promise<void>;
+    flush(): Promise<void>;
+    release(): Promise<void>;
+    close(): Promise<void>;
+    runWithContext<T>(context: DirectoryDocumentContext, operation: () => Promise<T> | T): Promise<T>;
+    rollbackContext(context: DirectoryDocumentContext): Promise<void>;
+}
+declare class DirectoryDocumentContext implements DocumentContext {
+    #private;
+    constructor(document: DirectoryDocument);
+    complete(): void;
+    dispose(): Promise<void>;
+    ownSerial(serialId: number): void;
+    run<T>(operation: () => Promise<T> | T): Promise<T>;
+    listCreatedFilePaths(): readonly string[];
+    listOwnedSerialIds(): readonly number[];
+    registerCreatedFile(path: string): void;
+}
+
+declare const SCHEMA_SQL = "\n  CREATE TABLE IF NOT EXISTS serials (\n    id INTEGER PRIMARY KEY,\n    document_order INTEGER NOT NULL DEFAULT 0\n  );\n\n  CREATE TABLE IF NOT EXISTS serial_states (\n    serial_id INTEGER PRIMARY KEY,\n    revision INTEGER NOT NULL DEFAULT 0,\n    topology_ready INTEGER NOT NULL DEFAULT 0,\n    topology_parameter_hash TEXT,\n    knowledge_graph_ready INTEGER NOT NULL DEFAULT 0,\n    knowledge_graph_parameter_hash TEXT,\n    FOREIGN KEY (serial_id) REFERENCES serials(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS archive_revisions (\n    key TEXT PRIMARY KEY,\n    value INTEGER NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS archive_index_settings (\n    id INTEGER PRIMARY KEY CHECK (id = 1),\n    fts_embedded INTEGER NOT NULL DEFAULT 0\n  );\n\n  CREATE TABLE IF NOT EXISTS graph_build_parameters (\n    hash TEXT PRIMARY KEY,\n    prompt TEXT NOT NULL,\n    language TEXT,\n    created_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS chunks (\n    id INTEGER PRIMARY KEY,\n    generation INTEGER NOT NULL,\n    serial_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    label TEXT NOT NULL,\n    content TEXT NOT NULL,\n    retention TEXT,\n    importance TEXT,\n    wordsCount INTEGER NOT NULL DEFAULT 0,\n    weight REAL NOT NULL DEFAULT 0.0\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_chunks_sentence\n  ON chunks(serial_id, sentence_index);\n\n  CREATE INDEX IF NOT EXISTS idx_chunks_serial_id\n  ON chunks(serial_id, id);\n\n  CREATE TABLE IF NOT EXISTS chunk_sentences (\n    chunk_id INTEGER NOT NULL,\n    serial_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    FOREIGN KEY (chunk_id) REFERENCES chunks(id),\n    PRIMARY KEY (chunk_id, serial_id, sentence_index)\n  );\n\n  CREATE TABLE IF NOT EXISTS reading_edges (\n    from_id INTEGER NOT NULL,\n    to_id INTEGER NOT NULL,\n    strength TEXT,\n    weight REAL NOT NULL DEFAULT 0.1,\n    PRIMARY KEY (from_id, to_id),\n    FOREIGN KEY (from_id) REFERENCES chunks(id),\n    FOREIGN KEY (to_id) REFERENCES chunks(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS snakes (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    serial_id INTEGER NOT NULL,\n    group_id INTEGER NOT NULL,\n    local_snake_id INTEGER NOT NULL,\n    size INTEGER NOT NULL,\n    first_label TEXT NOT NULL,\n    last_label TEXT NOT NULL,\n    wordsCount INTEGER NOT NULL DEFAULT 0,\n    weight REAL NOT NULL DEFAULT 0.0,\n    UNIQUE(serial_id, group_id, local_snake_id)\n  );\n\n  CREATE TABLE IF NOT EXISTS snake_chunks (\n    snake_id INTEGER NOT NULL,\n    chunk_id INTEGER NOT NULL,\n    position INTEGER NOT NULL,\n    FOREIGN KEY (snake_id) REFERENCES snakes(id),\n    FOREIGN KEY (chunk_id) REFERENCES chunks(id),\n    PRIMARY KEY (snake_id, chunk_id)\n  );\n\n  CREATE TABLE IF NOT EXISTS snake_edges (\n    from_snake_id INTEGER NOT NULL,\n    to_snake_id INTEGER NOT NULL,\n    weight REAL NOT NULL DEFAULT 0.1,\n    PRIMARY KEY (from_snake_id, to_snake_id),\n    FOREIGN KEY (from_snake_id) REFERENCES snakes(id),\n    FOREIGN KEY (to_snake_id) REFERENCES snakes(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS sentence_groups (\n    serial_id INTEGER NOT NULL,\n    group_id INTEGER NOT NULL,\n    start_sentence_index INTEGER NOT NULL,\n    end_sentence_index INTEGER NOT NULL,\n    PRIMARY KEY (serial_id, group_id, start_sentence_index, end_sentence_index)\n  );\n\n  CREATE TABLE IF NOT EXISTS mentions (\n    id TEXT PRIMARY KEY,\n    chapter_id INTEGER NOT NULL,\n    sentence_index INTEGER,\n    range_start INTEGER NOT NULL,\n    range_end INTEGER NOT NULL,\n    surface TEXT NOT NULL,\n    qid TEXT NOT NULL,\n    confidence REAL,\n    note TEXT,\n    FOREIGN KEY (chapter_id) REFERENCES serials(id)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_chapter\n  ON mentions(chapter_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_chapter_position\n  ON mentions(chapter_id, sentence_index, range_start, range_end, id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_chapter_qid\n  ON mentions(chapter_id, qid);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_qid\n  ON mentions(qid);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_qid_position\n  ON mentions(qid, chapter_id, sentence_index, range_start, range_end, id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_surface\n  ON mentions(surface);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_surface_position\n  ON mentions(surface, chapter_id, sentence_index, range_start, range_end, id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_sentence\n  ON mentions(chapter_id, sentence_index);\n\n  CREATE TABLE IF NOT EXISTS mention_links (\n    id TEXT PRIMARY KEY,\n    source_mention_id TEXT NOT NULL,\n    target_mention_id TEXT NOT NULL,\n    predicate TEXT NOT NULL,\n    confidence REAL,\n    note TEXT,\n    FOREIGN KEY (source_mention_id) REFERENCES mentions(id),\n    FOREIGN KEY (target_mention_id) REFERENCES mentions(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS mention_link_evidence_sentences (\n    link_id TEXT NOT NULL,\n    chapter_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    FOREIGN KEY (link_id) REFERENCES mention_links(id),\n    PRIMARY KEY (link_id, chapter_id, sentence_index)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_mention_link_evidence_sentences_sentence\n  ON mention_link_evidence_sentences(chapter_id, sentence_index);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_source\n  ON mention_links(source_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_target\n  ON mention_links(target_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_predicate\n  ON mention_links(predicate);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_predicate_source_target\n  ON mention_links(predicate, source_mention_id, target_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_predicate_target_source\n  ON mention_links(predicate, target_mention_id, source_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_source_predicate_target\n  ON mention_links(source_mention_id, predicate, target_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_target_predicate_source\n  ON mention_links(target_mention_id, predicate, source_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_source_target_predicate\n  ON mention_links(source_mention_id, target_mention_id, predicate);\n\n  CREATE INDEX IF NOT EXISTS idx_reading_edges_target\n  ON reading_edges(to_id, from_id);\n\n  CREATE INDEX IF NOT EXISTS idx_snake_edges_target\n  ON snake_edges(to_snake_id, from_snake_id);\n\n  CREATE VIEW IF NOT EXISTS chapter_entities AS\n  SELECT\n    chapter_id,\n    qid,\n    COUNT(*) AS mention_count\n  FROM mentions\n  GROUP BY chapter_id, qid;\n\n  CREATE VIEW IF NOT EXISTS book_entities AS\n  SELECT\n    qid,\n    SUM(mention_count) AS mention_count\n  FROM chapter_entities\n  GROUP BY qid;\n\n  CREATE VIEW IF NOT EXISTS chapter_entity_relations AS\n  SELECT\n    source_mentions.chapter_id AS chapter_id,\n    source_mentions.qid AS subject_qid,\n    mention_links.predicate AS predicate,\n    target_mentions.qid AS object_qid,\n    COUNT(*) AS evidence_count\n  FROM mention_links\n  JOIN mentions AS source_mentions\n    ON source_mentions.id = mention_links.source_mention_id\n  JOIN mentions AS target_mentions\n    ON target_mentions.id = mention_links.target_mention_id\n  WHERE source_mentions.chapter_id = target_mentions.chapter_id\n  GROUP BY\n    source_mentions.chapter_id,\n    source_mentions.qid,\n    mention_links.predicate,\n    target_mentions.qid;\n\n  CREATE VIEW IF NOT EXISTS book_entity_relations AS\n  SELECT\n    subject_qid,\n    predicate,\n    object_qid,\n    SUM(evidence_count) AS evidence_count\n  FROM chapter_entity_relations\n  GROUP BY subject_qid, predicate, object_qid;\n\n  CREATE TABLE IF NOT EXISTS text_sentence_records (\n    id INTEGER PRIMARY KEY,\n    kind INTEGER NOT NULL,\n    chapter_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    words_count INTEGER NOT NULL DEFAULT 0,\n    byte_offset INTEGER NOT NULL DEFAULT 0,\n    byte_length INTEGER NOT NULL DEFAULT 0,\n    UNIQUE(kind, chapter_id, sentence_index)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_text_sentence_records_chapter\n  ON text_sentence_records(kind, chapter_id, sentence_index);\n\n  CREATE TABLE IF NOT EXISTS object_metadata (\n    id INTEGER PRIMARY KEY,\n    object_kind INTEGER NOT NULL,\n    object_path TEXT NOT NULL,\n    key TEXT NOT NULL,\n    value_json TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    chapter_id INTEGER,\n    chunk_id INTEGER,\n    entity_qid TEXT,\n    triple_subject_qid TEXT,\n    triple_predicate TEXT,\n    triple_object_qid TEXT,\n    UNIQUE(object_path, key)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_object\n  ON object_metadata(object_path);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_chapter\n  ON object_metadata(chapter_id);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_chunk\n  ON object_metadata(chunk_id);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_entity\n  ON object_metadata(entity_qid);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_triple\n  ON object_metadata(\n    triple_subject_qid,\n    triple_predicate,\n    triple_object_qid\n  );\n";
 
 declare const EVIDENCE_SELECTION_PROMPT_FRAGMENT: string;
 declare const EVIDENCE_SELECTION_JSON_SHAPE: readonly [{
@@ -458,11 +1009,24 @@ declare function resolveEvidenceSelectionList(input: {
 ];
 declare function rankEvidenceQuote(quote: string, sentences: readonly EvidenceSelectionSentence[]): EvidenceSelectionCandidate[];
 
+interface GcContext {
+    readonly force: boolean;
+    readonly now: number;
+    readonly stateDirectoryPath: string;
+    readonly dryRun: boolean;
+}
+interface GcJobResult {
+    readonly scanned: number;
+    readonly removed: number;
+    readonly freedBytes: number;
+}
+
 interface WikipageResolverOptions {
     readonly cacheDatabasePath?: string;
     readonly concurrency?: number;
     readonly fetch?: typeof fetch;
     readonly language?: string;
+    readonly logDirPath?: string;
     readonly maxBatchSize?: number;
     readonly minRequestIntervalMs?: number;
     readonly normalizer?: DisambiguationProfileNormalizer;
@@ -564,6 +1128,10 @@ declare class WikipageCache {
 }
 
 type GuaranteedRequest = (messages: readonly LLMessage[], index: number, maxRetries: number) => Promise<string | undefined>;
+type GuaranteedLazyRequest = <T>(operation: (request: GuaranteedRequest) => Promise<T>) => Promise<T>;
+type GuaranteedRequestController = GuaranteedRequest & {
+    lazy?: GuaranteedLazyRequest;
+};
 
 interface CreateDisambiguationProfileNormalizerOptions {
     readonly maxMeanings?: number;
@@ -584,12 +1152,28 @@ declare class RateLimiter {
 }
 declare function parseRetryAfterMs(value: string | null): number | undefined;
 
+interface WikipageFetchLog {
+    readonly filePath: string | undefined;
+    append(entry: WikipageFetchLogEntry): Promise<void>;
+    warnFailed(): void;
+}
+interface WikipageFetchLogEntry {
+    readonly attempt: number;
+    readonly durationMs: number;
+    readonly error?: unknown;
+    readonly response?: Response;
+    readonly responseText?: string;
+    readonly startedAt: number;
+    readonly url: URL;
+}
+
 type SupportedWiki = "enwiki" | "zhwiki";
 interface WikimediaClientOptions {
     readonly concurrency: number;
     readonly fetch?: typeof fetch;
     readonly language: string;
     readonly minRequestIntervalMs: number;
+    readonly requestLog: WikipageFetchLog;
     readonly retryBaseDelayMs: number;
     readonly retryTimes: number;
     readonly userAgent?: string;
@@ -651,6 +1235,11 @@ interface WikimatchCandidate {
     readonly range: WikimatchTextRange;
     readonly surface: string;
 }
+interface WikimatchSentence {
+    readonly id?: string;
+    readonly range: WikimatchTextRange;
+    readonly text: string;
+}
 interface WikimatchQidOption {
     readonly description?: string;
     readonly disambiguation?: DisambiguationExpansion;
@@ -668,6 +1257,11 @@ interface WikimatchWindow {
     readonly groups: readonly WikimatchConflictGroup[];
     readonly text: string;
 }
+interface WikimatchSurface {
+    readonly id: string;
+    readonly count: number;
+    readonly text: string;
+}
 interface WikimatchConflictGroup {
     readonly candidateIds: readonly string[];
     readonly id: string;
@@ -679,6 +1273,60 @@ interface BuildWikimatchWindowsOptions {
     readonly optionBudget: number;
     readonly text: string;
 }
+interface NarrowWikimatchCandidateOptionsInput {
+    readonly candidate: WikimatchCandidate;
+    readonly policyPrompt: string;
+    readonly text: string;
+}
+interface WikimatchCandidateOptionNarrowingResult {
+    readonly candidate: WikimatchCandidate;
+    readonly fallback?: WikimatchCandidateOptionNarrowingFallback;
+}
+interface WikimatchCandidateOptionNarrowingFallback {
+    readonly issues: readonly string[];
+    readonly reason: "guaranteed_json_failed";
+}
+interface WikimatchCandidateOptionNarrowingResponse {
+    readonly qids: readonly WikimatchCandidateOptionNarrowingItemOutput[];
+}
+interface WikimatchCandidateOptionNarrowingItemOutput {
+    readonly decision: "keep" | "reject";
+    readonly qid: string;
+}
+interface BuildWikimatchSurfaceProtectionInputOptions {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly percentile: number;
+    readonly text: string;
+}
+interface WikimatchSurfaceProtectionInput {
+    readonly policyPrompt: string;
+    readonly suspiciousSurfaces: readonly WikimatchSurface[];
+}
+interface WikimatchSurfaceProtectionBuildResult {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly suppressedCandidates: readonly WikimatchCandidate[];
+    readonly suspiciousSurfaces: readonly WikimatchSurface[];
+}
+interface WikimatchSurfaceProtectionResult {
+    readonly fallback?: WikimatchSurfaceProtectionFallback;
+    readonly protectedSurfaces: readonly WikimatchProtectedSurface[];
+}
+interface WikimatchProtectedSurface {
+    readonly note?: string;
+    readonly surfaceId: string;
+    readonly text: string;
+}
+interface WikimatchSurfaceProtectionFallback {
+    readonly issues: readonly string[];
+    readonly reason: "guaranteed_json_failed";
+}
+interface WikimatchProtectedSurfaceOutput {
+    readonly note?: string;
+    readonly surfaceId: string;
+}
+interface WikimatchSurfaceProtectionResponse {
+    readonly protectedSurfaces: readonly WikimatchProtectedSurfaceOutput[];
+}
 type WikimatchPolicyDecision = "continue" | "never_recall" | "recall" | "skip_this_time";
 interface WikimatchPolicyJudgeInput {
     readonly candidates: readonly WikimatchCandidate[];
@@ -735,10 +1383,114 @@ interface JudgeWikimatchPolicyOptions extends WikimatchPolicyJudgeInput {
 declare function judgeWikimatchPolicy(options: JudgeWikimatchPolicyOptions): Promise<WikimatchPolicyJudgeResult>;
 declare function parsePolicyResponse(candidates: readonly WikimatchCandidate[], response: WikimatchPolicyResponse, groups?: readonly WikimatchConflictGroup[]): WikimatchPolicyJudgeResult;
 declare function validatePolicyResponse(candidates: readonly WikimatchCandidate[], response: WikimatchPolicyResponse, groups?: readonly WikimatchConflictGroup[]): readonly string[];
+declare function formatCandidateForPrompt(candidate: WikimatchCandidate, _group?: WikimatchConflictGroup): object;
+
+interface NarrowWikimatchCandidateOptionsOptions extends NarrowWikimatchCandidateOptionsInput {
+    readonly maxRetries?: number;
+    readonly optionBudget: number;
+    readonly request: GuaranteedRequest;
+}
+declare function narrowWikimatchCandidateOptions(options: NarrowWikimatchCandidateOptionsOptions): Promise<WikimatchCandidateOptionNarrowingResult>;
+declare function parseNarrowingResponse(candidate: WikimatchCandidate, response: WikimatchCandidateOptionNarrowingResponse): WikimatchCandidateOptionNarrowingResult;
+declare function validateNarrowingResponse(candidate: WikimatchCandidate, response: WikimatchCandidateOptionNarrowingResponse): readonly string[];
+
+declare function countWikimatchCandidateOptions(candidate: WikimatchCandidate): number;
+declare function countWikimatchQidOption(option: WikimatchQidOption): number;
+declare function listCandidateSelectableQids(candidate: WikimatchCandidate): readonly string[];
+declare function filterCandidateQidOptions(candidate: WikimatchCandidate, allowedQids: ReadonlySet<string>): WikimatchCandidate;
+declare function splitCandidateByOptionBudget(candidate: WikimatchCandidate, optionBudget: number): readonly WikimatchCandidate[];
+declare function sliceCandidateByOptionBudget(candidate: WikimatchCandidate, optionBudget: number, offset: number): {
+    readonly candidate: WikimatchCandidate;
+    readonly nextOffset?: number;
+};
+
+declare function enrichWikimatchCandidates(candidates: readonly WikimatchCandidate[], options?: {
+    readonly progress?: WikipageResolveProgressReporter;
+    readonly resolverOptions?: Omit<WikipageResolverOptions, "progress">;
+}): Promise<readonly WikimatchCandidate[]>;
+declare function applyQidResolutions(candidates: readonly WikimatchCandidate[], resolutions: readonly QidResolution[]): readonly WikimatchCandidate[];
+
+interface JudgeWikimatchSurfaceProtectionOptions extends WikimatchSurfaceProtectionInput {
+    readonly maxRetries?: number;
+    readonly request: GuaranteedRequest;
+}
+declare function judgeWikimatchSurfaceProtection(options: JudgeWikimatchSurfaceProtectionOptions): Promise<WikimatchSurfaceProtectionResult>;
+declare function parseSurfaceProtectionResponse(surfaces: readonly WikimatchSurface[], response: WikimatchSurfaceProtectionResponse): WikimatchSurfaceProtectionResult;
+declare function validateSurfaceProtectionResponse(surfaces: readonly WikimatchSurface[], response: WikimatchSurfaceProtectionResponse): readonly string[];
+
+declare function buildWikimatchSurfaceProtectionInput(options: BuildWikimatchSurfaceProtectionInputOptions): WikimatchSurfaceProtectionBuildResult;
+
+interface SuppressContainedRangeInput {
+    readonly range: {
+        readonly end: number;
+        readonly start: number;
+    };
+}
+declare function suppressContainedRanges<T extends SuppressContainedRangeInput>(items: readonly T[]): readonly T[];
+
+interface MatchWikispineSentenceCandidatesOptions {
+    readonly command?: string;
+    readonly dataDir?: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof fetch;
+    readonly includeDisambiguation?: boolean;
+    readonly maxCandidatesPerSurface?: number;
+    readonly onProgress?: (progress: WikispineMatchProgress) => Promise<void> | void;
+    readonly provider?: WikispineProvider;
+    readonly sentences: readonly WikimatchSentence[];
+}
+type WikispineProvider = "cli" | "fetch";
+interface WikispineMatchProgress {
+    readonly coveredRangeEnd: number;
+}
+interface TestWikispineRuntimeOptions {
+    readonly command?: string;
+    readonly dataDir?: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof fetch;
+    readonly provider?: WikispineProvider;
+}
+interface WikispineRuntimeTestResult {
+    readonly durationMs: number;
+    readonly metadata?: WikispineMetadata;
+    readonly ok: true;
+    readonly provider: WikispineProvider;
+}
+interface WikispineMetadata {
+    readonly automaton_shard_count: number;
+    readonly format: string;
+    readonly qid_count: number;
+    readonly surface_count: number;
+    readonly surface_normalization: string;
+}
+declare const DEFAULT_WIKISPINE_FETCH_ENDPOINT = "https://wikispi-service-cxbfjlteab.cn-hangzhou.fcapp.run";
+declare function matchWikispineSentenceCandidates(options: MatchWikispineSentenceCandidatesOptions): Promise<readonly WikimatchCandidate[]>;
+declare function testWikispineRuntime(options: TestWikispineRuntimeOptions): Promise<WikispineRuntimeTestResult>;
 
 declare function buildWikimatchWindows(options: BuildWikimatchWindowsOptions): readonly WikimatchWindow[];
 
-type SpineDigestOperation = "digest-epub" | "digest-markdown" | "digest-text-stream" | "digest-txt";
+interface WordBoundary {
+    readonly end: number;
+    readonly start: number;
+}
+declare function listWordBoundaries(text: string): readonly WordBoundary[];
+declare function expandRangeByWords(input: {
+    readonly rangeEnd: number;
+    readonly rangeStart: number;
+    readonly text: string;
+    readonly words: number;
+}): {
+    readonly end: number;
+    readonly start: number;
+};
+
+type WikiGraphSamplingConfig = SamplingScopeConfig<WikiGraphScope>;
+declare function createDefaultWikiGraphSampling(input?: {
+    readonly temperature?: TemperatureSetting;
+    readonly topP?: TemperatureSetting;
+}): WikiGraphSamplingConfig;
+
+type WikiGraphOperation = "digest-epub" | "digest-markdown" | "digest-text-stream" | "digest-txt";
 interface SerialDiscoveryItem {
     readonly id: number;
     readonly fragments?: number | undefined;
@@ -761,21 +1513,175 @@ interface DigestProgressEvent {
     readonly completedWords: number;
     readonly totalWords: number;
 }
-type SpineDigestProgressEventType = SpineDigestProgressEvent["type"];
-type SpineDigestProgressEvent = SerialsDiscoveredEvent | SerialProgressEvent | DigestProgressEvent;
-type SpineDigestProgressCallback = (event: SpineDigestProgressEvent) => void | Promise<void>;
+type WikiGraphProgressEventType = WikiGraphProgressEvent["type"];
+type WikiGraphProgressEvent = SerialsDiscoveredEvent | SerialProgressEvent | DigestProgressEvent;
+type WikiGraphProgressCallback = (event: WikiGraphProgressEvent) => void | Promise<void>;
+
+type TextStream = AsyncIterable<string> | Iterable<string>;
+
+type ReaderTextStream = TextStream;
+
+interface SerialProgressSink {
+    begin?(input?: {
+        readonly fragments: number;
+        readonly words: number;
+    }): Promise<void>;
+    advance(wordsCount: number): Promise<void>;
+    complete(finalWordsCount?: number): Promise<void>;
+}
 
 declare const CHAPTER_STAGES: readonly ["planned", "sourced", "graphed", "summarized"];
 type ChapterStage = (typeof CHAPTER_STAGES)[number];
+interface ChapterEntry {
+    readonly chapterId: number;
+    readonly childCount: number;
+    readonly depth: number;
+    readonly documentOrder: number;
+    readonly fragmentCount: number;
+    readonly stage: ChapterStage;
+    readonly title: string | null;
+    readonly tocPath: readonly string[];
+    readonly words: number;
+}
+interface ChapterDetails extends ChapterEntry {
+    readonly graphReady: boolean;
+    readonly hasSummary: boolean;
+    readonly words: number;
+}
+interface ChapterTree {
+    readonly chapters: readonly ChapterTreeNode[];
+}
+interface ChapterTreeNode {
+    readonly children: readonly ChapterTreeNode[];
+    readonly id: number;
+    readonly title: string | null;
+}
+interface ChapterTreeInput {
+    readonly chapters: readonly ChapterTreeInputNode[];
+}
+interface ChapterTreeInputNode {
+    readonly children: readonly ChapterTreeInputNode[];
+    readonly id: number;
+    readonly title?: string | null | undefined;
+}
+interface ChapterTreeApplyResult {
+    readonly changed: boolean;
+    readonly moved: readonly ChapterTreeMoveChange[];
+    readonly renamed: readonly ChapterTreeTitleChange[];
+    readonly unchanged: number;
+}
+interface ChapterTreeMoveChange {
+    readonly chapterId: number;
+    readonly newIndex: number;
+    readonly newParentChapterId: number | null;
+    readonly newPath: readonly string[];
+    readonly oldIndex: number;
+    readonly oldParentChapterId: number | null;
+    readonly oldPath: readonly string[];
+}
+interface ChapterTreeTitleChange {
+    readonly chapterId: number;
+    readonly newTitle: string | null;
+    readonly oldTitle: string | null;
+}
+interface MoveChapterOptions {
+    readonly afterChapterId?: number;
+    readonly beforeChapterId?: number;
+    readonly first?: boolean;
+    readonly last?: boolean;
+    readonly parentChapterId?: number;
+    readonly root?: boolean;
+}
+interface AdvanceChapterStagesOptions {
+    readonly chapterId?: number;
+    readonly extractionPrompt: string;
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly onProgress?: AdvanceChapterStagesProgressCallback;
+    readonly targetStage: ChapterStage;
+    readonly userLanguage?: Language;
+}
+interface AdvanceChapterStagesProgressState {
+    readonly graphWords: number;
+    readonly summaryWords: number;
+    readonly totalGraphWords: number;
+    readonly totalSummaryWords: number;
+}
+type AdvanceChapterStagesProgressCallback = (event: AdvanceChapterStagesProgressEvent) => void | Promise<void>;
+type AdvanceChapterStagesProgressEvent = {
+    readonly type: "selected";
+    readonly state: AdvanceChapterStagesProgressState;
+    readonly targetStage: ChapterStage;
+    readonly totalChapters: number;
+} | {
+    readonly type: "skipped";
+    readonly chapter: ChapterEntry;
+    readonly reason: "planned";
+    readonly targetStage: ChapterStage;
+} | {
+    readonly type: "progress";
+    readonly state: AdvanceChapterStagesProgressState;
+    readonly targetStage: ChapterStage;
+} | {
+    readonly type: "started";
+    readonly chapter: ChapterEntry;
+    readonly step: "graph" | "summary";
+    readonly targetStage: ChapterStage;
+} | {
+    readonly type: "completed";
+    readonly chapter: ChapterEntry;
+    readonly step: "graph" | "summary";
+    readonly targetStage: ChapterStage;
+};
+interface AdvanceChapterStagesResult {
+    readonly advanced: readonly ChapterEntry[];
+    readonly pending: readonly ChapterEntry[];
+    readonly skipped: readonly ChapterEntry[];
+}
+interface AddChapterOptions {
+    readonly parentChapterId?: number;
+    readonly title?: string | null | undefined;
+}
+declare function parseChapterTreeInput(input: unknown): ChapterTreeInput;
+interface GenerateChapterGraphOptions {
+    readonly extractionPrompt: string;
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly progressTracker?: SerialProgressSink;
+    readonly userLanguage?: Language;
+}
+interface GenerateChapterSummaryOptions {
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly userLanguage?: Language;
+}
+declare function advanceChapterStages(document: Document, options: AdvanceChapterStagesOptions): Promise<AdvanceChapterStagesResult>;
+declare function addChapter(document: Document, options: AddChapterOptions): Promise<ChapterDetails>;
+declare function generateChapterGraph(document: Document, chapterId: number, options: GenerateChapterGraphOptions): Promise<ChapterDetails>;
+declare function generateChapterSummary(document: Document, chapterId: number, options: GenerateChapterSummaryOptions): Promise<ChapterDetails>;
+declare function getChapterDetails(document: ReadonlyDocument, chapterId: number): Promise<ChapterDetails>;
+declare function listChapters(document: ReadonlyDocument): Promise<readonly ChapterEntry[]>;
+declare function getChapterTree(document: ReadonlyDocument): Promise<ChapterTree>;
+declare function applyChapterTree(document: Document, tree: ChapterTreeInput, options?: {
+    readonly dryRun?: boolean;
+}): Promise<ChapterTreeApplyResult>;
+declare function moveChapter(document: Document, chapterId: number, options: MoveChapterOptions): Promise<ChapterDetails>;
+declare function removeChapter(document: Document, chapterId: number, options?: {
+    readonly recursive?: boolean;
+}): Promise<void>;
+declare function resetChapter(document: Document, chapterId: number, stage: Exclude<ChapterStage, "summarized">): Promise<ChapterDetails>;
+declare function setChapterSource(document: Document, chapterId: number, stream: ReaderTextStream): Promise<ChapterDetails>;
+declare function setChapterSummary(document: Document, chapterId: number, summary: string): Promise<ChapterDetails>;
+declare function setChapterTitle(document: Document, chapterId: number, title: string | null | undefined): Promise<ChapterDetails>;
 
-interface SpineDigestSerialEntry {
+interface WikiGraphSerialEntry {
     readonly fragmentCount: number;
     readonly serialId: number;
     readonly title: string | null;
     readonly tocPath: readonly string[];
 }
 
-declare class SpineDigest {
+declare class WikiGraphArchive {
     #private;
     constructor(document: ReadonlyDocument, documentDirectoryPath: string);
     exportEpub(path: string): Promise<void>;
@@ -785,7 +1691,7 @@ declare class SpineDigest {
     readToc(): Promise<TocFile | undefined>;
     readArchiveFormatVersion(): Promise<number>;
     readChapterStage(serialId: number): Promise<ChapterStage>;
-    listSerials(): Promise<readonly SpineDigestSerialEntry[]>;
+    listSerials(): Promise<readonly WikiGraphSerialEntry[]>;
     readSerialSummary(serialId: number): Promise<string>;
     saveAs(path: string): Promise<void>;
 }
@@ -794,7 +1700,7 @@ interface DigestDocumentSessionOptions {
     readonly documentDirPath?: string;
 }
 
-interface SpineDigestLLMOptions {
+interface WikiGraphLLMOptions {
     readonly cacheDirPath?: string;
     readonly concurrent?: number;
     readonly logDirPath?: string;
@@ -806,37 +1712,938 @@ interface SpineDigestLLMOptions {
     readonly timeout?: number;
     readonly topP?: number | readonly number[];
 }
-interface SpineDigestAppOptions {
+interface WikiGraphOptions {
     readonly debugLogDirPath?: string;
-    readonly llm?: LanguageModel | SpineDigestLLMOptions;
+    readonly llm?: LanguageModel | WikiGraphLLMOptions;
     readonly verbose?: boolean;
 }
-type SpineDigestOpenSessionOptions = DigestDocumentSessionOptions;
-interface SpineDigestSourceSessionOptions extends DigestDocumentSessionOptions {
+type WikiGraphOpenSessionOptions = DigestDocumentSessionOptions;
+interface WikiGraphSourceSessionOptions extends DigestDocumentSessionOptions {
     readonly extractionPrompt?: string;
-    readonly onProgress?: SpineDigestProgressCallback;
+    readonly onProgress?: WikiGraphProgressCallback;
     readonly path: string;
     readonly targetStage?: ChapterStage;
     readonly userLanguage?: Language;
 }
-interface SpineDigestTextStreamSessionOptions extends DigestDocumentSessionOptions {
+interface WikiGraphTextStreamSessionOptions extends DigestDocumentSessionOptions {
     readonly bookLanguage?: string | null;
     readonly extractionPrompt?: string;
-    readonly onProgress?: SpineDigestProgressCallback;
+    readonly onProgress?: WikiGraphProgressCallback;
     readonly sourceFormat?: "markdown" | "txt";
     readonly stream: AsyncIterable<string> | Iterable<string>;
     readonly targetStage?: ChapterStage;
     readonly title?: string | null;
     readonly userLanguage?: Language;
 }
-declare class SpineDigestApp {
+declare class WikiGraph {
+    #private;
+    constructor(options: WikiGraphOptions);
+    digestEpubSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    digestMarkdownSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    digestTextStreamSession<T>(options: WikiGraphTextStreamSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    digestTxtSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    openSession<T>(path: string, operation: (digest: WikiGraphArchive) => Promise<T> | T, options?: WikiGraphOpenSessionOptions): Promise<T>;
+}
+
+interface GraphNode {
+    readonly content: string;
+    readonly id: number;
+    readonly importance?: ChunkImportance;
+    readonly label: string;
+    readonly retention?: ChunkRetention;
+    readonly sentenceIds: readonly SentenceId[];
+    readonly weight: number;
+    readonly wordsCount: number;
+}
+interface GraphEdge {
+    readonly fromId: number;
+    readonly strength?: string;
+    readonly toId: number;
+    readonly weight: number;
+}
+interface GraphEvidenceLine {
+    readonly sentenceId: SentenceId;
+    readonly text: string;
+}
+interface GraphStatus {
+    readonly chapterId: number;
+    readonly edgeCount: number;
+    readonly graphReady: boolean;
+    readonly nodeCount: number;
+}
+interface GraphSearchHit {
+    readonly node: GraphNode;
+    readonly matchedFields: readonly GraphSearchField[];
+}
+type GraphSearchField = "content" | "evidence" | "label";
+interface GraphNeighbor {
+    readonly direction: "incoming" | "outgoing";
+    readonly edge: GraphEdge;
+    readonly node: GraphNode;
+}
+interface GraphPathStep {
+    readonly edge?: GraphEdge;
+    readonly node: GraphNode;
+}
+declare function getGraphStatus(document: ReadonlyDocument, chapterId: number): Promise<GraphStatus>;
+declare function listGraphNodes(document: ReadonlyDocument, chapterId: number): Promise<readonly GraphNode[]>;
+declare function getGraphNode(document: ReadonlyDocument, chapterId: number, nodeId: number): Promise<GraphNode>;
+declare function searchGraphNodes(document: ReadonlyDocument, chapterId: number, pattern: string): Promise<readonly GraphSearchHit[]>;
+declare function listGraphNeighbors(document: ReadonlyDocument, chapterId: number, nodeId: number): Promise<readonly GraphNeighbor[]>;
+declare function getGraphEvidence(document: ReadonlyDocument, chapterId: number, nodeId: number): Promise<readonly GraphEvidenceLine[]>;
+declare function findGraphPath(document: ReadonlyDocument, chapterId: number, fromNodeId: number, toNodeId: number): Promise<readonly GraphPathStep[]>;
+
+declare const TEXT_SENTENCE_KIND: {
+    readonly source: 1;
+    readonly summary: 2;
+};
+type TextSentenceKind = (typeof TEXT_SENTENCE_KIND)[keyof typeof TEXT_SENTENCE_KIND];
+declare const SEARCH_OBJECT_PROPERTY_OWNER_KIND: {
+    readonly chapter: 1;
+    readonly chunk: 2;
+    readonly entity: 3;
+};
+type SearchObjectPropertyOwnerKind = (typeof SEARCH_OBJECT_PROPERTY_OWNER_KIND)[keyof typeof SEARCH_OBJECT_PROPERTY_OWNER_KIND];
+declare const SEARCH_OBJECT_PROPERTY_KIND: {
+    readonly title: 1;
+    readonly label: 1;
+    readonly content: 2;
+    readonly surface: 1;
+};
+type SearchObjectPropertyKind = (typeof SEARCH_OBJECT_PROPERTY_KIND)[keyof typeof SEARCH_OBJECT_PROPERTY_KIND];
+interface TextSentenceRecordInput {
+    readonly chapterId: number;
+    readonly kind: TextSentenceKind;
+    readonly sentenceIndex: number;
+    readonly text: string;
+    readonly wordsCount: number;
+}
+interface SearchObjectPropertyRecordInput {
+    readonly chapterId?: number;
+    readonly ownerId: string;
+    readonly ownerKind: SearchObjectPropertyOwnerKind;
+    readonly propertyKind: SearchObjectPropertyKind;
+    readonly text: string;
+}
+interface SearchIndexInput {
+    readonly objectProperties: readonly SearchObjectPropertyRecordInput[];
+    readonly textSentences: readonly TextSentenceRecordInput[];
+}
+type SearchIndexProgressPhase = "checking" | "clearing" | "collecting" | "finalizing" | "indexing-objects" | "indexing-text";
+interface SearchIndexProgressEvent {
+    readonly done?: number;
+    readonly phase: SearchIndexProgressPhase;
+    readonly total?: number;
+    readonly unit?: "chapter" | "object" | "sentence";
+}
+type SearchIndexProgressReporter = (event: SearchIndexProgressEvent) => void | Promise<void>;
+type SearchIndexStatus = "current" | "dirty" | "missing";
+interface SearchIndexTextHit {
+    readonly chapterId: number;
+    readonly kind: TextSentenceKind;
+    readonly rank: number;
+    readonly score: number;
+    readonly sentenceIndex: number;
+    readonly wordsCount: number;
+}
+interface SearchIndexObjectHit {
+    readonly chapterId?: number;
+    readonly ownerId: string;
+    readonly ownerKind: SearchObjectPropertyOwnerKind;
+    readonly propertyKind: SearchObjectPropertyKind;
+    readonly score: number;
+}
+interface SearchIndexQueryResult {
+    readonly objectHits: readonly SearchIndexObjectHit[];
+    readonly terms: readonly string[];
+    readonly textHits: readonly SearchIndexTextHit[];
+}
+declare const SEARCH_INDEX_FTS_HIT_LIMIT = 32000;
+interface ArchiveIndexSettings {
+    readonly ftsEmbedded: boolean;
+}
+declare function readArchiveIndexSettings(document: ReadonlyDocument): Promise<ArchiveIndexSettings>;
+declare function setFtsIndexEmbedded(document: Document, embedded: boolean): Promise<void>;
+declare function isSearchIndexCurrent(document: ReadonlyDocument, input?: SearchIndexInput): Promise<boolean>;
+declare function readSearchIndexStatus(document: ReadonlyDocument, input?: SearchIndexInput): Promise<SearchIndexStatus>;
+declare function ensureSearchIndex(document: Document, input: SearchIndexInput, progress?: SearchIndexProgressReporter): Promise<void>;
+declare function querySearchIndex(document: ReadonlyDocument, query: string, options?: {
+    readonly chapters?: readonly number[];
+    readonly match?: ArchiveFindMatch;
+    readonly objectHitLimit?: number;
+    readonly textAfter?: {
+        readonly chapterId: number;
+        readonly kind: TextSentenceKind;
+        readonly rank: number;
+        readonly sentenceIndex: number;
+    };
+    readonly textHitLimit?: number;
+    readonly types?: readonly ArchiveFindObjectType[] | null;
+}): Promise<SearchIndexQueryResult | undefined>;
+declare function createSearchIndexFingerprint(input: SearchIndexInput): string;
+declare function readSearchIndexFingerprintFromDatabase(database: Database): Promise<string | undefined>;
+
+type ArchiveObjectType = "chapter" | "chapter-title" | "chapter-tree" | "edge" | "entity" | "fragment" | "meta" | "node" | "source" | "state" | "summary" | "triple";
+type ChapterStateTarget = "knowledge-graph" | "reading-graph" | "reading-summary" | "source";
+type ChapterStateValue = "missing" | "ready";
+type ChapterState = Record<ChapterStateTarget, ChapterStateValue>;
+type ArchiveCollectionType = "chapter" | "chapter-title" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
+type ArchiveFindObjectType = "chapter" | "chapter-title" | "chapter-tree" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
+type ArchiveFindFilterType = "chapter" | "chapter-title" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
+interface ArchiveIndex {
+    readonly chapters: readonly ChapterEntry[];
+    readonly edgeCount: number;
+    readonly meta: BookMeta | undefined;
+    readonly nodeCount: number;
+    readonly summaryCount: number;
+}
+interface ArchiveFindHit {
+    readonly backlinks?: ArchiveBacklinks;
+    readonly chapter?: number;
+    readonly evidence?: ArchiveFindEvidencePreview;
+    readonly evidenceLinks?: readonly MentionLinkRecord[];
+    readonly evidenceMentions?: readonly EntityEvidenceMention[];
+    readonly field: ArchiveFindField;
+    readonly id: string;
+    readonly matchCount?: number;
+    readonly matchedTerms?: readonly string[];
+    readonly missingTerms?: readonly string[];
+    readonly position?: ArchiveFindPosition;
+    readonly score?: number;
+    readonly snippet: string;
+    readonly state?: ChapterState;
+    readonly title: string;
+    readonly triple?: {
+        readonly objectLabel: string;
+        readonly predicate: string;
+        readonly subjectLabel: string;
+    };
+    readonly type: ArchiveFindObjectType;
+}
+interface EntityEvidenceMention {
+    readonly match: Pick<ArchiveFindHit, "matchCount" | "matchedTerms" | "missingTerms" | "score">;
+    readonly mention: MentionRecord;
+}
+interface ArchiveFindEvidencePreview {
+    readonly nextCursor: string | null;
+    readonly shown: number;
+    readonly sources: readonly ArchiveEvidenceItem[];
+    readonly total: number;
+}
+type ArchiveFindField = "content" | "metadata" | "source" | "summary" | "title";
+interface ArchiveFindOptions {
+    readonly archiveKey?: string;
+    readonly backlinks?: boolean;
+    readonly chapters?: readonly number[];
+    readonly cursor?: string;
+    readonly evidenceLimit?: number;
+    readonly ids?: readonly string[];
+    readonly limit?: number;
+    readonly match?: ArchiveFindMatch;
+    readonly order?: ArchiveFindOrder;
+    readonly sourceContext?: number;
+    readonly triplePattern?: ArchiveTriplePattern;
+    readonly types?: readonly ArchiveFindFilterType[];
+}
+type ArchiveFindOrder = "doc-asc" | "doc-desc";
+type ArchiveFindMatch = "all" | "any";
+interface ArchiveFindPosition {
+    readonly chapter: number;
+    readonly documentOrder?: number;
+    readonly fragment?: number;
+    readonly sentence?: number;
+}
+interface ArchiveFindResult {
+    readonly chapters: readonly number[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly lens: ArchiveFindLens;
+    readonly lensHint: ArchiveFindLensHint | null;
+    readonly limit: number;
+    readonly match: ArchiveFindMatch;
+    readonly nextCursor: string | null;
+    readonly order: ArchiveFindOrder;
+    readonly query: string;
+    readonly terms: readonly string[];
+    readonly types: readonly ArchiveFindFilterType[] | null;
+}
+type ArchiveFindLens = "broad" | "exact" | "typed";
+interface ArchiveFindLensHint {
+    readonly lenses: {
+        readonly chapter: string;
+        readonly chunk: string;
+        readonly entity: string;
+        readonly node: string;
+        readonly triple: string;
+    };
+    readonly message: string;
+}
+interface ArchiveCollectionOptions {
+    readonly backlinks?: boolean;
+    readonly chapters?: readonly number[];
+    readonly cursor?: string;
+    readonly evidenceLimit?: number;
+    readonly ids?: readonly string[];
+    readonly limit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly sourceContext?: number;
+    readonly triplePattern?: ArchiveTriplePattern;
+    readonly types?: readonly ArchiveCollectionType[];
+}
+interface ArchiveTriplePattern {
+    readonly objectQid?: string;
+    readonly predicate?: string;
+    readonly subjectQid?: string;
+}
+interface ArchiveCollectionResult {
+    readonly chapters: readonly number[] | null;
+    readonly ids: readonly string[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
+    readonly order: ArchiveFindOrder;
+    readonly types: readonly ArchiveCollectionType[] | null;
+}
+interface ArchiveBacklinks {
+    readonly chunks: ArchiveBacklinkBucket;
+    readonly entities: ArchiveBacklinkBucket;
+    readonly triples: ArchiveBacklinkBucket;
+}
+interface ArchiveBacklinkBucket {
+    readonly items: readonly ArchiveFindHit[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
+}
+type ArchiveListKind = "chapters" | "edges" | "fragments" | "meta" | "nodes" | "summaries";
+type ArchiveListItem = {
+    readonly evidence?: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly score?: number;
+    readonly state?: ChapterState;
+    readonly summary: string;
+    readonly type: Exclude<ArchiveObjectType, "triple">;
+} | {
+    readonly evidence?: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly evidenceLinks?: readonly MentionLinkRecord[];
+    readonly objectLabel: string;
+    readonly objectQid: string;
+    readonly predicate: string;
+    readonly score?: number;
+    readonly subjectLabel: string;
+    readonly subjectQid: string;
+    readonly summary: string;
+    readonly type: "triple";
+};
+type ArchivePage = {
+    readonly id: string;
+    readonly state: ChapterState;
+    readonly title: string;
+    readonly type: "chapter";
+} | {
+    readonly id: string;
+    readonly title: string;
+    readonly type: "chapter-title";
+} | {
+    readonly id: string;
+    readonly title: string;
+    readonly tree: ChapterTree;
+    readonly type: "chapter-tree";
+} | {
+    readonly generatedNodeSummary: string;
+    readonly id: string;
+    readonly incoming: readonly GraphNeighbor[];
+    readonly neighbors: readonly GraphNeighbor[];
+    readonly outgoing: readonly GraphNeighbor[];
+    readonly position: ArchiveFindPosition | undefined;
+    readonly sourceFragments: readonly ArchiveNodeSourceFragment[];
+    readonly title: string;
+    readonly type: "node";
+} | {
+    readonly backlinks?: ArchiveBacklinks;
+    readonly fragment: ArchiveSourceFragment;
+    readonly id: string;
+    readonly nextFragmentId: string | undefined;
+    readonly nodes: readonly ArchiveNodeLabel[];
+    readonly previousFragmentId: string | undefined;
+    readonly title: string;
+    readonly type: "fragment";
+} | {
+    readonly content: string;
+    readonly id: string;
+    readonly title: string;
+    readonly type: "summary";
+} | {
+    readonly evidence: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly labels: readonly string[];
+    readonly mentionCount: number;
+    readonly qid: string;
+    readonly type: "entity";
+} | {
+    readonly en: ArchiveEntityWikipageLocale | null;
+    readonly id: string;
+    readonly type: "entity-wikipage";
+    readonly zh: ArchiveEntityWikipageLocale | null;
+} | {
+    readonly evidence: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly objectQid: string;
+    readonly predicate: string;
+    readonly subjectQid: string;
+    readonly type: "triple";
+} | {
+    readonly authors?: readonly string[];
+    readonly description?: string;
+    readonly id: string;
+    readonly publisher?: string;
+    readonly title: string;
+    readonly type: "meta";
+} | {
+    readonly id: string;
+    readonly state: ChapterState;
+    readonly type: "state";
+} | {
+    readonly id: string;
+    readonly target: ChapterStateTarget;
+    readonly type: "state";
+    readonly value: ChapterStateValue;
+};
+interface ArchiveEntityWikipageLocale {
+    readonly description?: string;
+    readonly title: string;
+    readonly url: string;
+}
+interface ArchivePack {
+    readonly anchor: ArchivePage;
+    readonly budget: number;
+    readonly related: readonly ArchiveListItem[];
+}
+type ArchiveRelatedRole = "any" | "object" | "self" | "subject";
+interface ArchiveRelatedOptions {
+    readonly cursor?: string;
+    readonly evidenceLimit?: number;
+    readonly limit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly query?: string;
+    readonly role?: ArchiveRelatedRole;
+    readonly sourceContext?: number;
+}
+interface ArchiveRelatedResult {
+    readonly items: readonly ArchiveListItem[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
+}
+interface ArchiveEvidence {
+    readonly items: readonly ArchiveEvidenceItem[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
+}
+interface ArchiveEvidenceItem {
+    readonly chapterId: number;
+    readonly endSentenceIndex: number;
+    readonly fragmentId?: number;
+    readonly id: string;
+    readonly score?: number;
+    readonly source: string;
+    readonly startSentenceIndex: number;
+    readonly title: string;
+    readonly type: "source";
+}
+interface ArchiveNodeLabel {
+    readonly id: string;
+    readonly title: string;
+}
+interface ArchiveSourceFragment {
+    readonly fragmentId?: number;
+    readonly id: string;
+    readonly preview: string;
+    readonly sentenceCount: number;
+    readonly text: string;
+    readonly wordsCount: number;
+}
+interface ArchiveNodeSourceFragment {
+    readonly id: string;
+    readonly text: string;
+    readonly truncated: boolean;
+}
+interface ArchiveEvidenceOptions {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly query?: string;
+    readonly sourceContext?: number;
+}
+interface ArchivePageOptions {
+    readonly backlinks?: boolean;
+    readonly evidenceLimit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly sourceContext?: number;
+    readonly wikipageResolverOptions?: WikipageResolverOptions;
+}
+declare function getArchiveIndex(document: ReadonlyDocument): Promise<ArchiveIndex>;
+declare function listArchiveObjects(document: ReadonlyDocument, kind: ArchiveListKind): Promise<readonly ArchiveListItem[]>;
+declare function listArchiveCollection(document: ReadonlyDocument, options?: ArchiveCollectionOptions): Promise<ArchiveCollectionResult>;
+declare function findArchiveObjects(document: ReadonlyDocument, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
+declare function rebuildArchiveSearchIndex(document: Document, progress?: SearchIndexProgressReporter): Promise<void>;
+declare function isArchiveSearchIndexCurrent(document: ReadonlyDocument): Promise<boolean>;
+declare function readArchiveSearchIndexStatus(document: ReadonlyDocument): Promise<"current" | "dirty" | "missing">;
+declare function clearDirtyArchiveSearchIndex(document: Document): Promise<void>;
+declare function createArchiveSearchIndexFingerprint(document: ReadonlyDocument): Promise<string>;
+declare function grepArchiveObjects(document: ReadonlyDocument, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
+declare function readArchiveText(document: ReadonlyDocument, id: string): Promise<string>;
+declare function readArchivePage(document: ReadonlyDocument, id: string, options?: ArchivePageOptions): Promise<ArchivePage>;
+declare function listArchiveLinks(document: ReadonlyDocument, id: string, direction: "backlinks" | "links"): Promise<readonly GraphNeighbor[]>;
+declare function listAllArchiveLinks(document: ReadonlyDocument, id: string): Promise<readonly GraphNeighbor[]>;
+declare function listRelatedArchiveObjects(document: ReadonlyDocument, id: string, options?: ArchiveRelatedOptions): Promise<ArchiveRelatedResult>;
+declare function listArchiveEvidence(document: ReadonlyDocument, uri: string, options?: ArchiveEvidenceOptions): Promise<ArchiveEvidence>;
+declare function packArchiveContext(document: ReadonlyDocument, id: string, budget: number): Promise<ArchivePack>;
+declare function formatChapterId(chapterId: number): string;
+declare function formatEdgeId(edge: ReadingEdgeRecord): string;
+declare function formatNodeId(nodeId: number): string;
+declare function formatSummaryId(chapterId: number): string;
+
+type ContinuationCursor = {
+    readonly archiveKey: string;
+    readonly archivePath: string;
+    readonly backlinks?: boolean;
+    readonly chapters: readonly number[] | null;
+    readonly cursor: string;
+    readonly evidenceLimit?: number;
+    readonly format: "json" | "jsonl" | "text";
+    readonly ids: readonly string[] | null;
+    readonly kind: "collection";
+    readonly order: "doc-asc" | "doc-desc";
+    readonly sourceContext?: number;
+    readonly triplePattern?: {
+        readonly objectQid?: string;
+        readonly predicate?: string;
+        readonly subjectQid?: string;
+    };
+    readonly types: readonly string[] | null;
+} | {
+    readonly archiveKey: string;
+    readonly archivePath: string;
+    readonly backlinks?: boolean;
+    readonly cursor: string;
+    readonly evidenceLimit?: number;
+    readonly format: "json" | "jsonl" | "text";
+    readonly kind: "search";
+    readonly query?: string;
+    readonly sourceContext?: number;
+    readonly triplePattern?: {
+        readonly objectQid?: string;
+        readonly predicate?: string;
+        readonly subjectQid?: string;
+    };
+    readonly types: readonly string[] | null;
+} | {
+    readonly archiveKey: string;
+    readonly archivePath: string;
+    readonly cursor: string;
+    readonly format: "json" | "jsonl" | "text";
+    readonly kind: "evidence";
+    readonly order: "doc-asc" | "doc-desc";
+    readonly query?: string;
+    readonly sourceContext?: number;
+    readonly targetUri: string;
+} | {
+    readonly archiveKey: string;
+    readonly archivePath: string;
+    readonly cursor: string;
+    readonly evidenceLimit?: number;
+    readonly format: "json" | "jsonl" | "text";
+    readonly kind: "related";
+    readonly order: "doc-asc" | "doc-desc";
+    readonly query?: string;
+    readonly role?: "any" | "object" | "self" | "subject";
+    readonly sourceContext?: number;
+    readonly targetUri: string;
+};
+declare function createContinuationCursor(input: ContinuationCursor): Promise<string>;
+declare function readContinuationCursor(cursorId: string): Promise<ContinuationCursor>;
+
+interface SearchSessionInput {
+    readonly archiveKey: string;
+    readonly chapters: readonly number[] | null;
+    readonly chunkHits?: readonly SearchChunkHitInput[];
+    readonly entityHits?: readonly SearchEntityHitInput[];
+    readonly evidenceEvents?: readonly SearchEvidenceHitEventInput[];
+    readonly items?: readonly ArchiveFindHit[];
+    readonly lens: string;
+    readonly match: string;
+    readonly order: string;
+    readonly query: string;
+    readonly revisionScope: string;
+    readonly terms: readonly string[];
+    readonly tripleHits?: readonly SearchTripleHitInput[];
+    readonly types: readonly string[] | null;
+}
+declare const SEARCH_EVIDENCE_KIND: {
+    readonly mention: 1;
+    readonly mentionLink: 2;
+    readonly chunk: 3;
+};
+type SearchEvidenceKind = (typeof SEARCH_EVIDENCE_KIND)[keyof typeof SEARCH_EVIDENCE_KIND];
+interface SearchEvidenceHitEventInput {
+    readonly chapterId: number;
+    readonly evidenceId: string;
+    readonly evidenceKind: SearchEvidenceKind;
+    readonly score: number;
+    readonly sentenceIndex: number;
+}
+interface SearchEntityHitInput {
+    readonly evidenceTopScores?: readonly number[];
+    readonly propertyTopScores?: readonly number[];
+    readonly qid: string;
+}
+interface SearchTripleHitInput {
+    readonly evidenceTopScores: readonly number[];
+    readonly objectQid: string;
+    readonly predicate: string;
+    readonly subjectQid: string;
+}
+interface SearchChunkHitInput {
+    readonly chunkId: number;
+    readonly evidenceTopScores?: readonly number[];
+    readonly propertyTopScores?: readonly number[];
+}
+interface SearchSessionPage {
+    readonly chapters: readonly number[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly lens: string;
+    readonly match: string;
+    readonly nextCursor: string | null;
+    readonly query: string;
+    readonly sessionId: string;
+    readonly terms: readonly string[];
+    readonly types: readonly string[] | null;
+}
+interface SearchSessionDescriptor {
+    readonly chapters: readonly number[] | null;
+    readonly createdAt: number;
+    readonly lens: string;
+    readonly match: string;
+    readonly objectCachesPopulated: boolean;
+    readonly query: string;
+    readonly sessionId: string;
+    readonly terms: readonly string[];
+    readonly types: readonly string[] | null;
+}
+type SearchSessionCacheInput = Omit<SearchSessionInput, "items">;
+declare function readCachedSearchSessionPage(input: SearchSessionCacheInput, offset: number, limit: number): Promise<SearchSessionPage | undefined>;
+declare function createSearchSession(input: SearchSessionInput): Promise<string>;
+declare function deleteArchiveSearchSessions(archiveKey: string): Promise<void>;
+declare function runSearchCacheGc(context: GcContext): Promise<GcJobResult>;
+
+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 addBuildJob(options: AddBuildJobOptions): Promise<BuildJob>;
+declare function recordBuildJobInputRevision(input: {
+    readonly currentRevision: number;
+    readonly jobId: string;
+    readonly ownerId: string;
+}): Promise<BuildJob>;
+declare function assertBuildJobInputRevision(input: {
+    readonly currentRevision: number;
+    readonly jobId: string;
+    readonly ownerId: string;
+}): Promise<void>;
+declare function listBuildJobs(options?: BuildJobListOptions): Promise<BuildJob[]>;
+declare function getBuildJob(jobId: string): Promise<BuildJob>;
+declare function resolveBuildJobId(jobIdPrefix: string): Promise<string>;
+declare function pauseBuildJob(jobId: string): Promise<BuildJob>;
+declare function resumeBuildJob(jobId: string): Promise<BuildJob>;
+declare function cancelBuildJob(jobId: string): Promise<BuildJob>;
+declare function boostBuildJob(jobId: string): Promise<BuildJob>;
+declare function updateBuildJobTarget(jobId: string, target: BuildJobTarget): Promise<BuildJob>;
+declare function assertNoActiveBuildJobs(input: {
+    readonly archivePath: string;
+    readonly chapterIds: readonly number[];
+    readonly operation: string;
+    readonly requiresTarget?: BuildJobTarget;
+}): Promise<void>;
+declare function assertNoActiveBuildJobConflicts(input: {
+    readonly archivePath: string;
+    readonly operation: string;
+    readonly requiresTarget?: BuildJobTarget;
+    readonly scope: BuildJobConflictScope;
+}): Promise<void>;
+declare function runBuildJobWorker(options: BuildJobWorkerOptions): Promise<void>;
+declare function readBuildJobEvents(job: Pick<BuildJob, "eventsPath">): Promise<BuildJobEvent[]>;
+declare function cleanBuildJobs(options?: {
+    readonly olderThanMs?: number;
+    readonly states?: readonly BuildJobState[];
+}): Promise<number>;
+declare function runBuildQueueGc(context: GcContext): Promise<GcJobResult>;
+
+interface ChapterGraphBuildArtifact {
+    readonly documentPath: string;
+    readonly chapterId: number;
+    readonly parameter: GraphBuildParameterInput$1;
+}
+interface GraphBuildParameterInput$1 {
+    readonly language?: string;
+    readonly prompt: string;
+}
+interface ChapterSummaryInputSnapshot {
+    readonly filePath: string;
+}
+interface BuildChapterGraphArtifactOptions extends GenerateChapterGraphOptions {
+    readonly sourceText: readonly string[];
+    readonly workspacePath: string;
+}
+interface BuildChapterSummaryArtifactOptions extends GenerateChapterSummaryOptions {
+    readonly snapshotPath?: string;
+    readonly sourceDocumentPath?: string;
+    readonly workspacePath: string;
+}
+declare function readChapterBuildInput(document: ReadonlyDocument, chapterId: number): Promise<{
+    readonly details: ChapterDetails;
+    readonly revision: number;
+    readonly sourceText: readonly string[];
+}>;
+declare function buildChapterGraphArtifact(chapterId: number, options: BuildChapterGraphArtifactOptions): Promise<ChapterGraphBuildArtifact>;
+declare function commitChapterGraphArtifact(document: Document, artifact: ChapterGraphBuildArtifact): Promise<ChapterDetails>;
+declare function buildChapterSummaryArtifact(document: ReadonlyDocument, chapterId: number, options: BuildChapterSummaryArtifactOptions): Promise<string>;
+declare function buildChapterSummaryArtifactFromSnapshot(chapterId: number, options: BuildChapterSummaryArtifactOptions & {
+    readonly snapshotPath: string;
+}): Promise<string>;
+declare function commitChapterSummaryArtifact(document: Document, chapterId: number, summary: string): Promise<ChapterDetails>;
+declare function snapshotChapterSummaryInput(document: ReadonlyDocument, chapterId: number, workspacePath: string): Promise<ChapterSummaryInputSnapshot>;
+
+interface ChapterKnowledgeGraphBuildArtifact {
+    readonly chapterId: number;
+    readonly mentionLinksPath: string;
+    readonly mentionsPath: string;
+    readonly parameter: GraphBuildParameterInput;
+    readonly workspacePath: string;
+}
+interface ChapterKnowledgeGraphInputSnapshot {
+    readonly details: ChapterDetails;
+    readonly fragments: readonly FragmentRecord[];
+}
+interface GraphBuildParameterInput {
+    readonly language?: string;
+    readonly prompt: string;
+}
+interface BuildChapterKnowledgeGraphArtifactOptions {
+    readonly mentionLinks: AsyncIterable<MentionLinkRecord> | Iterable<MentionLinkRecord>;
+    readonly mentions: AsyncIterable<MentionRecord> | Iterable<MentionRecord>;
+    readonly parameter?: GraphBuildParameterInput;
+    readonly workspacePath: string;
+}
+interface GenerateChapterKnowledgeGraphArtifactOptions {
+    readonly policyPrompt: string;
+    readonly progressTracker?: Pick<BuildJobProgressReporter, "throwIfStopped" | "updatePhase">;
+    readonly request: GuaranteedRequestController;
+    readonly resolverOptions?: Omit<WikipageResolverOptions, "progress">;
+    readonly wikispine?: Pick<MatchWikispineSentenceCandidatesOptions, "command" | "dataDir" | "endpoint" | "provider">;
+    readonly workspacePath: string;
+}
+declare function generateChapterKnowledgeGraphArtifact(document: ReadonlyDocument, chapterId: number, options: GenerateChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
+declare function snapshotChapterKnowledgeGraphInput(document: ReadonlyDocument, chapterId: number): Promise<ChapterKnowledgeGraphInputSnapshot>;
+declare function generateChapterKnowledgeGraphArtifactFromSnapshot(chapterId: number, snapshot: ChapterKnowledgeGraphInputSnapshot, options: GenerateChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
+declare function buildChapterKnowledgeGraphArtifact(chapterId: number, options: BuildChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
+declare function groundWikimatchCandidates(input: {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly policyPrompt: string;
+    readonly progressTracker?: Pick<BuildJobProgressReporter, "throwIfStopped" | "updatePhase">;
+    readonly request: GuaranteedRequestController;
+    readonly text: string;
+}): Promise<readonly WikimatchAcceptedMention[]>;
+declare function createEnrichmentProgressReporter(progressTracker: Pick<BuildJobProgressReporter, "throwIfStopped" | "updatePhase">): (event: WikipageResolveProgress) => Promise<void>;
+declare function commitChapterKnowledgeGraphArtifact(document: Document, artifact: ChapterKnowledgeGraphBuildArtifact): Promise<void>;
+declare function clearChapterKnowledgeGraph(document: Document, chapterId: number): Promise<void>;
+
+declare function writeWikgArchive(documentDirectoryPath: string, outputPath: string): Promise<void>;
+declare function readWikgArchiveFormatVersion(documentDirectoryPath: string): Promise<number>;
+
+declare const WIKI_GRAPH_URI_PREFIX = "wikg://";
+declare const WIKI_GRAPH_JOB_URI_PREFIX = "wikg://local/job";
+interface LocatedWikiGraphUri {
+    readonly archivePath?: string;
+    readonly objectUri?: string;
+}
+declare function isWikiGraphUri(value: string | undefined): value is string;
+declare function isWikiGraphJobUri(value: string | undefined): value is string;
+declare function parseLocatedWikiGraphUri(uri: string): LocatedWikiGraphUri;
+declare function formatLocatedWikiGraphUri(archivePath: string, objectUri?: string): string;
+declare function formatWikiGraphCommandUri(archivePath: string, objectUri?: string, cwd?: string): string;
+declare function formatLocatedChapterUri(archivePath: string, chapterId: number): string;
+declare function formatLocatedChapterResourceUri(archivePath: string, chapterId: number, resource: "source" | "summary" | "title"): string;
+declare function formatLocatedChapterSourceCollectionUri(archivePath: string, chapterId: number): string;
+declare function requireArchiveUri(uri: string): string;
+declare function requireLocatedObjectUri(uri: string): {
+    readonly archivePath: string;
+    readonly objectUri: string;
+};
+declare function requireLocatedObjectOrArchiveUri(uri: string): {
+    readonly archivePath: string;
+    readonly objectUri?: string;
+};
+
+declare class WikiGraphArchiveFile {
     #private;
-    constructor(options: SpineDigestAppOptions);
-    digestEpubSession<T>(options: SpineDigestSourceSessionOptions, operation: (digest: SpineDigest) => Promise<T> | T): Promise<T>;
-    digestMarkdownSession<T>(options: SpineDigestSourceSessionOptions, operation: (digest: SpineDigest) => Promise<T> | T): Promise<T>;
-    digestTextStreamSession<T>(options: SpineDigestTextStreamSessionOptions, operation: (digest: SpineDigest) => Promise<T> | T): Promise<T>;
-    digestTxtSession<T>(options: SpineDigestSourceSessionOptions, operation: (digest: SpineDigest) => Promise<T> | T): Promise<T>;
-    openSession<T>(path: string, operation: (digest: SpineDigest) => Promise<T> | T, options?: SpineDigestOpenSessionOptions): Promise<T>;
+    constructor(path: string);
+    read<T>(operation: (digest: WikiGraphArchive) => Promise<T> | T, options?: {
+        readonly documentDirPath?: string;
+    }): Promise<T>;
+    readDocument<T>(operation: (document: DirectoryDocument, directoryPath: string) => Promise<T> | T, options?: {
+        readonly documentDirPath?: string;
+        readonly searchIndexWritebackPolicy?: "archive" | "cache";
+    }): Promise<T>;
+    write<T>(operation: (document: DirectoryDocument) => Promise<T> | T, options?: {
+        readonly searchIndexWritebackPolicy?: "archive" | "cache";
+    }): Promise<T>;
 }
 
-export { type BuildWikimatchWindowsOptions, type CachedDisambiguationRecord, type CachedPageRecord, type CachedQidRecord, type DigestProgressEvent, type DisambiguationExpansion, type DisambiguationLinkedQid, type DisambiguationMeaningPriority, type DisambiguationPageText, type DisambiguationProfile, type DisambiguationProfileMeaning, type DisambiguationProfileNormalizer, type DisambiguationProfileNormalizerInput, EVIDENCE_SELECTION_JSON_SHAPE, EVIDENCE_SELECTION_PROMPT_FRAGMENT, type EvidenceQuoteMatchStrategy, type EvidenceQuoteScore, type EvidenceSelection, type EvidenceSelectionCandidate, type EvidenceSelectionFailure, type EvidenceSelectionList, type EvidenceSelectionResolution, type EvidenceSelectionSentence, type EvidenceSentenceId, type JudgeWikimatchPolicyOptions, LLMPaymentRequiredError, Language, LanguageCode, type QidResolution, RateLimiter, SPINE_DIGEST_CONTEXT_VERSION, type SerialDiscoveryItem, type SerialProgressEvent, type SerialsDiscoveredEvent, SpineDigest, SpineDigestApp, type SpineDigestAppOptions, type SpineDigestLLMOptions, type SpineDigestOpenSessionOptions, type SpineDigestOperation, type SpineDigestProgressCallback, type SpineDigestProgressEvent, type SpineDigestProgressEventType, type SpineDigestSerialEntry, type SpineDigestSourceSessionOptions, SpineDigestTask, SpineDigestTaskContext, type SpineDigestTaskContextOptions, type SpineDigestTaskIdentity, type SpineDigestTaskType, type SpineDigestTextStreamSessionOptions, type WikimatchAcceptedMention, type WikimatchCandidate, type WikimatchConflictGroup, type WikimatchPolicyDecision, type WikimatchPolicyDecisionOutput, type WikimatchPolicyFallback, type WikimatchPolicyJudgeInput, type WikimatchPolicyJudgeResult, type WikimatchPolicyResponse, type WikimatchPolicyUpdate, type WikimatchQidOption, type WikimatchTextRange, type WikimatchWindow, WikimediaClient, WikipageCache, WikipageResolver, type WikipageResolverOptions, type WikipageSitelink, buildWikimatchWindows, createDisambiguationProfileNormalizer, createSpineDigestTaskId, formatEvidenceSelectionChoicePrompt, formatLanguageForPrompt, getLanguageCode, getWikipageLanguageCode, judgeWikimatchPolicy, normalizeEvidenceDisplayText, normalizeEvidenceText, normalizeLanguageCode, parsePolicyResponse, parseRetryAfterMs, rankEvidenceQuote, resolveEvidenceSelection, resolveEvidenceSelectionList, scoreEvidenceQuote, validatePolicyResponse };
+interface LegacySdpubMigrationResult {
+    readonly inputPath: string;
+    readonly outputPath: string;
+}
+declare function migrateLegacySdpubToWikg(inputPath: string, outputPath?: string): Promise<LegacySdpubMigrationResult>;
+
+declare function formatError(error: unknown): string;
+
+export { type AddBuildJobOptions, type AddChapterOptions, type AdvanceChapterStagesOptions, type AdvanceChapterStagesProgressCallback, type AdvanceChapterStagesProgressEvent, type AdvanceChapterStagesResult, type ArchiveBacklinkBucket, type ArchiveBacklinks, type ArchiveCollectionOptions, type ArchiveCollectionResult, type ArchiveCollectionType, type ArchiveEvidence, type ArchiveEvidenceItem, type ArchiveFindEvidencePreview, type ArchiveFindField, type ArchiveFindFilterType, type ArchiveFindHit, type ArchiveFindObjectType, type ArchiveFindOptions, type ArchiveFindOrder, type ArchiveFindPosition, type ArchiveFindResult, type ArchiveIndex, type ArchiveIndexSettings, type ArchiveListItem, type ArchiveListKind, type ArchiveNodeLabel, type ArchiveNodeSourceFragment, type ArchiveObjectType, type ArchivePack, type ArchivePage, type ArchiveRelatedResult, type ArchiveTriplePattern, type BookMeta, type BuildChapterGraphArtifactOptions, type BuildChapterKnowledgeGraphArtifactOptions, type BuildChapterSummaryArtifactOptions, type BuildJob, type BuildJobConflictScope, type BuildJobEvent, type BuildJobExecutionContext, type BuildJobListOptions, type BuildJobProgressCounter, type BuildJobProgressReporter, type BuildJobState, type BuildJobTarget, type BuildJobWorkerOptions, type BuildWikimatchSurfaceProtectionInputOptions, type BuildWikimatchWindowsOptions, CHAPTER_STAGES, CLI_FULL_COMMAND, CLI_PRIMARY_COMMAND, type CachedDisambiguationRecord, type CachedPageRecord, type CachedQidRecord, type ChapterDetails, type ChapterEntry, type ChapterGraphBuildArtifact, type ChapterKnowledgeGraphBuildArtifact, type ChapterKnowledgeGraphInputSnapshot, type ChapterStage, type ChapterTree, type ChapterTreeApplyResult, type ChapterTreeInput, type ChapterTreeInputNode, type ChapterTreeMoveChange, type ChapterTreeNode, type ChapterTreeTitleChange, ChunkImportance, type ChunkRecord, ChunkRetention, ChunkStore, type ContinuationCursor, type CreateSnakeRecord, DEFAULT_WIKISPINE_FETCH_ENDPOINT, Database, type DigestProgressEvent, DirectoryDocument, type DisambiguationExpansion, type DisambiguationLinkedQid, type DisambiguationMeaningPriority, type DisambiguationPageText, type DisambiguationProfile, type DisambiguationProfileMeaning, type DisambiguationProfileNormalizer, type DisambiguationProfileNormalizerInput, type Document, type DocumentContext, EVIDENCE_SELECTION_JSON_SHAPE, EVIDENCE_SELECTION_PROMPT_FRAGMENT, type EvidenceQuoteMatchStrategy, type EvidenceQuoteScore, type EvidenceSelection, type EvidenceSelectionCandidate, type EvidenceSelectionFailure, type EvidenceSelectionList, type EvidenceSelectionResolution, type EvidenceSelectionSentence, type EvidenceSentenceId, FragmentDraft, FragmentGroupStore, type FragmentRecord, Fragments, type GenerateChapterGraphOptions, type GenerateChapterSummaryOptions, type GraphBuildParameterRecord, GraphBuildParameterStore, type GraphEdge, type GraphEvidenceLine, type GraphNeighbor, type GraphNode, type GraphPathStep, type GraphSearchField, type GraphSearchHit, type GraphStatus, type GuaranteedRequest, type GuaranteedRequestController, type JudgeWikimatchPolicyOptions, type JudgeWikimatchSurfaceProtectionOptions, LLM, type LLMOptions, LLMPaymentRequiredError, type LLMRequestOptions, type LLMStreamProgressCallback, type LLMTokenUsage, type LLMTokenUsageCallback, type LLMessage, Language, LanguageCode, type LocatedWikiGraphUri, type MatchWikispineSentenceCandidatesOptions, type MentionLinkRecord, MentionLinkStore, type MentionRecord, MentionStore, type MoveChapterOptions, type NarrowWikimatchCandidateOptionsInput, type NarrowWikimatchCandidateOptionsOptions, ObjectMetadataKind, ObjectMetadataStore, type ObjectMetadataTarget, type QidResolution, RateLimiter, type ReadingEdgeRecord, ReadingEdgeStore, type ReadonlyChunkStore, type ReadonlyDocument, type ReadonlyFragmentGroupStore, type ReadonlyTextStreams as ReadonlyFragments, type ReadonlyGraphBuildParameterStore, type ReadonlyMentionLinkStore, type ReadonlyMentionStore, type ReadonlyObjectMetadataStore, type ReadonlyReadingEdgeStore, type ReadonlySerialTextStream as ReadonlySerialFragments, type ReadonlySerialStore, type ReadonlySerialTextStream, type ReadonlySnakeChunkStore, type ReadonlySnakeEdgeStore, type ReadonlySnakeStore, type ReadonlyTextStreams, SCHEMA_SQL, SEARCH_INDEX_FTS_HIT_LIMIT, SEARCH_OBJECT_PROPERTY_KIND, SEARCH_OBJECT_PROPERTY_OWNER_KIND, type SearchIndexInput, type SearchIndexObjectHit, type SearchIndexProgressEvent, type SearchIndexProgressPhase, type SearchIndexProgressReporter, type SearchIndexQueryResult, type SearchIndexStatus, type SearchIndexTextHit, type SearchObjectPropertyKind, type SearchObjectPropertyOwnerKind, type SearchSessionDescriptor, type SearchSessionInput, type SearchSessionPage, type SentenceGroupRecord, type SentenceId, type SentenceRecord, type SerialDiscoveryItem, SerialFragments, type SerialProgressEvent, type SerialRecord, SerialStore, SerialTextStream, type SerialsDiscoveredEvent, type SnakeChunkRecord, SnakeChunkStore, type SnakeEdgeRecord, SnakeEdgeStore, type SnakeRecord, SnakeStore, TEXT_SENTENCE_KIND, TOC_FILE_VERSION, type TestWikispineRuntimeOptions, type TextSentenceKind, TextStreams, WIKI_GRAPH_CONTEXT_VERSION, WIKI_GRAPH_EDITOR_SCOPES, WIKI_GRAPH_JOB_URI_PREFIX, WIKI_GRAPH_READER_SCOPES, WIKI_GRAPH_SCOPES, WIKI_GRAPH_URI_PREFIX, WikiGraph, WikiGraphArchive, WikiGraphArchiveFile, type WikiGraphLLMOptions, type WikiGraphOpenSessionOptions, type WikiGraphOperation, type WikiGraphOptions, type WikiGraphProgressCallback, type WikiGraphProgressEvent, type WikiGraphProgressEventType, WikiGraphScope, type WikiGraphSerialEntry, type WikiGraphSourceSessionOptions, WikiGraphTask, WikiGraphTaskContext, type WikiGraphTaskContextOptions, type WikiGraphTaskIdentity, type WikiGraphTaskType, type WikiGraphTextStreamSessionOptions, type WikimatchAcceptedMention, type WikimatchCandidate, type WikimatchCandidateOptionNarrowingFallback, type WikimatchCandidateOptionNarrowingItemOutput, type WikimatchCandidateOptionNarrowingResponse, type WikimatchCandidateOptionNarrowingResult, type WikimatchConflictGroup, type WikimatchPolicyContinuation, type WikimatchPolicyDecision, type WikimatchPolicyDecisionOutput, type WikimatchPolicyFallback, type WikimatchPolicyJudgeInput, type WikimatchPolicyJudgeResult, type WikimatchPolicyResponse, type WikimatchPolicyUpdate, type WikimatchProtectedSurface, type WikimatchQidOption, type WikimatchSentence, type WikimatchSurface, type WikimatchSurfaceProtectionBuildResult, type WikimatchSurfaceProtectionFallback, type WikimatchSurfaceProtectionInput, type WikimatchSurfaceProtectionResponse, type WikimatchSurfaceProtectionResult, type WikimatchTextRange, type WikimatchWindow, WikimediaClient, WikipageCache, WikipageResolver, type WikipageResolverOptions, type WikipageSitelink, type WikispineProvider, type WikispineRuntimeTestResult, addBuildJob, addChapter, advanceChapterStages, applyChapterTree, applyQidResolutions, assertBuildJobInputRevision, assertNoActiveBuildJobConflicts, assertNoActiveBuildJobs, boostBuildJob, buildChapterGraphArtifact, buildChapterKnowledgeGraphArtifact, buildChapterSummaryArtifact, buildChapterSummaryArtifactFromSnapshot, buildWikimatchSurfaceProtectionInput, buildWikimatchWindows, cancelBuildJob, cleanBuildJobs, clearChapterKnowledgeGraph, clearDirtyArchiveSearchIndex, commitChapterGraphArtifact, commitChapterKnowledgeGraphArtifact, commitChapterSummaryArtifact, countWikimatchCandidateOptions, countWikimatchQidOption, createArchiveSearchIndexFingerprint, createContinuationCursor, createDefaultWikiGraphSampling, createDisambiguationProfileNormalizer, createEnrichmentProgressReporter, createEnv, createSearchIndexFingerprint, createSearchSession, createWikiGraphTaskId, createWikiGraphTempDirectory, deleteArchiveSearchSessions, enrichWikimatchCandidates, ensureSearchIndex, ensureSharedStateDatabaseInitialized, expandRangeByWords, expectChunkImportance, expectChunkRetention, filterCandidateQidOptions, findArchiveObjects, findGraphPath, formatCandidateForPrompt, formatChapterId, formatEdgeId, formatError, formatEvidenceSelectionChoicePrompt, formatLanguageForPrompt, formatLocatedChapterResourceUri, formatLocatedChapterSourceCollectionUri, formatLocatedChapterUri, formatLocatedWikiGraphUri, formatNodeId, formatSummaryId, formatWikiGraphCommandUri, generateChapterGraph, generateChapterKnowledgeGraphArtifact, generateChapterKnowledgeGraphArtifactFromSnapshot, generateChapterSummary, getArchiveIndex, getBuildJob, getChapterDetails, getChapterTree, getGraphEvidence, getGraphNode, getGraphStatus, getLanguageCode, getWikipageLanguageCode, grepArchiveObjects, groundWikimatchCandidates, isArchiveSearchIndexCurrent, isChunkImportance, isChunkRetention, isSearchIndexCurrent, isWikiGraphJobUri, isWikiGraphUri, judgeWikimatchPolicy, judgeWikimatchSurfaceProtection, listAllArchiveLinks, listArchiveCollection, listArchiveEvidence, listArchiveLinks, listArchiveObjects, listBuildJobs, listCandidateSelectableQids, listChapters, listGraphNeighbors, listGraphNodes, listRelatedArchiveObjects, listWordBoundaries, matchWikispineSentenceCandidates, migrateLegacySdpubToWikg, moveChapter, narrowWikimatchCandidateOptions, normalizeEvidenceDisplayText, normalizeEvidenceText, normalizeLanguageCode, openSharedStateDatabase, packArchiveContext, parseChapterTreeInput, parseLocatedWikiGraphUri, parseNarrowingResponse, parsePolicyResponse, parseRetryAfterMs, parseSurfaceProtectionResponse, pauseBuildJob, querySearchIndex, rankEvidenceQuote, readArchiveIndexSettings, readArchivePage, readArchiveSearchIndexStatus, readArchiveText, readBuildJobEvents, readCachedSearchSessionPage, readChapterBuildInput, readContinuationCursor, readSearchIndexFingerprintFromDatabase, readSearchIndexStatus, readWikgArchiveFormatVersion, rebuildArchiveSearchIndex, recordBuildJobInputRevision, removeChapter, requireArchiveUri, requireLocatedObjectOrArchiveUri, requireLocatedObjectUri, resetChapter, resolveBuildJobId, resolveDataDirPath, resolveEvidenceSelection, resolveEvidenceSelectionList, resolveWikiGraphCoreDatabasePath, resolveWikiGraphHomeDirectoryPath, resolveWikiGraphStateRootPath, resumeBuildJob, runBuildJobWorker, runBuildQueueGc, runSearchCacheGc, scoreEvidenceQuote, searchGraphNodes, setChapterSource, setChapterSummary, setChapterTitle, setFtsIndexEmbedded, sliceCandidateByOptionBudget, snapshotChapterKnowledgeGraphInput, snapshotChapterSummaryInput, splitCandidateByOptionBudget, suppressContainedRanges, testWikispineRuntime, updateBuildJobTarget, validateNarrowingResponse, validatePolicyResponse, validateSurfaceProtectionResponse, withLoggingContext, writeWikgArchive };