wiki-graph-core 0.3.1

package/dist/facade/chapter-build.js

@@ -0,0 +1,1020 @@
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+import { DirectoryDocument, Fragments } from "../document/index.js";
+import { WIKI_GRAPH_EDITOR_SCOPES } from "../common/llm-scope.js";
+import { normalizeLanguageCode } from "../common/language.js";
+import { compressText } from "../editor/index.js";
+import { segmentTextStream } from "../reader/index.js";
+import {
+  SerialGeneration
+} from "../serial.js";
+import { ChunkImportance, ChunkRetention } from "../document/types.js";
+import {
+  getChapterDetails
+} from "./chapter.js";
+const sentenceIdSchema = z.tuple([
+  z.number(),
+  z.number()
+]);
+const GRAPH_ARTIFACT_FRAGMENT_WORDS_COUNT = 320;
+const sentenceRecordSchema = z.object({
+  text: z.string(),
+  wordsCount: z.number()
+});
+const fragmentRecordSchema = z.object({
+  serialId: z.number(),
+  fragmentId: z.number(),
+  summary: z.string(),
+  sentences: z.array(sentenceRecordSchema)
+});
+const serialRecordSchema = z.object({
+  documentOrder: z.number().optional(),
+  id: z.number(),
+  knowledgeGraphReady: z.boolean(),
+  knowledgeGraphParameterHash: z.string().optional(),
+  revision: z.number().optional(),
+  topologyParameterHash: z.string().optional(),
+  topologyReady: z.boolean()
+}).transform((record) => ({
+  documentOrder: record.documentOrder ?? record.id,
+  id: record.id,
+  knowledgeGraphReady: record.knowledgeGraphReady,
+  ...record.knowledgeGraphParameterHash === void 0 ? {} : { knowledgeGraphParameterHash: record.knowledgeGraphParameterHash },
+  revision: record.revision ?? 0,
+  topologyReady: record.topologyReady,
+  ...record.topologyParameterHash === void 0 ? {} : { topologyParameterHash: record.topologyParameterHash }
+}));
+const chunkRecordSchema = z.object({
+  id: z.number(),
+  generation: z.number(),
+  sentenceId: sentenceIdSchema,
+  label: z.string(),
+  content: z.string(),
+  sentenceIds: z.array(sentenceIdSchema),
+  retention: z.enum(ChunkRetention).optional(),
+  importance: z.enum(ChunkImportance).optional(),
+  wordsCount: z.number(),
+  weight: z.number()
+});
+const knowledgeEdgeRecordSchema = z.object({
+  fromId: z.number(),
+  toId: z.number(),
+  strength: z.string().optional(),
+  weight: z.number()
+});
+const snakeRecordSchema = z.object({
+  id: z.number(),
+  serialId: z.number(),
+  groupId: z.number(),
+  localSnakeId: z.number(),
+  size: z.number(),
+  firstLabel: z.string(),
+  lastLabel: z.string(),
+  wordsCount: z.number(),
+  weight: z.number()
+});
+const snakeChunkRecordSchema = z.object({
+  snakeId: z.number(),
+  chunkId: z.number(),
+  position: z.number()
+});
+const snakeEdgeRecordSchema = z.object({
+  fromSnakeId: z.number(),
+  toSnakeId: z.number(),
+  weight: z.number()
+});
+const fragmentGroupRecordSchema = z.object({
+  serialId: z.number(),
+  groupId: z.number(),
+  startSentenceIndex: z.number(),
+  endSentenceIndex: z.number()
+});
+const summaryInputSnapshotSchema = z.object({
+  chunks: z.array(chunkRecordSchema),
+  fragmentGroups: z.array(fragmentGroupRecordSchema),
+  fragments: z.array(fragmentRecordSchema),
+  readingEdges: z.array(knowledgeEdgeRecordSchema),
+  serial: serialRecordSchema,
+  snakeChunks: z.array(snakeChunkRecordSchema),
+  snakeEdges: z.array(snakeEdgeRecordSchema),
+  snakes: z.array(snakeRecordSchema)
+});
+async function readChapterBuildInput(document, chapterId) {
+  const details = await getChapterDetails(document, chapterId);
+  return {
+    details,
+    revision: await document.serials.getRevision(chapterId),
+    sourceText: await collectReaderText(readChapterSource(document, chapterId))
+  };
+}
+async function buildChapterGraphArtifact(chapterId, options) {
+  const documentPath = join(options.workspacePath, "graph-document");
+  await rm(documentPath, { force: true, recursive: true });
+  await mkdir(options.workspacePath, { recursive: true });
+  const document = await DirectoryDocument.open(documentPath);
+  try {
+    await document.openSession(async (openedDocument) => {
+      await openedDocument.serials.createWithId(chapterId);
+      await writeGraphArtifactSourceFragments(
+        documentPath,
+        chapterId,
+        options.sourceText
+      );
+      const artifactDocument = createFragmentBackedDocument(
+        openedDocument,
+        documentPath
+      );
+      await new SerialGeneration({
+        document: artifactDocument,
+        llm: options.llm,
+        ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath }
+      }).buildTopologyInto(
+        chapterId,
+        createTopologyOptions(options),
+        options.progressTracker
+      );
+    });
+  } finally {
+    await document.release();
+  }
+  return {
+    chapterId,
+    documentPath,
+    parameter: createGraphBuildParameterInput(options)
+  };
+}
+async function commitChapterGraphArtifact(document, artifact) {
+  const sourceDocument = await DirectoryDocument.open(artifact.documentPath);
+  try {
+    await document.openSession(async (openedDocument) => {
+      await requireStage(openedDocument, artifact.chapterId, "sourced");
+      await openedDocument.clearSerialGraph(artifact.chapterId);
+      await openedDocument.serials.ensure(artifact.chapterId);
+      const chunkIdMap = await copyChunks(
+        sourceDocument,
+        openedDocument,
+        artifact.chapterId
+      );
+      for (const edge of await sourceDocument.readingEdges.listBySerial(
+        artifact.chapterId
+      )) {
+        const fromId = chunkIdMap.get(edge.fromId);
+        const toId = chunkIdMap.get(edge.toId);
+        if (fromId === void 0 || toId === void 0) {
+          continue;
+        }
+        await openedDocument.readingEdges.save({
+          ...edge,
+          fromId,
+          toId
+        });
+      }
+      await openedDocument.fragmentGroups.saveMany(
+        await sourceDocument.fragmentGroups.listBySerial(artifact.chapterId)
+      );
+      await copySnakes(
+        sourceDocument,
+        openedDocument,
+        artifact.chapterId,
+        chunkIdMap
+      );
+      const parameter = await openedDocument.graphBuildParameters.save(
+        artifact.parameter
+      );
+      await openedDocument.serials.setTopologyReady(
+        artifact.chapterId,
+        true,
+        parameter.hash
+      );
+    });
+    return await getChapterDetails(document, artifact.chapterId);
+  } finally {
+    await sourceDocument.release();
+  }
+}
+async function buildChapterSummaryArtifact(document, chapterId, options) {
+  const snapshotPath = options.snapshotPath;
+  if (snapshotPath !== void 0) {
+    return await buildChapterSummaryArtifactFromSnapshot(chapterId, {
+      ...options,
+      snapshotPath
+    });
+  }
+  const sourceDocumentPath = options.sourceDocumentPath;
+  if (sourceDocumentPath !== void 0) {
+    return await buildChapterSummaryArtifactFromDocumentSnapshot(chapterId, {
+      ...options,
+      sourceDocumentPath
+    });
+  }
+  return await buildChapterSummaryArtifactFromDocument(
+    document,
+    chapterId,
+    options
+  );
+}
+async function buildChapterSummaryArtifactFromSnapshot(chapterId, options) {
+  const snapshot = await readSummaryInputSnapshot(options.snapshotPath);
+  return await buildSummaryFromSnapshot(snapshot, chapterId, options);
+}
+async function buildChapterSummaryArtifactFromDocumentSnapshot(chapterId, options) {
+  const document = await DirectoryDocument.open(options.sourceDocumentPath);
+  try {
+    return await buildChapterSummaryArtifactFromDocument(
+      createFragmentBackedDocument(document, options.sourceDocumentPath),
+      chapterId,
+      options
+    );
+  } finally {
+    await document.release();
+  }
+}
+async function buildChapterSummaryArtifactFromDocument(document, chapterId, options) {
+  const details = await getChapterDetails(document, chapterId);
+  if (details.stage !== "graphed") {
+    throw new Error(
+      `Chapter ${chapterId} is ${details.stage}. Generate a summary only for graphed chapters.`
+    );
+  }
+  const summary = await document.readSummary(chapterId);
+  if (summary !== void 0) {
+    return summary;
+  }
+  return await buildSummaryFromDocument(document, chapterId, options);
+}
+async function commitChapterSummaryArtifact(document, chapterId, summary) {
+  await document.openSession(async (openedDocument) => {
+    await requireStage(openedDocument, chapterId, "graphed");
+    await openedDocument.writeSummary(chapterId, summary);
+  });
+  return await getChapterDetails(document, chapterId);
+}
+async function snapshotChapterSummaryInput(document, chapterId, workspacePath) {
+  const filePath = join(workspacePath, "summary-input.json");
+  await mkdir(workspacePath, { recursive: true });
+  await requireStage(document, chapterId, "graphed");
+  const fragments = await readSerialFragments(document, chapterId);
+  const snakes = await document.snakes.listBySerial(chapterId);
+  const snakeChunks = (await Promise.all(
+    snakes.map(
+      async (snake) => await document.snakeChunks.listBySnake(snake.id)
+    )
+  )).flat();
+  await writeSummaryInputSnapshot(filePath, {
+    chunks: await document.chunks.listBySerial(chapterId),
+    fragmentGroups: await document.fragmentGroups.listBySerial(chapterId),
+    fragments,
+    readingEdges: await document.readingEdges.listBySerial(chapterId),
+    serial: {
+      documentOrder: chapterId,
+      id: chapterId,
+      knowledgeGraphReady: false,
+      revision: 0,
+      topologyReady: true
+    },
+    snakeChunks,
+    snakeEdges: await document.snakeEdges.listBySerial(chapterId),
+    snakes
+  });
+  return { filePath };
+}
+async function buildSummaryFromSnapshot(snapshot, chapterId, options) {
+  if (snapshot.serial.id !== chapterId) {
+    throw new Error(
+      `Summary snapshot belongs to chapter ${snapshot.serial.id}, not chapter ${chapterId}.`
+    );
+  }
+  if (!snapshot.serial.topologyReady) {
+    throw new Error(`Chapter ${chapterId} is not ready for summary.`);
+  }
+  const document = new SummaryInputSnapshotDocument(snapshot);
+  const fragments = document.getSerialFragments(chapterId);
+  const sentenceStartIndexes = await fragments.listFragmentIds();
+  if (sentenceStartIndexes.length <= 1) {
+    return await readPassthroughSummary(fragments, sentenceStartIndexes);
+  }
+  const summaryParts = [];
+  for (const groupId of await document.fragmentGroups.listGroupIdsForSerial(
+    chapterId
+  )) {
+    const groupSummary = await compressText({
+      compressionRatio: 0.2,
+      document,
+      groupId,
+      llm: options.llm,
+      maxClues: 10,
+      maxIterations: 5,
+      scopes: WIKI_GRAPH_EDITOR_SCOPES,
+      serialId: chapterId,
+      ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath },
+      ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage }
+    });
+    if (groupSummary.trim() === "") {
+      continue;
+    }
+    summaryParts.push(groupSummary);
+  }
+  return summaryParts.join("\n\n");
+}
+async function buildSummaryFromDocument(document, chapterId, options) {
+  const serial = await document.serials.getById(chapterId);
+  if (serial === void 0) {
+    throw new Error(
+      `Chapter ${chapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+    );
+  }
+  if (!serial.topologyReady) {
+    throw new Error(`Chapter ${chapterId} is not ready for summary.`);
+  }
+  const fragments = document.getSerialFragments(chapterId);
+  const sentenceStartIndexes = await fragments.listFragmentIds();
+  if (sentenceStartIndexes.length <= 1) {
+    return await readPassthroughSummary(fragments, sentenceStartIndexes);
+  }
+  const summaryParts = [];
+  for (const groupId of await document.fragmentGroups.listGroupIdsForSerial(
+    chapterId
+  )) {
+    const groupSummary = await compressText({
+      compressionRatio: 0.2,
+      document,
+      groupId,
+      llm: options.llm,
+      maxClues: 10,
+      maxIterations: 5,
+      scopes: WIKI_GRAPH_EDITOR_SCOPES,
+      serialId: chapterId,
+      ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath },
+      ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage }
+    });
+    if (groupSummary.trim() === "") {
+      continue;
+    }
+    summaryParts.push(groupSummary);
+  }
+  return summaryParts.join("\n\n");
+}
+async function readPassthroughSummary(fragments, sentenceStartIndexes) {
+  if (sentenceStartIndexes.length === 0) {
+    return "";
+  }
+  const records = await Promise.all(
+    sentenceStartIndexes.map(
+      async (startSentenceIndex) => await fragments.getFragment(startSentenceIndex)
+    )
+  );
+  return records.flatMap((fragment) => fragment.sentences.map((sentence) => sentence.text)).join(" ").trim();
+}
+async function writeGraphArtifactSourceFragments(documentPath, chapterId, sourceText) {
+  const fragments = new Fragments(documentPath);
+  const serial = fragments.getSerial(chapterId);
+  let draft = await serial.createDraft();
+  let draftWordsCount = 0;
+  let hasSentences = false;
+  await fragments.ensureCreated();
+  for await (const sentence of segmentTextStream(sourceText)) {
+    const text = sentence.text.trim();
+    if (text === "") {
+      continue;
+    }
+    if (draftWordsCount > 0 && draftWordsCount + sentence.wordsCount > GRAPH_ARTIFACT_FRAGMENT_WORDS_COUNT) {
+      await draft.commit();
+      draft = await serial.createDraft();
+      draftWordsCount = 0;
+    }
+    draft.addSentence(text, sentence.wordsCount);
+    draftWordsCount += sentence.wordsCount;
+    hasSentences = true;
+  }
+  if (hasSentences) {
+    await draft.commit();
+  } else {
+    draft.discard();
+  }
+}
+function createFragmentBackedDocument(document, documentPath) {
+  const fragments = new Fragments(documentPath);
+  return new Proxy(document, {
+    get(target, property, receiver) {
+      if (property === "getSerialFragments") {
+        return (serialId) => fragments.getSerial(serialId);
+      }
+      if (property === "getSummaryFragments") {
+        return (serialId) => fragments.getSummarySerial(serialId);
+      }
+      if (property === "getSentence") {
+        return async (sentenceId) => await fragments.getSentence(sentenceId);
+      }
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return value.bind(target);
+    }
+  });
+}
+async function readSerialFragments(document, serialId) {
+  const fragments = document.getSerialFragments(serialId);
+  return await Promise.all(
+    (await fragments.listFragmentIds()).map(
+      async (fragmentId) => await fragments.getFragment(fragmentId)
+    )
+  );
+}
+async function readSummaryInputSnapshot(filePath) {
+  const snapshot = summaryInputSnapshotSchema.parse(
+    JSON.parse(await readFile(filePath, "utf8"))
+  );
+  return {
+    ...snapshot,
+    chunks: snapshot.chunks.map(toChunkRecord),
+    readingEdges: snapshot.readingEdges.map(toReadingEdgeRecord)
+  };
+}
+function toChunkRecord(record) {
+  return {
+    id: record.id,
+    generation: record.generation,
+    sentenceId: record.sentenceId,
+    label: record.label,
+    content: record.content,
+    sentenceIds: record.sentenceIds,
+    ...record.retention === void 0 ? {} : { retention: record.retention },
+    ...record.importance === void 0 ? {} : { importance: record.importance },
+    wordsCount: record.wordsCount,
+    weight: record.weight
+  };
+}
+function toReadingEdgeRecord(record) {
+  return {
+    fromId: record.fromId,
+    toId: record.toId,
+    ...record.strength === void 0 ? {} : { strength: record.strength },
+    weight: record.weight
+  };
+}
+async function writeSummaryInputSnapshot(filePath, snapshot) {
+  await writeFile(filePath, `${JSON.stringify(snapshot)}
+`, "utf8");
+}
+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();
+  }
+}
+class EmptySnapshotMentionStore {
+  getById(_mentionId) {
+    return Promise.resolve(void 0);
+  }
+  listAll() {
+    return Promise.resolve([]);
+  }
+  listByQid(_qid) {
+    return Promise.resolve([]);
+  }
+  listBySurfaceTerms(_terms) {
+    return Promise.resolve([]);
+  }
+  listBySurfaces(_surfaces) {
+    return Promise.resolve([]);
+  }
+  listByChapter(_chapterId) {
+    return Promise.resolve([]);
+  }
+}
+class EmptySnapshotMentionLinkStore {
+  getById(_linkId) {
+    return Promise.resolve(void 0);
+  }
+  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);
+  }
+}
+class SnapshotSerialStore {
+  #serial;
+  constructor(serial) {
+    this.#serial = serial;
+  }
+  getById(serialId) {
+    return Promise.resolve(
+      serialId === this.#serial.id ? this.#serial : void 0
+    );
+  }
+  getRevision(serialId) {
+    return Promise.resolve(
+      serialId === this.#serial.id ? this.#serial.revision : 0
+    );
+  }
+  getRevisions(serialIds) {
+    return Promise.resolve(
+      new Map(
+        serialIds.filter((serialId) => serialId === this.#serial.id).map((serialId) => [serialId, this.#serial.revision])
+      )
+    );
+  }
+  getChaptersRevision() {
+    return Promise.resolve(this.#serial.revision);
+  }
+  getMaxId() {
+    return Promise.resolve(this.#serial.id);
+  }
+  listIds() {
+    return Promise.resolve([this.#serial.id]);
+  }
+  listDocumentOrders() {
+    return Promise.resolve(
+      /* @__PURE__ */ new Map([[this.#serial.id, this.#serial.documentOrder]])
+    );
+  }
+}
+class SnapshotSerialFragments {
+  path = "";
+  serialId;
+  #fragmentsById;
+  constructor(serialId, fragments) {
+    this.serialId = serialId;
+    this.#fragmentsById = new Map(
+      fragments.filter((fragment) => fragment.serialId === serialId).map((fragment) => [fragment.fragmentId, fragment])
+    );
+  }
+  getFragment(fragmentId) {
+    const fragment = this.#fragmentsById.get(fragmentId);
+    if (fragment === void 0) {
+      throw new Error(`Fragment ${fragmentId} does not exist`);
+    }
+    return Promise.resolve(fragment);
+  }
+  listFragmentIds() {
+    return Promise.resolve([...this.#fragmentsById.keys()].sort(compareNumber));
+  }
+  async getSentence(sentenceIndex) {
+    const sentence = (await this.listSentences())[sentenceIndex];
+    if (sentence === void 0) {
+      throw new RangeError(`Sentence ${sentenceIndex} does not exist`);
+    }
+    return sentence;
+  }
+  async listSentencesInRange(startSentenceIndex, endSentenceIndex) {
+    return (await this.listSentences()).slice(
+      startSentenceIndex,
+      endSentenceIndex + 1
+    );
+  }
+  async listSentences() {
+    const fragments = await Promise.all(
+      (await this.listFragmentIds()).map(
+        async (fragmentId) => await this.getFragment(fragmentId)
+      )
+    );
+    return fragments.flatMap((fragment) => fragment.sentences);
+  }
+  async readText() {
+    const sentences = await this.listSentences();
+    if (sentences.length === 0) {
+      return void 0;
+    }
+    return sentences.map((sentence) => sentence.text).join("");
+  }
+}
+class SnapshotChunkStore {
+  #chunks;
+  #chunksById;
+  #fragmentStartIndexesBySerialId;
+  constructor(chunks, fragments) {
+    this.#chunks = [...chunks].sort(compareChunkById);
+    this.#chunksById = new Map(chunks.map((chunk) => [chunk.id, chunk]));
+    this.#fragmentStartIndexesBySerialId = createFragmentStartIndexesBySerialId(fragments);
+  }
+  getById(chunkId) {
+    return Promise.resolve(this.#chunksById.get(chunkId));
+  }
+  countAll() {
+    return Promise.resolve(this.#chunks.length);
+  }
+  listAll() {
+    return Promise.resolve([...this.#chunks]);
+  }
+  listBySentenceStartIndexes(serialId, sentenceStartIndexes) {
+    const segmentRanges = createSegmentRanges(
+      this.#fragmentStartIndexesBySerialId.get(serialId) ?? [],
+      sentenceStartIndexes
+    );
+    return Promise.resolve(
+      this.#chunks.filter(
+        (chunk) => chunk.sentenceId[0] === serialId && segmentRanges.some(
+          (range) => chunk.sentenceId[1] >= range.startSentenceIndex && chunk.sentenceId[1] <= range.endSentenceIndex
+        )
+      )
+    );
+  }
+  listBySentenceRange(serialId, startSentenceIndex, endSentenceIndex) {
+    return Promise.resolve(
+      this.#chunks.filter(
+        (chunk) => chunk.sentenceId[0] === serialId && chunk.sentenceId[1] >= startSentenceIndex && chunk.sentenceId[1] <= endSentenceIndex
+      )
+    );
+  }
+  listBySerial(serialId) {
+    return Promise.resolve(
+      this.#chunks.filter((chunk) => chunk.sentenceId[0] === serialId)
+    );
+  }
+  getMaxId() {
+    return Promise.resolve(
+      this.#chunks.reduce((maxId, chunk) => Math.max(maxId, chunk.id), 0)
+    );
+  }
+  listFragmentPairs() {
+    const pairs = /* @__PURE__ */ new Set();
+    for (const chunk of this.#chunks) {
+      pairs.add(`${chunk.sentenceId[0]}:${chunk.sentenceId[1]}`);
+    }
+    return Promise.resolve(
+      [...pairs].map((pair) => pair.split(":").map(Number)).sort(comparePair).map(([serialId, fragmentId]) => [serialId, fragmentId])
+    );
+  }
+}
+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)
+    );
+  }
+}
+async function copySnakes(sourceDocument, targetDocument, serialId, chunkIdMap) {
+  const sourceSnakes = await sourceDocument.snakes.listBySerial(serialId);
+  const snakeIdMap = /* @__PURE__ */ new Map();
+  for (const sourceSnake of sourceSnakes) {
+    const targetSnakeId = await targetDocument.snakes.create({
+      firstLabel: sourceSnake.firstLabel,
+      groupId: sourceSnake.groupId,
+      lastLabel: sourceSnake.lastLabel,
+      localSnakeId: sourceSnake.localSnakeId,
+      serialId,
+      size: sourceSnake.size,
+      weight: sourceSnake.weight,
+      wordsCount: sourceSnake.wordsCount
+    });
+    snakeIdMap.set(sourceSnake.id, targetSnakeId);
+    for (const snakeChunk of await sourceDocument.snakeChunks.listBySnake(
+      sourceSnake.id
+    )) {
+      const chunkId = chunkIdMap.get(snakeChunk.chunkId);
+      if (chunkId === void 0) {
+        continue;
+      }
+      await targetDocument.snakeChunks.save({
+        chunkId,
+        position: snakeChunk.position,
+        snakeId: targetSnakeId
+      });
+    }
+  }
+  for (const edge of await sourceDocument.snakeEdges.listBySerial(serialId)) {
+    const fromSnakeId = snakeIdMap.get(edge.fromSnakeId);
+    const toSnakeId = snakeIdMap.get(edge.toSnakeId);
+    if (fromSnakeId === void 0 || toSnakeId === void 0) {
+      continue;
+    }
+    await targetDocument.snakeEdges.save({
+      fromSnakeId,
+      toSnakeId,
+      weight: edge.weight
+    });
+  }
+}
+async function copyChunks(sourceDocument, targetDocument, serialId) {
+  const chunkIdMap = /* @__PURE__ */ new Map();
+  for (const chunk of await sourceDocument.chunks.listBySerial(serialId)) {
+    const createdChunk = await targetDocument.chunks.create({
+      content: chunk.content,
+      generation: chunk.generation,
+      label: chunk.label,
+      sentenceId: chunk.sentenceId,
+      sentenceIds: chunk.sentenceIds,
+      weight: chunk.weight,
+      wordsCount: chunk.wordsCount,
+      ...chunk.importance === void 0 ? {} : { importance: chunk.importance },
+      ...chunk.retention === void 0 ? {} : { retention: chunk.retention }
+    });
+    chunkIdMap.set(chunk.id, createdChunk.id);
+  }
+  return chunkIdMap;
+}
+async function requireStage(document, chapterId, stage) {
+  const details = await getChapterDetails(document, chapterId);
+  if (details.stage !== stage) {
+    throw new Error(
+      `Chapter ${chapterId} is ${details.stage}. Expected ${stage} before committing build output.`
+    );
+  }
+}
+function createTopologyOptions(options) {
+  return {
+    extractionPrompt: options.extractionPrompt,
+    ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage }
+  };
+}
+function createGraphBuildParameterInput(options) {
+  const language = normalizeLanguageCode(options.userLanguage);
+  return {
+    ...language === void 0 ? {} : { language },
+    prompt: options.extractionPrompt
+  };
+}
+async function* readChapterSource(document, chapterId) {
+  const fragments = document.getSerialFragments(chapterId);
+  for (const fragmentId of await fragments.listFragmentIds()) {
+    const fragment = await fragments.getFragment(fragmentId);
+    for (const sentence of fragment.sentences) {
+      yield sentence.text;
+    }
+  }
+}
+async function collectReaderText(stream) {
+  const text = [];
+  for await (const chunk of stream) {
+    text.push(chunk);
+  }
+  return text;
+}
+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 {
+  buildChapterGraphArtifact,
+  buildChapterSummaryArtifact,
+  buildChapterSummaryArtifactFromSnapshot,
+  commitChapterGraphArtifact,
+  commitChapterSummaryArtifact,
+  readChapterBuildInput,
+  snapshotChapterSummaryInput
+};
+//# sourceMappingURL=chapter-build.js.map