wiki-graph-core 0.3.1 → 0.4.1

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/summary-build/snapshot/chunk-store.ts"],"sourcesContent":["import type {\n  ChunkRecord,\n  FragmentRecord,\n  ReadonlyChunkStore,\n} from \"../../../document/index.js\";\nimport {\n  compareChunkById,\n  comparePair,\n  createFragmentStartIndexesBySerialId,\n  createSegmentRanges,\n} from \"./helpers.js\";\n\nexport class SnapshotChunkStore implements ReadonlyChunkStore {\n  readonly #chunks: readonly ChunkRecord[];\n  readonly #chunksById: Map<number, ChunkRecord>;\n  readonly #fragmentStartIndexesBySerialId: ReadonlyMap<\n    number,\n    readonly number[]\n  >;\n\n  public constructor(\n    chunks: readonly ChunkRecord[],\n    fragments: readonly FragmentRecord[],\n  ) {\n    this.#chunks = [...chunks].sort(compareChunkById);\n    this.#chunksById = new Map(chunks.map((chunk) => [chunk.id, chunk]));\n    this.#fragmentStartIndexesBySerialId =\n      createFragmentStartIndexesBySerialId(fragments);\n  }\n\n  public getById(chunkId: number): Promise<ChunkRecord | undefined> {\n    return Promise.resolve(this.#chunksById.get(chunkId));\n  }\n\n  public countAll(): Promise<number> {\n    return Promise.resolve(this.#chunks.length);\n  }\n\n  public listAll(): Promise<ChunkRecord[]> {\n    return Promise.resolve([...this.#chunks]);\n  }\n\n  public listBySentenceStartIndexes(\n    serialId: number,\n    sentenceStartIndexes: readonly number[],\n  ): Promise<ChunkRecord[]> {\n    const segmentRanges = createSegmentRanges(\n      this.#fragmentStartIndexesBySerialId.get(serialId) ?? [],\n      sentenceStartIndexes,\n    );\n\n    return Promise.resolve(\n      this.#chunks.filter(\n        (chunk) =>\n          chunk.sentenceId[0] === serialId &&\n          segmentRanges.some(\n            (range) =>\n              chunk.sentenceId[1] >= range.startSentenceIndex &&\n              chunk.sentenceId[1] <= range.endSentenceIndex,\n          ),\n      ),\n    );\n  }\n\n  public listBySentenceRange(\n    serialId: number,\n    startSentenceIndex: number,\n    endSentenceIndex: number,\n  ): Promise<ChunkRecord[]> {\n    return Promise.resolve(\n      this.#chunks.filter(\n        (chunk) =>\n          chunk.sentenceId[0] === serialId &&\n          chunk.sentenceId[1] >= startSentenceIndex &&\n          chunk.sentenceId[1] <= endSentenceIndex,\n      ),\n    );\n  }\n\n  public listBySerial(serialId: number): Promise<ChunkRecord[]> {\n    return Promise.resolve(\n      this.#chunks.filter((chunk) => chunk.sentenceId[0] === serialId),\n    );\n  }\n\n  public getMaxId(): Promise<number> {\n    return Promise.resolve(\n      this.#chunks.reduce((maxId, chunk) => Math.max(maxId, chunk.id), 0),\n    );\n  }\n\n  public listFragmentPairs(): Promise<\n    ReadonlyArray<readonly [number, number]>\n  > {\n    const pairs = new Set<string>();\n\n    for (const chunk of this.#chunks) {\n      pairs.add(`${chunk.sentenceId[0]}:${chunk.sentenceId[1]}`);\n    }\n\n    return Promise.resolve(\n      [...pairs]\n        .map((pair) => pair.split(\":\").map(Number) as [number, number])\n        .sort(comparePair)\n        .map(([serialId, fragmentId]) => [serialId, fragmentId] as const),\n    );\n  }\n}\n"],"mappings":"AAKA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEA,MAAM,mBAAiD;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AAAA,EAKF,YACL,QACA,WACA;AACA,SAAK,UAAU,CAAC,GAAG,MAAM,EAAE,KAAK,gBAAgB;AAChD,SAAK,cAAc,IAAI,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC;AACnE,SAAK,kCACH,qCAAqC,SAAS;AAAA,EAClD;AAAA,EAEO,QAAQ,SAAmD;AAChE,WAAO,QAAQ,QAAQ,KAAK,YAAY,IAAI,OAAO,CAAC;AAAA,EACtD;AAAA,EAEO,WAA4B;AACjC,WAAO,QAAQ,QAAQ,KAAK,QAAQ,MAAM;AAAA,EAC5C;AAAA,EAEO,UAAkC;AACvC,WAAO,QAAQ,QAAQ,CAAC,GAAG,KAAK,OAAO,CAAC;AAAA,EAC1C;AAAA,EAEO,2BACL,UACA,sBACwB;AACxB,UAAM,gBAAgB;AAAA,MACpB,KAAK,gCAAgC,IAAI,QAAQ,KAAK,CAAC;AAAA,MACvD;AAAA,IACF;AAEA,WAAO,QAAQ;AAAA,MACb,KAAK,QAAQ;AAAA,QACX,CAAC,UACC,MAAM,WAAW,CAAC,MAAM,YACxB,cAAc;AAAA,UACZ,CAAC,UACC,MAAM,WAAW,CAAC,KAAK,MAAM,sBAC7B,MAAM,WAAW,CAAC,KAAK,MAAM;AAAA,QACjC;AAAA,MACJ;AAAA,IACF;AAAA,EACF;AAAA,EAEO,oBACL,UACA,oBACA,kBACwB;AACxB,WAAO,QAAQ;AAAA,MACb,KAAK,QAAQ;AAAA,QACX,CAAC,UACC,MAAM,WAAW,CAAC,MAAM,YACxB,MAAM,WAAW,CAAC,KAAK,sBACvB,MAAM,WAAW,CAAC,KAAK;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAAA,EAEO,aAAa,UAA0C;AAC5D,WAAO,QAAQ;AAAA,MACb,KAAK,QAAQ,OAAO,CAAC,UAAU,MAAM,WAAW,CAAC,MAAM,QAAQ;AAAA,IACjE;AAAA,EACF;AAAA,EAEO,WAA4B;AACjC,WAAO,QAAQ;AAAA,MACb,KAAK,QAAQ,OAAO,CAAC,OAAO,UAAU,KAAK,IAAI,OAAO,MAAM,EAAE,GAAG,CAAC;AAAA,IACpE;AAAA,EACF;AAAA,EAEO,oBAEL;AACA,UAAM,QAAQ,oBAAI,IAAY;AAE9B,eAAW,SAAS,KAAK,SAAS;AAChC,YAAM,IAAI,GAAG,MAAM,WAAW,CAAC,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,EAAE;AAAA,IAC3D;AAEA,WAAO,QAAQ;AAAA,MACb,CAAC,GAAG,KAAK,EACN,IAAI,CAAC,SAAS,KAAK,MAAM,GAAG,EAAE,IAAI,MAAM,CAAqB,EAC7D,KAAK,WAAW,EAChB,IAAI,CAAC,CAAC,UAAU,UAAU,MAAM,CAAC,UAAU,UAAU,CAAU;AAAA,IACpE;AAAA,EACF;AACF;","names":[]}

