wiki-graph-core 0.3.1 → 0.4.0

package/dist/facade/chapter-build.js

@@ -1,1020 +0,0 @@
-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