package/dist/text/summary-build/snapshot/empty-stores.d.ts

@@ -0,0 +1,50 @@
+import { MentionLinkRecord, MentionRecord } from '../../../document/types.js';
+import { ReadonlyGraphBuildParameterStore, ReadonlyMentionLinkStore, ReadonlyMentionStore, ReadonlyObjectMetadataStore } from '../../../document/stores/types.js';
+
+declare class EmptySnapshotMentionStore implements ReadonlyMentionStore {
+    countByQid(_qid: string, _options?: {
+        readonly chapterId?: number;
+    }): Promise<number>;
+    getById(_mentionId: string): Promise<undefined>;
+    listAll(): Promise<MentionRecord[]>;
+    listByQid(_qid: string, _options?: {
+        readonly chapterId?: number;
+        readonly limit?: number;
+        readonly offset?: number;
+        readonly order?: "asc" | "desc";
+    }): Promise<MentionRecord[]>;
+    listLabelsByQid(_qid: string, _options?: {
+        readonly chapterId?: number;
+    }): Promise<string[]>;
+    listBySurfaceTerms(_terms: readonly string[]): Promise<MentionRecord[]>;
+    listBySurfaces(_surfaces: readonly string[]): Promise<MentionRecord[]>;
+    listByChapter(_chapterId: number): Promise<MentionRecord[]>;
+}
+declare class EmptySnapshotMentionLinkStore implements ReadonlyMentionLinkStore {
+    countByTriple(_input: {
+        readonly chapterId?: number;
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<number>;
+    getById(_linkId: string): Promise<undefined>;
+    listAll(): Promise<MentionLinkRecord[]>;
+    listByTriple(_input: {
+        readonly chapterId?: number;
+        readonly limit?: number;
+        readonly offset?: number;
+        readonly order?: "asc" | "desc";
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<MentionLinkRecord[]>;
+    listByChapter(_chapterId: number): Promise<MentionLinkRecord[]>;
+}
+declare class EmptySnapshotObjectMetadataStore implements ReadonlyObjectMetadataStore {
+    getMap(_objectPath: string): Promise<Readonly<Record<string, unknown>>>;
+}
+declare class EmptySnapshotGraphBuildParameterStore implements ReadonlyGraphBuildParameterStore {
+    getByHash(_hash: string): Promise<undefined>;
+}
+
+export { EmptySnapshotGraphBuildParameterStore, EmptySnapshotMentionLinkStore, EmptySnapshotMentionStore, EmptySnapshotObjectMetadataStore };

package/dist/text/summary-build/snapshot/empty-stores.js

@@ -0,0 +1,60 @@
+class EmptySnapshotMentionStore {
+  countByQid(_qid, _options) {
+    return Promise.resolve(0);
+  }
+  getById(_mentionId) {
+    return Promise.resolve(void 0);
+  }
+  listAll() {
+    return Promise.resolve([]);
+  }
+  listByQid(_qid, _options) {
+    return Promise.resolve([]);
+  }
+  listLabelsByQid(_qid, _options) {
+    return Promise.resolve([]);
+  }
+  listBySurfaceTerms(_terms) {
+    return Promise.resolve([]);
+  }
+  listBySurfaces(_surfaces) {
+    return Promise.resolve([]);
+  }
+  listByChapter(_chapterId) {
+    return Promise.resolve([]);
+  }
+}
+class EmptySnapshotMentionLinkStore {
+  countByTriple(_input) {
+    return Promise.resolve(0);
+  }
+  getById(_linkId) {
+    return Promise.resolve(void 0);
+  }
+  listAll() {
+    return Promise.resolve([]);
+  }
+  listByTriple(_input) {
+    return Promise.resolve([]);
+  }
+  listByChapter(_chapterId) {
+    return Promise.resolve([]);
+  }
+}
+class EmptySnapshotObjectMetadataStore {
+  getMap(_objectPath) {
+    return Promise.resolve({});
+  }
+}
+class EmptySnapshotGraphBuildParameterStore {
+  getByHash(_hash) {
+    return Promise.resolve(void 0);
+  }
+}
+export {
+  EmptySnapshotGraphBuildParameterStore,
+  EmptySnapshotMentionLinkStore,
+  EmptySnapshotMentionStore,
+  EmptySnapshotObjectMetadataStore
+};
+//# sourceMappingURL=empty-stores.js.map

package/dist/text/summary-build/snapshot/empty-stores.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/summary-build/snapshot/empty-stores.ts"],"sourcesContent":["import type {\n  MentionLinkRecord,\n  MentionRecord,\n  ReadonlyGraphBuildParameterStore,\n  ReadonlyMentionLinkStore,\n  ReadonlyMentionStore,\n  ReadonlyObjectMetadataStore,\n} from \"../../../document/index.js\";\n\nexport class EmptySnapshotMentionStore implements ReadonlyMentionStore {\n  public countByQid(\n    _qid: string,\n    _options?: { readonly chapterId?: number },\n  ): Promise<number> {\n    return Promise.resolve(0);\n  }\n\n  public getById(_mentionId: string): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public listAll(): Promise<MentionRecord[]> {\n    return Promise.resolve([]);\n  }\n\n  public listByQid(\n    _qid: string,\n    _options?: {\n      readonly chapterId?: number;\n      readonly limit?: number;\n      readonly offset?: number;\n      readonly order?: \"asc\" | \"desc\";\n    },\n  ): Promise<MentionRecord[]> {\n    return Promise.resolve([]);\n  }\n\n  public listLabelsByQid(\n    _qid: string,\n    _options?: { readonly chapterId?: number },\n  ): Promise<string[]> {\n    return Promise.resolve([]);\n  }\n\n  public listBySurfaceTerms(\n    _terms: readonly string[],\n  ): Promise<MentionRecord[]> {\n    return Promise.resolve([]);\n  }\n\n  public listBySurfaces(\n    _surfaces: readonly string[],\n  ): Promise<MentionRecord[]> {\n    return Promise.resolve([]);\n  }\n\n  public listByChapter(_chapterId: number): Promise<MentionRecord[]> {\n    return Promise.resolve([]);\n  }\n}\n\nexport class EmptySnapshotMentionLinkStore implements ReadonlyMentionLinkStore {\n  public countByTriple(_input: {\n    readonly chapterId?: number;\n    readonly objectQid: string;\n    readonly predicate: string;\n    readonly subjectQid: string;\n  }): Promise<number> {\n    return Promise.resolve(0);\n  }\n\n  public getById(_linkId: string): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public listAll(): Promise<MentionLinkRecord[]> {\n    return Promise.resolve([]);\n  }\n\n  public listByTriple(_input: {\n    readonly chapterId?: number;\n    readonly limit?: number;\n    readonly offset?: number;\n    readonly order?: \"asc\" | \"desc\";\n    readonly objectQid: string;\n    readonly predicate: string;\n    readonly subjectQid: string;\n  }): Promise<MentionLinkRecord[]> {\n    return Promise.resolve([]);\n  }\n\n  public listByChapter(_chapterId: number): Promise<MentionLinkRecord[]> {\n    return Promise.resolve([]);\n  }\n}\n\nexport class EmptySnapshotObjectMetadataStore implements ReadonlyObjectMetadataStore {\n  public getMap(\n    _objectPath: string,\n  ): Promise<Readonly<Record<string, unknown>>> {\n    return Promise.resolve({});\n  }\n}\n\nexport class EmptySnapshotGraphBuildParameterStore implements ReadonlyGraphBuildParameterStore {\n  public getByHash(_hash: string): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n}\n"],"mappings":"AASO,MAAM,0BAA0D;AAAA,EAC9D,WACL,MACA,UACiB;AACjB,WAAO,QAAQ,QAAQ,CAAC;AAAA,EAC1B;AAAA,EAEO,QAAQ,YAAwC;AACrD,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,UAAoC;AACzC,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,UACL,MACA,UAM0B;AAC1B,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,gBACL,MACA,UACmB;AACnB,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,mBACL,QAC0B;AAC1B,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,eACL,WAC0B;AAC1B,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,cAAc,YAA8C;AACjE,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AACF;AAEO,MAAM,8BAAkE;AAAA,EACtE,cAAc,QAKD;AAClB,WAAO,QAAQ,QAAQ,CAAC;AAAA,EAC1B;AAAA,EAEO,QAAQ,SAAqC;AAClD,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,UAAwC;AAC7C,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,aAAa,QAQa;AAC/B,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAEO,cAAc,YAAkD;AACrE,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AACF;AAEO,MAAM,iCAAwE;AAAA,EAC5E,OACL,aAC4C;AAC5C,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AACF;AAEO,MAAM,sCAAkF;AAAA,EACtF,UAAU,OAAmC;AAClD,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AACF;","names":[]}

package/dist/text/summary-build/snapshot/graph-stores.d.ts

@@ -0,0 +1,42 @@
+import { SentenceGroupRecord, ReadingEdgeRecord, ChunkRecord, SnakeChunkRecord, SnakeEdgeRecord, SnakeRecord } from '../../../document/types.js';
+import { ReadonlyFragmentGroupStore, ReadonlyReadingEdgeStore, ReadonlySnakeChunkStore, ReadonlySnakeEdgeStore, ReadonlySnakeStore } from '../../../document/stores/types.js';
+
+declare class SnapshotReadingEdgeStore implements ReadonlyReadingEdgeStore {
+    #private;
+    constructor(edges: readonly ReadingEdgeRecord[], chunks: readonly ChunkRecord[]);
+    listAll(): Promise<ReadingEdgeRecord[]>;
+    countAll(): Promise<number>;
+    listBySerial(serialId: number): Promise<ReadingEdgeRecord[]>;
+    listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]>;
+    listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
+}
+declare class SnapshotSnakeStore implements ReadonlySnakeStore {
+    #private;
+    constructor(snakes: readonly SnakeRecord[]);
+    getById(snakeId: number): Promise<SnakeRecord | undefined>;
+    listIdsByGroup(serialId: number, groupId: number): Promise<number[]>;
+    listBySerial(serialId: number): Promise<SnakeRecord[]>;
+}
+declare class SnapshotSnakeChunkStore implements ReadonlySnakeChunkStore {
+    #private;
+    constructor(snakeChunks: readonly SnakeChunkRecord[]);
+    listChunkIds(snakeId: number): Promise<number[]>;
+    listBySnake(snakeId: number): Promise<SnakeChunkRecord[]>;
+}
+declare class SnapshotSnakeEdgeStore implements ReadonlySnakeEdgeStore {
+    #private;
+    constructor(edges: readonly SnakeEdgeRecord[], snakes: readonly SnakeRecord[]);
+    listIncoming(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listOutgoing(snakeId: number): Promise<SnakeEdgeRecord[]>;
+    listWithin(snakeIds: readonly number[]): Promise<SnakeEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<SnakeEdgeRecord[]>;
+}
+declare class SnapshotFragmentGroupStore implements ReadonlyFragmentGroupStore {
+    #private;
+    constructor(groups: readonly SentenceGroupRecord[]);
+    listBySerial(serialId: number): Promise<SentenceGroupRecord[]>;
+    listSerialIds(): Promise<number[]>;
+    listGroupIdsForSerial(serialId: number): Promise<number[]>;
+}
+
+export { SnapshotFragmentGroupStore, SnapshotReadingEdgeStore, SnapshotSnakeChunkStore, SnapshotSnakeEdgeStore, SnapshotSnakeStore };

package/dist/text/summary-build/snapshot/graph-stores.js

@@ -0,0 +1,148 @@
+import {
+  compareFragmentGroup,
+  compareNumber,
+  compareReadingEdge,
+  compareSnake,
+  compareSnakeChunk,
+  compareSnakeEdge
+} from "./helpers.js";
+class SnapshotReadingEdgeStore {
+  #edges;
+  #serialIdByChunkId;
+  constructor(edges, chunks) {
+    this.#edges = [...edges].sort(compareReadingEdge);
+    this.#serialIdByChunkId = new Map(
+      chunks.map((chunk) => [chunk.id, chunk.sentenceId[0]])
+    );
+  }
+  listAll() {
+    return Promise.resolve([...this.#edges]);
+  }
+  countAll() {
+    return Promise.resolve(this.#edges.length);
+  }
+  listBySerial(serialId) {
+    return Promise.resolve(
+      this.#edges.filter(
+        (edge) => this.#serialIdByChunkId.get(edge.fromId) === serialId && this.#serialIdByChunkId.get(edge.toId) === serialId
+      )
+    );
+  }
+  listIncoming(chunkId) {
+    return Promise.resolve(this.#edges.filter((edge) => edge.toId === chunkId));
+  }
+  listOutgoing(chunkId) {
+    return Promise.resolve(
+      this.#edges.filter((edge) => edge.fromId === chunkId)
+    );
+  }
+}
+class SnapshotSnakeStore {
+  #snakes;
+  #snakesById;
+  constructor(snakes) {
+    this.#snakes = [...snakes].sort(compareSnake);
+    this.#snakesById = new Map(snakes.map((snake) => [snake.id, snake]));
+  }
+  getById(snakeId) {
+    return Promise.resolve(this.#snakesById.get(snakeId));
+  }
+  listIdsByGroup(serialId, groupId) {
+    return Promise.resolve(
+      this.#snakes.filter(
+        (snake) => snake.serialId === serialId && snake.groupId === groupId
+      ).map((snake) => snake.id).sort(compareNumber)
+    );
+  }
+  listBySerial(serialId) {
+    return Promise.resolve(
+      this.#snakes.filter((snake) => snake.serialId === serialId)
+    );
+  }
+}
+class SnapshotSnakeChunkStore {
+  #snakeChunks;
+  constructor(snakeChunks) {
+    this.#snakeChunks = [...snakeChunks].sort(compareSnakeChunk);
+  }
+  listChunkIds(snakeId) {
+    return Promise.resolve(
+      this.#snakeChunks.filter((snakeChunk) => snakeChunk.snakeId === snakeId).map((snakeChunk) => snakeChunk.chunkId)
+    );
+  }
+  listBySnake(snakeId) {
+    return Promise.resolve(
+      this.#snakeChunks.filter((snakeChunk) => snakeChunk.snakeId === snakeId)
+    );
+  }
+}
+class SnapshotSnakeEdgeStore {
+  #edges;
+  #serialIdBySnakeId;
+  constructor(edges, snakes) {
+    this.#edges = [...edges].sort(compareSnakeEdge);
+    this.#serialIdBySnakeId = new Map(
+      snakes.map((snake) => [snake.id, snake.serialId])
+    );
+  }
+  listIncoming(snakeId) {
+    return Promise.resolve(
+      this.#edges.filter((edge) => edge.toSnakeId === snakeId)
+    );
+  }
+  listOutgoing(snakeId) {
+    return Promise.resolve(
+      this.#edges.filter((edge) => edge.fromSnakeId === snakeId)
+    );
+  }
+  listWithin(snakeIds) {
+    const snakeIdSet = new Set(snakeIds);
+    return Promise.resolve(
+      this.#edges.filter(
+        (edge) => snakeIdSet.has(edge.fromSnakeId) && snakeIdSet.has(edge.toSnakeId)
+      )
+    );
+  }
+  listBySerial(serialId) {
+    return Promise.resolve(
+      this.#edges.filter(
+        (edge) => this.#serialIdBySnakeId.get(edge.fromSnakeId) === serialId && this.#serialIdBySnakeId.get(edge.toSnakeId) === serialId
+      )
+    );
+  }
+}
+class SnapshotFragmentGroupStore {
+  #groups;
+  constructor(groups) {
+    this.#groups = [...groups].sort(compareFragmentGroup);
+  }
+  listBySerial(serialId) {
+    return Promise.resolve(
+      this.#groups.filter((group) => group.serialId === serialId)
+    );
+  }
+  listSerialIds() {
+    return Promise.resolve(
+      [...new Set(this.#groups.map((group) => group.serialId))].sort(
+        compareNumber
+      )
+    );
+  }
+  listGroupIdsForSerial(serialId) {
+    return Promise.resolve(
+      [
+        ...new Set(
+          this.#groups.filter((group) => group.serialId === serialId).map((group) => group.groupId)
+        )
+      ].sort(compareNumber)
+    );
+  }
+}
+export {
+  SnapshotFragmentGroupStore,
+  SnapshotReadingEdgeStore,
+  SnapshotSnakeChunkStore,
+  SnapshotSnakeEdgeStore,
+  SnapshotSnakeStore
+};
+//# sourceMappingURL=graph-stores.js.map

package/dist/text/summary-build/snapshot/graph-stores.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/summary-build/snapshot/graph-stores.ts"],"sourcesContent":["import type {\n  ChunkRecord,\n  ReadingEdgeRecord,\n  ReadonlyFragmentGroupStore,\n  ReadonlyReadingEdgeStore,\n  ReadonlySnakeChunkStore,\n  ReadonlySnakeEdgeStore,\n  ReadonlySnakeStore,\n  SentenceGroupRecord,\n  SnakeChunkRecord,\n  SnakeEdgeRecord,\n  SnakeRecord,\n} from \"../../../document/index.js\";\nimport {\n  compareFragmentGroup,\n  compareNumber,\n  compareReadingEdge,\n  compareSnake,\n  compareSnakeChunk,\n  compareSnakeEdge,\n} from \"./helpers.js\";\n\nexport class SnapshotReadingEdgeStore implements ReadonlyReadingEdgeStore {\n  readonly #edges: readonly ReadingEdgeRecord[];\n  readonly #serialIdByChunkId: Map<number, number>;\n\n  public constructor(\n    edges: readonly ReadingEdgeRecord[],\n    chunks: readonly ChunkRecord[],\n  ) {\n    this.#edges = [...edges].sort(compareReadingEdge);\n    this.#serialIdByChunkId = new Map(\n      chunks.map((chunk) => [chunk.id, chunk.sentenceId[0]]),\n    );\n  }\n\n  public listAll(): Promise<ReadingEdgeRecord[]> {\n    return Promise.resolve([...this.#edges]);\n  }\n\n  public countAll(): Promise<number> {\n    return Promise.resolve(this.#edges.length);\n  }\n\n  public listBySerial(serialId: number): Promise<ReadingEdgeRecord[]> {\n    return Promise.resolve(\n      this.#edges.filter(\n        (edge) =>\n          this.#serialIdByChunkId.get(edge.fromId) === serialId &&\n          this.#serialIdByChunkId.get(edge.toId) === serialId,\n      ),\n    );\n  }\n\n  public listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]> {\n    return Promise.resolve(this.#edges.filter((edge) => edge.toId === chunkId));\n  }\n\n  public listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]> {\n    return Promise.resolve(\n      this.#edges.filter((edge) => edge.fromId === chunkId),\n    );\n  }\n}\n\nexport class SnapshotSnakeStore implements ReadonlySnakeStore {\n  readonly #snakes: readonly SnakeRecord[];\n  readonly #snakesById: Map<number, SnakeRecord>;\n\n  public constructor(snakes: readonly SnakeRecord[]) {\n    this.#snakes = [...snakes].sort(compareSnake);\n    this.#snakesById = new Map(snakes.map((snake) => [snake.id, snake]));\n  }\n\n  public getById(snakeId: number): Promise<SnakeRecord | undefined> {\n    return Promise.resolve(this.#snakesById.get(snakeId));\n  }\n\n  public listIdsByGroup(serialId: number, groupId: number): Promise<number[]> {\n    return Promise.resolve(\n      this.#snakes\n        .filter(\n          (snake) => snake.serialId === serialId && snake.groupId === groupId,\n        )\n        .map((snake) => snake.id)\n        .sort(compareNumber),\n    );\n  }\n\n  public listBySerial(serialId: number): Promise<SnakeRecord[]> {\n    return Promise.resolve(\n      this.#snakes.filter((snake) => snake.serialId === serialId),\n    );\n  }\n}\n\nexport class SnapshotSnakeChunkStore implements ReadonlySnakeChunkStore {\n  readonly #snakeChunks: readonly SnakeChunkRecord[];\n\n  public constructor(snakeChunks: readonly SnakeChunkRecord[]) {\n    this.#snakeChunks = [...snakeChunks].sort(compareSnakeChunk);\n  }\n\n  public listChunkIds(snakeId: number): Promise<number[]> {\n    return Promise.resolve(\n      this.#snakeChunks\n        .filter((snakeChunk) => snakeChunk.snakeId === snakeId)\n        .map((snakeChunk) => snakeChunk.chunkId),\n    );\n  }\n\n  public listBySnake(snakeId: number): Promise<SnakeChunkRecord[]> {\n    return Promise.resolve(\n      this.#snakeChunks.filter((snakeChunk) => snakeChunk.snakeId === snakeId),\n    );\n  }\n}\n\nexport class SnapshotSnakeEdgeStore implements ReadonlySnakeEdgeStore {\n  readonly #edges: readonly SnakeEdgeRecord[];\n  readonly #serialIdBySnakeId: Map<number, number>;\n\n  public constructor(\n    edges: readonly SnakeEdgeRecord[],\n    snakes: readonly SnakeRecord[],\n  ) {\n    this.#edges = [...edges].sort(compareSnakeEdge);\n    this.#serialIdBySnakeId = new Map(\n      snakes.map((snake) => [snake.id, snake.serialId]),\n    );\n  }\n\n  public listIncoming(snakeId: number): Promise<SnakeEdgeRecord[]> {\n    return Promise.resolve(\n      this.#edges.filter((edge) => edge.toSnakeId === snakeId),\n    );\n  }\n\n  public listOutgoing(snakeId: number): Promise<SnakeEdgeRecord[]> {\n    return Promise.resolve(\n      this.#edges.filter((edge) => edge.fromSnakeId === snakeId),\n    );\n  }\n\n  public listWithin(snakeIds: readonly number[]): Promise<SnakeEdgeRecord[]> {\n    const snakeIdSet = new Set(snakeIds);\n\n    return Promise.resolve(\n      this.#edges.filter(\n        (edge) =>\n          snakeIdSet.has(edge.fromSnakeId) && snakeIdSet.has(edge.toSnakeId),\n      ),\n    );\n  }\n\n  public listBySerial(serialId: number): Promise<SnakeEdgeRecord[]> {\n    return Promise.resolve(\n      this.#edges.filter(\n        (edge) =>\n          this.#serialIdBySnakeId.get(edge.fromSnakeId) === serialId &&\n          this.#serialIdBySnakeId.get(edge.toSnakeId) === serialId,\n      ),\n    );\n  }\n}\n\nexport class SnapshotFragmentGroupStore implements ReadonlyFragmentGroupStore {\n  readonly #groups: readonly SentenceGroupRecord[];\n\n  public constructor(groups: readonly SentenceGroupRecord[]) {\n    this.#groups = [...groups].sort(compareFragmentGroup);\n  }\n\n  public listBySerial(serialId: number): Promise<SentenceGroupRecord[]> {\n    return Promise.resolve(\n      this.#groups.filter((group) => group.serialId === serialId),\n    );\n  }\n\n  public listSerialIds(): Promise<number[]> {\n    return Promise.resolve(\n      [...new Set(this.#groups.map((group) => group.serialId))].sort(\n        compareNumber,\n      ),\n    );\n  }\n\n  public listGroupIdsForSerial(serialId: number): Promise<number[]> {\n    return Promise.resolve(\n      [\n        ...new Set(\n          this.#groups\n            .filter((group) => group.serialId === serialId)\n            .map((group) => group.groupId),\n        ),\n      ].sort(compareNumber),\n    );\n  }\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,17 @@
+import { ChunkRecord, SentenceGroupRecord, ReadingEdgeRecord, SnakeRecord, SnakeChunkRecord, SnakeEdgeRecord, FragmentRecord } from '../../../document/types.js';
+
+declare function compareNumber(left: number, right: number): number;
+declare function createFragmentStartIndexesBySerialId(fragments: readonly FragmentRecord[]): ReadonlyMap<number, readonly number[]>;
+declare function createSegmentRanges(allStartIndexes: readonly number[], selectedStartIndexes: readonly number[]): Array<{
+    readonly endSentenceIndex: number;
+    readonly startSentenceIndex: number;
+}>;
+declare function compareChunkById(left: ChunkRecord, right: ChunkRecord): number;
+declare function compareFragmentGroup(left: SentenceGroupRecord, right: SentenceGroupRecord): number;
+declare function compareReadingEdge(left: ReadingEdgeRecord, right: ReadingEdgeRecord): number;
+declare function comparePair(left: readonly [number, number], right: readonly [number, number]): number;
+declare function compareSnake(left: SnakeRecord, right: SnakeRecord): number;
+declare function compareSnakeChunk(left: SnakeChunkRecord, right: SnakeChunkRecord): number;
+declare function compareSnakeEdge(left: SnakeEdgeRecord, right: SnakeEdgeRecord): number;
+
+export { compareChunkById, compareFragmentGroup, compareNumber, comparePair, compareReadingEdge, compareSnake, compareSnakeChunk, compareSnakeEdge, createFragmentStartIndexesBySerialId, createSegmentRanges };

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

@@ -0,0 +1,65 @@
+function compareNumber(left, right) {
+  return left - right;
+}
+function createFragmentStartIndexesBySerialId(fragments) {
+  const indexesBySerialId = /* @__PURE__ */ new Map();
+  for (const fragment of fragments) {
+    const indexes = indexesBySerialId.get(fragment.serialId) ?? [];
+    indexes.push(fragment.fragmentId);
+    indexesBySerialId.set(fragment.serialId, indexes);
+  }
+  return new Map(
+    [...indexesBySerialId.entries()].map(
+      ([serialId, indexes]) => [serialId, indexes.sort(compareNumber)]
+    )
+  );
+}
+function createSegmentRanges(allStartIndexes, selectedStartIndexes) {
+  const selected = new Set(selectedStartIndexes);
+  return allStartIndexes.flatMap((startSentenceIndex, index) => {
+    if (!selected.has(startSentenceIndex)) {
+      return [];
+    }
+    const nextStartSentenceIndex = allStartIndexes[index + 1];
+    return [
+      {
+        endSentenceIndex: nextStartSentenceIndex === void 0 ? Infinity : nextStartSentenceIndex - 1,
+        startSentenceIndex
+      }
+    ];
+  });
+}
+function compareChunkById(left, right) {
+  return left.id - right.id;
+}
+function compareFragmentGroup(left, right) {
+  return left.serialId - right.serialId || left.groupId - right.groupId || left.startSentenceIndex - right.startSentenceIndex || left.endSentenceIndex - right.endSentenceIndex;
+}
+function compareReadingEdge(left, right) {
+  return left.fromId - right.fromId || left.toId - right.toId;
+}
+function comparePair(left, right) {
+  return left[0] - right[0] || left[1] - right[1];
+}
+function compareSnake(left, right) {
+  return left.groupId - right.groupId || left.id - right.id;
+}
+function compareSnakeChunk(left, right) {
+  return left.snakeId - right.snakeId || left.position - right.position;
+}
+function compareSnakeEdge(left, right) {
+  return left.fromSnakeId - right.fromSnakeId || left.toSnakeId - right.toSnakeId;
+}
+export {
+  compareChunkById,
+  compareFragmentGroup,
+  compareNumber,
+  comparePair,
+  compareReadingEdge,
+  compareSnake,
+  compareSnakeChunk,
+  compareSnakeEdge,
+  createFragmentStartIndexesBySerialId,
+  createSegmentRanges
+};
+//# sourceMappingURL=helpers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/summary-build/snapshot/helpers.ts"],"sourcesContent":["import type {\n  ChunkRecord,\n  FragmentRecord,\n  ReadingEdgeRecord,\n  SentenceGroupRecord,\n  SnakeChunkRecord,\n  SnakeEdgeRecord,\n  SnakeRecord,\n} from \"../../../document/index.js\";\n\nexport function compareNumber(left: number, right: number): number {\n  return left - right;\n}\n\nexport function createFragmentStartIndexesBySerialId(\n  fragments: readonly FragmentRecord[],\n): ReadonlyMap<number, readonly number[]> {\n  const indexesBySerialId = new Map<number, number[]>();\n\n  for (const fragment of fragments) {\n    const indexes = indexesBySerialId.get(fragment.serialId) ?? [];\n\n    indexes.push(fragment.fragmentId);\n    indexesBySerialId.set(fragment.serialId, indexes);\n  }\n\n  return new Map(\n    [...indexesBySerialId.entries()].map(\n      ([serialId, indexes]) => [serialId, indexes.sort(compareNumber)] as const,\n    ),\n  );\n}\n\nexport function createSegmentRanges(\n  allStartIndexes: readonly number[],\n  selectedStartIndexes: readonly number[],\n): Array<{\n  readonly endSentenceIndex: number;\n  readonly startSentenceIndex: number;\n}> {\n  const selected = new Set(selectedStartIndexes);\n\n  return allStartIndexes.flatMap((startSentenceIndex, index) => {\n    if (!selected.has(startSentenceIndex)) {\n      return [];\n    }\n\n    const nextStartSentenceIndex = allStartIndexes[index + 1];\n\n    return [\n      {\n        endSentenceIndex:\n          nextStartSentenceIndex === undefined\n            ? Infinity\n            : nextStartSentenceIndex - 1,\n        startSentenceIndex,\n      },\n    ];\n  });\n}\n\nexport function compareChunkById(\n  left: ChunkRecord,\n  right: ChunkRecord,\n): number {\n  return left.id - right.id;\n}\n\nexport function compareFragmentGroup(\n  left: SentenceGroupRecord,\n  right: SentenceGroupRecord,\n): number {\n  return (\n    left.serialId - right.serialId ||\n    left.groupId - right.groupId ||\n    left.startSentenceIndex - right.startSentenceIndex ||\n    left.endSentenceIndex - right.endSentenceIndex\n  );\n}\n\nexport function compareReadingEdge(\n  left: ReadingEdgeRecord,\n  right: ReadingEdgeRecord,\n): number {\n  return left.fromId - right.fromId || left.toId - right.toId;\n}\n\nexport function comparePair(\n  left: readonly [number, number],\n  right: readonly [number, number],\n): number {\n  return left[0] - right[0] || left[1] - right[1];\n}\n\nexport function compareSnake(left: SnakeRecord, right: SnakeRecord): number {\n  return left.groupId - right.groupId || left.id - right.id;\n}\n\nexport function compareSnakeChunk(\n  left: SnakeChunkRecord,\n  right: SnakeChunkRecord,\n): number {\n  return left.snakeId - right.snakeId || left.position - right.position;\n}\n\nexport function compareSnakeEdge(\n  left: SnakeEdgeRecord,\n  right: SnakeEdgeRecord,\n): number {\n  return (\n    left.fromSnakeId - right.fromSnakeId || left.toSnakeId - right.toSnakeId\n  );\n}\n"],"mappings":"AAUO,SAAS,cAAc,MAAc,OAAuB;AACjE,SAAO,OAAO;AAChB;AAEO,SAAS,qCACd,WACwC;AACxC,QAAM,oBAAoB,oBAAI,IAAsB;AAEpD,aAAW,YAAY,WAAW;AAChC,UAAM,UAAU,kBAAkB,IAAI,SAAS,QAAQ,KAAK,CAAC;AAE7D,YAAQ,KAAK,SAAS,UAAU;AAChC,sBAAkB,IAAI,SAAS,UAAU,OAAO;AAAA,EAClD;AAEA,SAAO,IAAI;AAAA,IACT,CAAC,GAAG,kBAAkB,QAAQ,CAAC,EAAE;AAAA,MAC/B,CAAC,CAAC,UAAU,OAAO,MAAM,CAAC,UAAU,QAAQ,KAAK,aAAa,CAAC;AAAA,IACjE;AAAA,EACF;AACF;AAEO,SAAS,oBACd,iBACA,sBAIC;AACD,QAAM,WAAW,IAAI,IAAI,oBAAoB;AAE7C,SAAO,gBAAgB,QAAQ,CAAC,oBAAoB,UAAU;AAC5D,QAAI,CAAC,SAAS,IAAI,kBAAkB,GAAG;AACrC,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,yBAAyB,gBAAgB,QAAQ,CAAC;AAExD,WAAO;AAAA,MACL;AAAA,QACE,kBACE,2BAA2B,SACvB,WACA,yBAAyB;AAAA,QAC/B;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAEO,SAAS,iBACd,MACA,OACQ;AACR,SAAO,KAAK,KAAK,MAAM;AACzB;AAEO,SAAS,qBACd,MACA,OACQ;AACR,SACE,KAAK,WAAW,MAAM,YACtB,KAAK,UAAU,MAAM,WACrB,KAAK,qBAAqB,MAAM,sBAChC,KAAK,mBAAmB,MAAM;AAElC;AAEO,SAAS,mBACd,MACA,OACQ;AACR,SAAO,KAAK,SAAS,MAAM,UAAU,KAAK,OAAO,MAAM;AACzD;AAEO,SAAS,YACd,MACA,OACQ;AACR,SAAO,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,KAAK,CAAC,IAAI,MAAM,CAAC;AAChD;AAEO,SAAS,aAAa,MAAmB,OAA4B;AAC1E,SAAO,KAAK,UAAU,MAAM,WAAW,KAAK,KAAK,MAAM;AACzD;AAEO,SAAS,kBACd,MACA,OACQ;AACR,SAAO,KAAK,UAAU,MAAM,WAAW,KAAK,WAAW,MAAM;AAC/D;AAEO,SAAS,iBACd,MACA,OACQ;AACR,SACE,KAAK,cAAc,MAAM,eAAe,KAAK,YAAY,MAAM;AAEnE;","names":[]}

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

@@ -0,0 +1,63 @@
+import { SentenceId } from '../../../document/types.js';
+import { ReadonlySerialTextStream } from '../../../document/text-streams/types.js';
+import { ReadonlyGraphBuildParameterStore, ReadonlyMentionLinkStore, ReadonlyMentionStore, ReadonlyObjectMetadataStore } from '../../../document/stores/types.js';
+import { ReadonlyDocument } from '../../../document/directory/types.js';
+import { SummaryInputSnapshotData } from '../types.js';
+import { SnapshotChunkStore } from './chunk-store.js';
+import { SnapshotFragmentGroupStore, SnapshotReadingEdgeStore, SnapshotSnakeChunkStore, SnapshotSnakeEdgeStore, SnapshotSnakeStore } from './graph-stores.js';
+import { SnapshotSerialStore } from './serial-store.js';
+import '../../source/meta.js';
+import 'zod';
+import '../../source/toc.js';
+import '../../source/types.js';
+import '../../../document/database.js';
+import 'sqlite3';
+import '../../../document/text-streams/serial.js';
+import '../../../document/text-streams/draft.js';
+import '../../../document/stores/chunk.js';
+import '../../../document/stores/fragment-group.js';
+import '../../../document/stores/graph-build-parameter.js';
+import '../../../document/stores/mention-link.js';
+import '../../../document/stores/mention.js';
+import '../../../document/stores/object-metadata.js';
+import '../../../document/stores/reading-edge.js';
+import '../../../document/stores/serial.js';
+import '../../../document/stores/snake/chunk.js';
+import '../../../document/stores/snake/core.js';
+import '../../../document/stores/snake/edge.js';
+import '../../../external/llm/client/core.js';
+import '../../../external/llm/context.js';
+import '../../../external/llm/cache.js';
+import '../../../external/llm/types.js';
+import 'ai';
+import '../../../runtime/common/language.js';
+import '../../../runtime/common/llm-scope.js';
+
+declare class SummaryInputSnapshotDocument implements ReadonlyDocument {
+    #private;
+    readonly chunks: SnapshotChunkStore;
+    readonly fragmentGroups: SnapshotFragmentGroupStore;
+    readonly graphBuildParameters: ReadonlyGraphBuildParameterStore;
+    readonly readingEdges: SnapshotReadingEdgeStore;
+    readonly mentionLinks: ReadonlyMentionLinkStore;
+    readonly mentions: ReadonlyMentionStore;
+    readonly metadata: ReadonlyObjectMetadataStore;
+    readonly serials: SnapshotSerialStore;
+    readonly snakeChunks: SnapshotSnakeChunkStore;
+    readonly snakeEdges: SnapshotSnakeEdgeStore;
+    readonly snakes: SnapshotSnakeStore;
+    constructor(snapshot: SummaryInputSnapshotData);
+    getSentence(sentenceId: SentenceId): Promise<string>;
+    getSerialFragments(serialId: number): ReadonlySerialTextStream;
+    getSummaryFragments(serialId: number): ReadonlySerialTextStream;
+    openSession<T>(operation: (document: ReadonlyDocument) => Promise<T> | T): Promise<T>;
+    readDatabase<T>(): Promise<T>;
+    readSearchIndexDatabase<T>(): Promise<T>;
+    readBookMeta(): Promise<undefined>;
+    readCover(): Promise<undefined>;
+    readSummary(_serialId: number): Promise<undefined>;
+    readToc(): Promise<undefined>;
+    release(): Promise<void>;
+}
+
+export { SummaryInputSnapshotDocument };

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

@@ -0,0 +1,106 @@
+import { SnapshotChunkStore } from "./chunk-store.js";
+import {
+  EmptySnapshotGraphBuildParameterStore,
+  EmptySnapshotMentionLinkStore,
+  EmptySnapshotMentionStore,
+  EmptySnapshotObjectMetadataStore
+} from "./empty-stores.js";
+import {
+  SnapshotFragmentGroupStore,
+  SnapshotReadingEdgeStore,
+  SnapshotSnakeChunkStore,
+  SnapshotSnakeEdgeStore,
+  SnapshotSnakeStore
+} from "./graph-stores.js";
+import {
+  SnapshotSerialFragments,
+  SnapshotSerialStore
+} from "./serial-store.js";
+class SummaryInputSnapshotDocument {
+  chunks;
+  fragmentGroups;
+  graphBuildParameters;
+  readingEdges;
+  mentionLinks;
+  mentions;
+  metadata;
+  serials;
+  snakeChunks;
+  snakeEdges;
+  snakes;
+  #fragments;
+  constructor(snapshot) {
+    const serialId = snapshot.serial.id;
+    this.chunks = new SnapshotChunkStore(snapshot.chunks, snapshot.fragments);
+    this.fragmentGroups = new SnapshotFragmentGroupStore(
+      snapshot.fragmentGroups
+    );
+    this.graphBuildParameters = new EmptySnapshotGraphBuildParameterStore();
+    this.readingEdges = new SnapshotReadingEdgeStore(
+      snapshot.readingEdges,
+      snapshot.chunks
+    );
+    this.mentionLinks = new EmptySnapshotMentionLinkStore();
+    this.mentions = new EmptySnapshotMentionStore();
+    this.metadata = new EmptySnapshotObjectMetadataStore();
+    this.serials = new SnapshotSerialStore(snapshot.serial);
+    this.snakeChunks = new SnapshotSnakeChunkStore(snapshot.snakeChunks);
+    this.snakeEdges = new SnapshotSnakeEdgeStore(
+      snapshot.snakeEdges,
+      snapshot.snakes
+    );
+    this.snakes = new SnapshotSnakeStore(snapshot.snakes);
+    this.#fragments = new SnapshotSerialFragments(serialId, snapshot.fragments);
+  }
+  async getSentence(sentenceId) {
+    const [serialId, sentenceIndex] = sentenceId;
+    const sentence = (await this.getSerialFragments(serialId).listSentences())[sentenceIndex];
+    if (sentence === void 0) {
+      throw new RangeError(`Sentence ${sentenceIndex} does not exist`);
+    }
+    return sentence.text;
+  }
+  getSerialFragments(serialId) {
+    if (serialId !== this.#fragments.serialId) {
+      return new SnapshotSerialFragments(serialId, []);
+    }
+    return this.#fragments;
+  }
+  getSummaryFragments(serialId) {
+    return new SnapshotSerialFragments(serialId, []);
+  }
+  async openSession(operation) {
+    return await operation(this);
+  }
+  readDatabase() {
+    return Promise.reject(
+      new Error("Summary input snapshots do not expose a SQLite database.")
+    );
+  }
+  readSearchIndexDatabase() {
+    return Promise.reject(
+      new Error(
+        "Summary input snapshots do not expose a search index database."
+      )
+    );
+  }
+  readBookMeta() {
+    return Promise.resolve(void 0);
+  }
+  readCover() {
+    return Promise.resolve(void 0);
+  }
+  readSummary(_serialId) {
+    return Promise.resolve(void 0);
+  }
+  readToc() {
+    return Promise.resolve(void 0);
+  }
+  release() {
+    return Promise.resolve();
+  }
+}
+export {
+  SummaryInputSnapshotDocument
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/summary-build/snapshot/index.ts"],"sourcesContent":["import type {\n  ReadonlyDocument,\n  ReadonlyGraphBuildParameterStore,\n  ReadonlyMentionLinkStore,\n  ReadonlyMentionStore,\n  ReadonlyObjectMetadataStore,\n  ReadonlySerialFragments,\n  SentenceId,\n} from \"../../../document/index.js\";\nimport type { SummaryInputSnapshotData } from \"../types.js\";\nimport { SnapshotChunkStore } from \"./chunk-store.js\";\nimport {\n  EmptySnapshotGraphBuildParameterStore,\n  EmptySnapshotMentionLinkStore,\n  EmptySnapshotMentionStore,\n  EmptySnapshotObjectMetadataStore,\n} from \"./empty-stores.js\";\nimport {\n  SnapshotFragmentGroupStore,\n  SnapshotReadingEdgeStore,\n  SnapshotSnakeChunkStore,\n  SnapshotSnakeEdgeStore,\n  SnapshotSnakeStore,\n} from \"./graph-stores.js\";\nimport {\n  SnapshotSerialFragments,\n  SnapshotSerialStore,\n} from \"./serial-store.js\";\n\nexport class SummaryInputSnapshotDocument implements ReadonlyDocument {\n  public readonly chunks: SnapshotChunkStore;\n  public readonly fragmentGroups: SnapshotFragmentGroupStore;\n  public readonly graphBuildParameters: ReadonlyGraphBuildParameterStore;\n  public readonly readingEdges: SnapshotReadingEdgeStore;\n  public readonly mentionLinks: ReadonlyMentionLinkStore;\n  public readonly mentions: ReadonlyMentionStore;\n  public readonly metadata: ReadonlyObjectMetadataStore;\n  public readonly serials: SnapshotSerialStore;\n  public readonly snakeChunks: SnapshotSnakeChunkStore;\n  public readonly snakeEdges: SnapshotSnakeEdgeStore;\n  public readonly snakes: SnapshotSnakeStore;\n  readonly #fragments: ReadonlySerialFragments;\n\n  public constructor(snapshot: SummaryInputSnapshotData) {\n    const serialId = snapshot.serial.id;\n\n    this.chunks = new SnapshotChunkStore(snapshot.chunks, snapshot.fragments);\n    this.fragmentGroups = new SnapshotFragmentGroupStore(\n      snapshot.fragmentGroups,\n    );\n    this.graphBuildParameters = new EmptySnapshotGraphBuildParameterStore();\n    this.readingEdges = new SnapshotReadingEdgeStore(\n      snapshot.readingEdges,\n      snapshot.chunks,\n    );\n    this.mentionLinks = new EmptySnapshotMentionLinkStore();\n    this.mentions = new EmptySnapshotMentionStore();\n    this.metadata = new EmptySnapshotObjectMetadataStore();\n    this.serials = new SnapshotSerialStore(snapshot.serial);\n    this.snakeChunks = new SnapshotSnakeChunkStore(snapshot.snakeChunks);\n    this.snakeEdges = new SnapshotSnakeEdgeStore(\n      snapshot.snakeEdges,\n      snapshot.snakes,\n    );\n    this.snakes = new SnapshotSnakeStore(snapshot.snakes);\n    this.#fragments = new SnapshotSerialFragments(serialId, snapshot.fragments);\n  }\n\n  public async getSentence(sentenceId: SentenceId): Promise<string> {\n    const [serialId, sentenceIndex] = sentenceId;\n    const sentence = (await this.getSerialFragments(serialId).listSentences!())[\n      sentenceIndex\n    ];\n\n    if (sentence === undefined) {\n      throw new RangeError(`Sentence ${sentenceIndex} does not exist`);\n    }\n\n    return sentence.text;\n  }\n\n  public getSerialFragments(serialId: number): ReadonlySerialFragments {\n    if (serialId !== this.#fragments.serialId) {\n      return new SnapshotSerialFragments(serialId, []);\n    }\n    return this.#fragments;\n  }\n\n  public getSummaryFragments(serialId: number): ReadonlySerialFragments {\n    return new SnapshotSerialFragments(serialId, []);\n  }\n\n  public async openSession<T>(\n    operation: (document: ReadonlyDocument) => Promise<T> | T,\n  ): Promise<T> {\n    return await operation(this);\n  }\n\n  public readDatabase<T>(): Promise<T> {\n    return Promise.reject(\n      new Error(\"Summary input snapshots do not expose a SQLite database.\"),\n    );\n  }\n\n  public readSearchIndexDatabase<T>(): Promise<T> {\n    return Promise.reject(\n      new Error(\n        \"Summary input snapshots do not expose a search index database.\",\n      ),\n    );\n  }\n\n  public readBookMeta(): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public readCover(): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public readSummary(_serialId: number): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public readToc(): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public release(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n"],"mappings":"AAUA,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEA,MAAM,6BAAyD;AAAA,EACpD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACP;AAAA,EAEF,YAAY,UAAoC;AACrD,UAAM,WAAW,SAAS,OAAO;AAEjC,SAAK,SAAS,IAAI,mBAAmB,SAAS,QAAQ,SAAS,SAAS;AACxE,SAAK,iBAAiB,IAAI;AAAA,MACxB,SAAS;AAAA,IACX;AACA,SAAK,uBAAuB,IAAI,sCAAsC;AACtE,SAAK,eAAe,IAAI;AAAA,MACtB,SAAS;AAAA,MACT,SAAS;AAAA,IACX;AACA,SAAK,eAAe,IAAI,8BAA8B;AACtD,SAAK,WAAW,IAAI,0BAA0B;AAC9C,SAAK,WAAW,IAAI,iCAAiC;AACrD,SAAK,UAAU,IAAI,oBAAoB,SAAS,MAAM;AACtD,SAAK,cAAc,IAAI,wBAAwB,SAAS,WAAW;AACnE,SAAK,aAAa,IAAI;AAAA,MACpB,SAAS;AAAA,MACT,SAAS;AAAA,IACX;AACA,SAAK,SAAS,IAAI,mBAAmB,SAAS,MAAM;AACpD,SAAK,aAAa,IAAI,wBAAwB,UAAU,SAAS,SAAS;AAAA,EAC5E;AAAA,EAEA,MAAa,YAAY,YAAyC;AAChE,UAAM,CAAC,UAAU,aAAa,IAAI;AAClC,UAAM,YAAY,MAAM,KAAK,mBAAmB,QAAQ,EAAE,cAAe,GACvE,aACF;AAEA,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,WAAW,YAAY,aAAa,iBAAiB;AAAA,IACjE;AAEA,WAAO,SAAS;AAAA,EAClB;AAAA,EAEO,mBAAmB,UAA2C;AACnE,QAAI,aAAa,KAAK,WAAW,UAAU;AACzC,aAAO,IAAI,wBAAwB,UAAU,CAAC,CAAC;AAAA,IACjD;AACA,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,oBAAoB,UAA2C;AACpE,WAAO,IAAI,wBAAwB,UAAU,CAAC,CAAC;AAAA,EACjD;AAAA,EAEA,MAAa,YACX,WACY;AACZ,WAAO,MAAM,UAAU,IAAI;AAAA,EAC7B;AAAA,EAEO,eAA8B;AACnC,WAAO,QAAQ;AAAA,MACb,IAAI,MAAM,0DAA0D;AAAA,IACtE;AAAA,EACF;AAAA,EAEO,0BAAyC;AAC9C,WAAO,QAAQ;AAAA,MACb,IAAI;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEO,eAAmC;AACxC,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,YAAgC;AACrC,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,YAAY,WAAuC;AACxD,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,UAA8B;AACnC,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,UAAyB;AAC9B,WAAO,QAAQ,QAAQ;AAAA,EACzB;AACF;","names":[]}

package/dist/text/summary-build/snapshot/serial-store.d.ts

@@ -0,0 +1,29 @@
+import { SerialRecord, FragmentRecord, SentenceRecord } from '../../../document/types.js';
+import { ReadonlySerialTextStream } from '../../../document/text-streams/types.js';
+import { ReadonlySerialStore } from '../../../document/stores/types.js';
+
+declare class SnapshotSerialStore implements ReadonlySerialStore {
+    #private;
+    constructor(serial: SerialRecord);
+    getById(serialId: number): Promise<SerialRecord | undefined>;
+    getRevision(serialId: number): Promise<number>;
+    getRevisions(serialIds: readonly number[]): Promise<ReadonlyMap<number, number>>;
+    getChaptersRevision(): Promise<number>;
+    getMaxId(): Promise<number>;
+    listIds(): Promise<number[]>;
+    listDocumentOrders(): Promise<ReadonlyMap<number, number>>;
+}
+declare class SnapshotSerialFragments implements ReadonlySerialTextStream {
+    #private;
+    readonly path = "";
+    readonly serialId: number;
+    constructor(serialId: number, fragments: readonly FragmentRecord[]);
+    getFragment(fragmentId: number): Promise<FragmentRecord>;
+    listFragmentIds(): Promise<readonly number[]>;
+    getSentence(sentenceIndex: number): Promise<SentenceRecord>;
+    listSentencesInRange(startSentenceIndex: number, endSentenceIndex: number): Promise<SentenceRecord[]>;
+    listSentences(): Promise<SentenceRecord[]>;
+    readText(): Promise<string | undefined>;
+}
+
+export { SnapshotSerialFragments, SnapshotSerialStore };