wiki-graph-core 0.3.1

package/dist/facade/chapter.js

@@ -0,0 +1,944 @@
+import { normalizeLanguageCode } from "../common/language.js";
+import { z } from "zod";
+import {
+  SerialGeneration,
+  writeSerialSource
+} from "../serial.js";
+import { TOC_FILE_VERSION } from "../source/index.js";
+const CHAPTER_STAGES = [
+  "planned",
+  "sourced",
+  "graphed",
+  "summarized"
+];
+const chapterTreeInputNodeSchema = z.object({
+  children: z.lazy(() => z.array(chapterTreeInputNodeSchema)),
+  id: z.number().int().nonnegative(),
+  title: z.string().nullable().optional()
+}).strict();
+const chapterTreeInputSchema = z.object({
+  chapters: z.array(chapterTreeInputNodeSchema)
+}).strict();
+function parseChapterTreeInput(input) {
+  return chapterTreeInputSchema.parse(input);
+}
+async function advanceChapterStages(document, options) {
+  if (options.targetStage === "planned") {
+    return {
+      advanced: [],
+      pending: await selectChapterEntries(document, options.chapterId),
+      skipped: []
+    };
+  }
+  const advancedIds = /* @__PURE__ */ new Set();
+  const entries = await selectChapterEntries(document, options.chapterId);
+  const progressState = createAdvanceProgressState(
+    entries,
+    options.targetStage
+  );
+  await emitAdvanceProgress(options, {
+    state: progressState.snapshot(),
+    targetStage: options.targetStage,
+    totalChapters: entries.length,
+    type: "selected"
+  });
+  await emitPlannedSkips(entries, options);
+  if (isStageBefore("sourced", options.targetStage)) {
+    await advanceEntriesToGraphed(document, entries, options, {
+      advancedIds,
+      progressState
+    });
+  }
+  if (isStageBefore("graphed", options.targetStage)) {
+    const graphedEntries = await selectChapterEntries(
+      document,
+      options.chapterId
+    );
+    await advanceEntriesToSummarized(document, graphedEntries, options, {
+      advancedIds,
+      progressState
+    });
+  }
+  const nextEntries = await selectChapterEntries(document, options.chapterId);
+  return {
+    advanced: nextEntries.filter((entry) => advancedIds.has(entry.chapterId)),
+    pending: nextEntries.filter(
+      (entry) => isStageBefore(entry.stage, options.targetStage)
+    ),
+    skipped: nextEntries.filter((entry) => entry.stage === "planned")
+  };
+}
+async function addChapter(document, options) {
+  return await document.openSession(async (openedDocument) => {
+    const toc = await normalizeChapterToc(openedDocument);
+    const normalizedTitle = normalizeTitle(options.title);
+    const chapterId = await openedDocument.createSerial();
+    const chapterItem = {
+      children: [],
+      serialId: chapterId,
+      ...normalizedTitle === void 0 ? {} : { title: normalizedTitle }
+    };
+    if (options.parentChapterId === void 0) {
+      toc.items = [...toc.items, chapterItem];
+    } else if (!appendChildToChapter(toc.items, options.parentChapterId, chapterItem)) {
+      throw new Error(
+        `Chapter ${options.parentChapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+      );
+    }
+    await openedDocument.replaceToc(toc);
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function generateChapterGraph(document, chapterId, options) {
+  return await document.openSession(async (openedDocument) => {
+    const details = await requireChapterDetails(openedDocument, chapterId);
+    if (details.stage !== "sourced") {
+      throw new Error(
+        `Chapter ${chapterId} is ${details.stage}. Generate a graph only for sourced chapters.`
+      );
+    }
+    const generation = new SerialGeneration({
+      document: openedDocument,
+      llm: options.llm,
+      ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath }
+    });
+    await openedDocument.clearSerialGraph(chapterId);
+    await generation.buildTopologyInto(
+      chapterId,
+      createTopologyOptions(options),
+      options.progressTracker
+    );
+    const language = normalizeLanguageCode(options.userLanguage);
+    const parameter = await openedDocument.graphBuildParameters.save({
+      prompt: options.extractionPrompt,
+      ...language === void 0 ? {} : { language }
+    });
+    await openedDocument.serials.setTopologyReady(
+      chapterId,
+      true,
+      parameter.hash
+    );
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function generateChapterSummary(document, chapterId, options) {
+  return await document.openSession(async (openedDocument) => {
+    const details = await requireChapterDetails(openedDocument, chapterId);
+    if (details.stage !== "graphed") {
+      throw new Error(
+        `Chapter ${chapterId} is ${details.stage}. Generate a summary only for graphed chapters.`
+      );
+    }
+    const generation = new SerialGeneration({
+      document: openedDocument,
+      llm: options.llm,
+      ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath }
+    });
+    await generation.buildSummary(chapterId, {
+      ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage }
+    });
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function getChapterDetails(document, chapterId) {
+  const toc = await readChapterToc(document);
+  const entry = await findChapterEntry(document, toc.items, chapterId);
+  if (entry === void 0) {
+    throw new Error(
+      `Chapter ${chapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+    );
+  }
+  const serial = await document.serials.getById(chapterId);
+  const summary = await document.readSummary(chapterId);
+  return {
+    ...entry,
+    graphReady: serial?.topologyReady === true,
+    hasSummary: summary !== void 0
+  };
+}
+async function listChapters(document) {
+  const toc = await readChapterToc(document);
+  return await collectChapterEntries(document, toc.items);
+}
+async function getChapterTree(document) {
+  const toc = await readChapterToc(document);
+  return {
+    chapters: toc.items.flatMap(toChapterTreeNodes)
+  };
+}
+async function applyChapterTree(document, tree, options = {}) {
+  return await document.openSession(async (openedDocument) => {
+    const toc = await normalizeChapterToc(openedDocument);
+    const oldItems = toc.items.map(cloneTocItem);
+    const oldMetas = collectTocItemMetas(oldItems);
+    const { items } = createTocItemsFromChapterTree(tree, oldItems);
+    const newMetas = collectTocItemMetas(items);
+    const result = createChapterTreeApplyResult(oldMetas, newMetas);
+    if (options.dryRun !== true && result.changed) {
+      await openedDocument.replaceToc({
+        items,
+        version: toc.version
+      });
+    }
+    return result;
+  });
+}
+async function moveChapter(document, chapterId, options) {
+  return await document.openSession(async (openedDocument) => {
+    const toc = await normalizeChapterToc(openedDocument);
+    const originalLocation = findChapterLocation(toc.items, chapterId);
+    const extracted = extractChapterItem(toc.items, chapterId);
+    if (extracted.item === void 0) {
+      throw new Error(
+        `Chapter ${chapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+      );
+    }
+    rejectMoveIntoOwnSubtree(chapterId, extracted.item, options);
+    toc.items = extracted.items;
+    insertMovedChapter(toc.items, extracted.item, {
+      originalParentChapterId: originalLocation?.parentChapterId,
+      ...options
+    });
+    await openedDocument.replaceToc(toc);
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function removeChapter(document, chapterId, options = {}) {
+  await document.openSession(async (openedDocument) => {
+    const toc = await normalizeChapterToc(openedDocument);
+    const removedChapterIds = [];
+    const result = removeChapterFromItems(toc.items, chapterId, {
+      recursive: options.recursive ?? false,
+      removedChapterIds
+    });
+    if (!result.removed) {
+      throw new Error(
+        `Chapter ${chapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+      );
+    }
+    toc.items = result.items;
+    await openedDocument.replaceToc(toc);
+    for (const removedChapterId of removedChapterIds) {
+      await openedDocument.deleteSerial(removedChapterId);
+    }
+  });
+}
+async function resetChapter(document, chapterId, stage) {
+  return await document.openSession(async (openedDocument) => {
+    await requireChapterDetails(openedDocument, chapterId);
+    switch (stage) {
+      case "planned":
+        await openedDocument.clearSerialSource(chapterId);
+        break;
+      case "sourced":
+        await openedDocument.clearSerialGraph(chapterId);
+        break;
+      case "graphed":
+        await openedDocument.deleteSummary(chapterId);
+        break;
+    }
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function setChapterSource(document, chapterId, stream) {
+  return await document.openSession(async (openedDocument) => {
+    const details = await requireChapterDetails(openedDocument, chapterId);
+    if (details.stage !== "planned") {
+      throw new Error(
+        `Chapter ${chapterId} is ${details.stage}. Reset it to planned before setting source.`
+      );
+    }
+    await writeSerialSource(openedDocument, chapterId, stream);
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function setChapterSummary(document, chapterId, summary) {
+  return await document.openSession(async (openedDocument) => {
+    const details = await requireChapterDetails(openedDocument, chapterId);
+    if (details.stage !== "graphed") {
+      throw new Error(
+        `Chapter ${chapterId} is ${details.stage}. Set a summary only for graphed chapters.`
+      );
+    }
+    await openedDocument.writeSummary(chapterId, summary);
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function setChapterTitle(document, chapterId, title) {
+  return await document.openSession(async (openedDocument) => {
+    const toc = await normalizeChapterToc(openedDocument);
+    const normalizedTitle = normalizeTitle(title);
+    if (!setChapterTitleInItems(toc.items, chapterId, normalizedTitle)) {
+      throw new Error(
+        `Chapter ${chapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+      );
+    }
+    await openedDocument.replaceToc(toc);
+    return await getChapterDetails(openedDocument, chapterId);
+  });
+}
+async function normalizeChapterToc(document) {
+  const existingToc = await document.readToc();
+  const toc = await readChapterToc(document);
+  let changed = false;
+  const normalizeItems = async (items) => {
+    for (const item of items) {
+      if (item.serialId === void 0) {
+        item.serialId = await document.createSerial();
+        changed = true;
+      } else {
+        await document.serials.ensure(item.serialId);
+      }
+      await normalizeItems(item.children);
+    }
+  };
+  await normalizeItems(toc.items);
+  if (existingToc === void 0 || changed) {
+    await document.replaceToc(toc);
+  }
+  return toc;
+}
+async function readChapterToc(document) {
+  const toc = await document.readToc();
+  return toc === void 0 ? { items: [], version: TOC_FILE_VERSION } : {
+    items: toc.items.map(cloneTocItem),
+    version: toc.version
+  };
+}
+async function findChapterEntry(document, items, chapterId, ancestorTitles = [], depth = 0) {
+  for (const item of items) {
+    const title = normalizeTitle(item.title) ?? null;
+    const tocPath = item.serialId === void 0 ? [...ancestorTitles, ...title === null ? [] : [title]] : [...ancestorTitles, title ?? `Chapter ${item.serialId}`];
+    if (item.serialId === chapterId) {
+      return await createChapterEntry(document, item, item.serialId, {
+        depth,
+        title,
+        tocPath
+      });
+    }
+    const childEntry = await findChapterEntry(
+      document,
+      item.children,
+      chapterId,
+      tocPath,
+      depth + 1
+    );
+    if (childEntry !== void 0) {
+      return childEntry;
+    }
+  }
+  return void 0;
+}
+async function collectChapterEntries(document, items, ancestorTitles = [], depth = 0) {
+  const entries = [];
+  for (const item of items) {
+    const title = normalizeTitle(item.title) ?? null;
+    const tocPath = item.serialId === void 0 ? [...ancestorTitles, ...title === null ? [] : [title]] : [...ancestorTitles, title ?? `Chapter ${item.serialId}`];
+    if (item.serialId === void 0) {
+      entries.push(
+        ...await collectChapterEntries(
+          document,
+          item.children,
+          tocPath,
+          depth + 1
+        )
+      );
+      continue;
+    }
+    entries.push(
+      await createChapterEntry(document, item, item.serialId, {
+        depth,
+        title,
+        tocPath
+      })
+    );
+    entries.push(
+      ...await collectChapterEntries(
+        document,
+        item.children,
+        tocPath,
+        depth + 1
+      )
+    );
+  }
+  return entries;
+}
+async function createChapterEntry(document, item, serialId, input) {
+  const [serial, sourceSummary] = await Promise.all([
+    document.serials.getById(serialId),
+    summarizeSerialSource(document, serialId)
+  ]);
+  return {
+    chapterId: serialId,
+    childCount: item.children.length,
+    depth: input.depth,
+    documentOrder: serial?.documentOrder ?? serialId,
+    fragmentCount: sourceSummary.fragmentCount,
+    stage: await resolveChapterStage(
+      document,
+      serialId,
+      sourceSummary.fragmentCount
+    ),
+    title: input.title,
+    tocPath: input.tocPath,
+    words: sourceSummary.words
+  };
+}
+async function summarizeSerialSource(document, serialId) {
+  const sentenceWords = await document.readDatabase(
+    async (database) => await database.queryAll(
+      `
+        SELECT words_count
+        FROM text_sentence_records
+        WHERE kind = 1 AND chapter_id = ?
+        ORDER BY sentence_index
+      `,
+      [serialId],
+      (row) => Number(row.words_count)
+    )
+  );
+  let fragmentCount = 0;
+  let fragmentWords = 0;
+  let words = 0;
+  for (const sentenceWordCount of sentenceWords) {
+    if (fragmentWords > 0 && fragmentWords + sentenceWordCount > 600) {
+      fragmentCount += 1;
+      fragmentWords = 0;
+    }
+    fragmentWords += sentenceWordCount;
+    words += sentenceWordCount;
+  }
+  if (fragmentWords > 0) {
+    fragmentCount += 1;
+  }
+  return {
+    fragmentCount,
+    words
+  };
+}
+async function advanceEntriesToGraphed(document, entries, options, state) {
+  for (const entry of entries) {
+    if (entry.stage !== "sourced") {
+      continue;
+    }
+    await emitAdvanceProgress(options, {
+      chapter: entry,
+      step: "graph",
+      targetStage: options.targetStage,
+      type: "started"
+    });
+    await generateChapterGraph(document, entry.chapterId, {
+      extractionPrompt: options.extractionPrompt,
+      llm: options.llm,
+      ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath },
+      ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage },
+      progressTracker: {
+        async advance(wordsCount) {
+          state.progressState.addGraphWords(wordsCount);
+          await emitAdvanceProgress(options, {
+            state: state.progressState.snapshot(),
+            targetStage: options.targetStage,
+            type: "progress"
+          });
+        },
+        async complete() {
+        }
+      }
+    });
+    await emitAdvanceProgress(options, {
+      chapter: entry,
+      step: "graph",
+      targetStage: options.targetStage,
+      type: "completed"
+    });
+    state.advancedIds.add(entry.chapterId);
+  }
+  return await selectChapterEntries(document, options.chapterId);
+}
+async function advanceEntriesToSummarized(document, entries, options, state) {
+  for (const entry of entries) {
+    if (entry.stage !== "graphed") {
+      continue;
+    }
+    await emitAdvanceProgress(options, {
+      chapter: entry,
+      step: "summary",
+      targetStage: options.targetStage,
+      type: "started"
+    });
+    await generateChapterSummary(document, entry.chapterId, {
+      llm: options.llm,
+      ...options.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath },
+      ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage }
+    });
+    state.progressState.addSummaryWords(entry.words);
+    await emitAdvanceProgress(options, {
+      state: state.progressState.snapshot(),
+      targetStage: options.targetStage,
+      type: "progress"
+    });
+    await emitAdvanceProgress(options, {
+      chapter: entry,
+      step: "summary",
+      targetStage: options.targetStage,
+      type: "completed"
+    });
+    state.advancedIds.add(entry.chapterId);
+  }
+  return await selectChapterEntries(document, options.chapterId);
+}
+async function selectChapterEntries(document, chapterId) {
+  const entries = await listChapters(document);
+  if (chapterId === void 0) {
+    return entries;
+  }
+  const selectedIds = await collectChapterSubtreeIds(document, chapterId);
+  if (selectedIds.size === 0) {
+    throw new Error(
+      `Chapter ${chapterId} does not exist. Use \`wg <archive-uri>/chapter list\` to discover chapter ids.`
+    );
+  }
+  return entries.filter((entry) => selectedIds.has(entry.chapterId));
+}
+function createAdvanceProgressState(entries, targetStage) {
+  const totalGraphWords = isStageBefore("sourced", targetStage) ? entries.filter((entry) => entry.stage === "sourced").reduce((sum, entry) => sum + entry.words, 0) : 0;
+  const totalSummaryWords = isStageBefore("graphed", targetStage) ? entries.filter(
+    (entry) => entry.stage === "graphed" || entry.stage === "sourced"
+  ).reduce((sum, entry) => sum + entry.words, 0) : 0;
+  let graphWords = 0;
+  let summaryWords = 0;
+  return {
+    addGraphWords(words) {
+      graphWords = Math.min(totalGraphWords, graphWords + Math.max(0, words));
+    },
+    addSummaryWords(words) {
+      summaryWords = Math.min(
+        totalSummaryWords,
+        summaryWords + Math.max(0, words)
+      );
+    },
+    snapshot() {
+      return {
+        graphWords,
+        summaryWords,
+        totalGraphWords,
+        totalSummaryWords
+      };
+    }
+  };
+}
+async function collectChapterSubtreeIds(document, chapterId) {
+  const toc = await readChapterToc(document);
+  const selectedIds = /* @__PURE__ */ new Set();
+  for (const item of toc.items) {
+    if (collectChapterSubtreeIdsFromItem(item, chapterId, selectedIds)) {
+      break;
+    }
+  }
+  return selectedIds;
+}
+function collectChapterSubtreeIdsFromItem(item, chapterId, selectedIds) {
+  if (item.serialId === chapterId) {
+    collectChapterIds(item, selectedIds);
+    return true;
+  }
+  for (const child of item.children) {
+    if (collectChapterSubtreeIdsFromItem(child, chapterId, selectedIds)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isStageBefore(stage, targetStage) {
+  return CHAPTER_STAGES.indexOf(stage) < CHAPTER_STAGES.indexOf(targetStage);
+}
+async function emitPlannedSkips(entries, options) {
+  for (const entry of entries) {
+    if (entry.stage !== "planned") {
+      continue;
+    }
+    await emitAdvanceProgress(options, {
+      chapter: entry,
+      reason: "planned",
+      targetStage: options.targetStage,
+      type: "skipped"
+    });
+  }
+}
+async function emitAdvanceProgress(options, event) {
+  try {
+    await options.onProgress?.(event);
+  } catch {
+    return;
+  }
+}
+async function resolveChapterStage(document, chapterId, fragmentCount) {
+  const summarySentenceCount = await document.readDatabase(
+    async (database) => await database.queryOne(
+      `
+          SELECT COUNT(*) AS count
+          FROM text_sentence_records
+          WHERE kind = 2 AND chapter_id = ?
+        `,
+      [chapterId],
+      (row) => Number(row.count)
+    ) ?? 0
+  );
+  if (summarySentenceCount > 0) {
+    return "summarized";
+  }
+  const serial = await document.serials.getById(chapterId);
+  if (serial?.topologyReady === true) {
+    return "graphed";
+  }
+  if (fragmentCount > 0) {
+    return "sourced";
+  }
+  return "planned";
+}
+async function requireChapterDetails(document, chapterId) {
+  return await getChapterDetails(document, chapterId);
+}
+function appendChildToChapter(items, parentChapterId, child) {
+  for (const item of items) {
+    if (item.serialId === parentChapterId) {
+      item.children = [...item.children, child];
+      return true;
+    }
+    if (appendChildToChapter(item.children, parentChapterId, child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createChapterTreeApplyResult(oldMetas, newMetas) {
+  const moved = [];
+  const renamed = [];
+  let unchanged = 0;
+  for (const [chapterId, oldMeta] of oldMetas) {
+    const newMeta = newMetas.get(chapterId);
+    if (newMeta === void 0) {
+      continue;
+    }
+    const movedChapter = oldMeta.parentChapterId !== newMeta.parentChapterId || oldMeta.index !== newMeta.index;
+    const renamedChapter = oldMeta.title !== newMeta.title;
+    if (movedChapter) {
+      moved.push({
+        chapterId,
+        newIndex: newMeta.index,
+        newParentChapterId: newMeta.parentChapterId,
+        newPath: newMeta.path,
+        oldIndex: oldMeta.index,
+        oldParentChapterId: oldMeta.parentChapterId,
+        oldPath: oldMeta.path
+      });
+    }
+    if (renamedChapter) {
+      renamed.push({
+        chapterId,
+        newTitle: newMeta.title,
+        oldTitle: oldMeta.title
+      });
+    }
+    if (!movedChapter && !renamedChapter) {
+      unchanged += 1;
+    }
+  }
+  return {
+    changed: moved.length > 0 || renamed.length > 0,
+    moved,
+    renamed,
+    unchanged
+  };
+}
+function createTocItemsFromChapterTree(tree, oldItems) {
+  const oldItemsById = /* @__PURE__ */ new Map();
+  const oldIds = /* @__PURE__ */ new Set();
+  for (const oldItem of oldItems) {
+    collectTocItemsById(oldItem, oldItemsById, oldIds);
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const items = tree.chapters.map(
+    (node) => createTocItemFromChapterTreeNode(node, oldItemsById, seenIds)
+  );
+  const missingIds = [...oldIds].filter((id) => !seenIds.has(id));
+  if (missingIds.length > 0) {
+    throw new Error(
+      `Chapter tree is missing chapter ids: ${missingIds.join(", ")}.`
+    );
+  }
+  return { items };
+}
+function createTocItemFromChapterTreeNode(node, oldItemsById, seenIds) {
+  const oldItem = oldItemsById.get(node.id);
+  if (oldItem === void 0) {
+    throw new Error(`Chapter tree references unknown chapter id: ${node.id}.`);
+  }
+  if (seenIds.has(node.id)) {
+    throw new Error(`Chapter tree repeats chapter id: ${node.id}.`);
+  }
+  seenIds.add(node.id);
+  const title = Object.prototype.hasOwnProperty.call(node, "title") ? normalizeTitle(node.title) : normalizeTitle(oldItem.title);
+  const item = {
+    children: node.children.map(
+      (child) => createTocItemFromChapterTreeNode(child, oldItemsById, seenIds)
+    ),
+    serialId: node.id
+  };
+  if (title !== void 0) {
+    item.title = title;
+  }
+  return item;
+}
+function collectTocItemsById(item, itemsById, ids) {
+  if (item.serialId !== void 0) {
+    itemsById.set(item.serialId, item);
+    ids.add(item.serialId);
+  }
+  for (const child of item.children) {
+    collectTocItemsById(child, itemsById, ids);
+  }
+}
+function collectTocItemMetas(items, parentChapterId = null, parentPath = []) {
+  const metas = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (item.serialId === void 0) {
+      return;
+    }
+    const title = normalizeTitle(item.title) ?? null;
+    const path = [...parentPath, title ?? `Chapter ${item.serialId}`];
+    metas.set(item.serialId, {
+      index,
+      parentChapterId,
+      path,
+      title
+    });
+    for (const [childId, childMeta] of collectTocItemMetas(
+      item.children,
+      item.serialId,
+      path
+    )) {
+      metas.set(childId, childMeta);
+    }
+  });
+  return metas;
+}
+function extractChapterItem(items, chapterId) {
+  const nextItems = [];
+  for (const item of items) {
+    if (item.serialId === chapterId) {
+      return {
+        item,
+        items: [...nextItems, ...items.slice(nextItems.length + 1)]
+      };
+    }
+    const childResult = extractChapterItem(item.children, chapterId);
+    if (childResult.item !== void 0) {
+      nextItems.push({
+        ...item,
+        children: childResult.items
+      });
+      nextItems.push(...items.slice(nextItems.length));
+      return {
+        item: childResult.item,
+        items: nextItems
+      };
+    }
+    nextItems.push(item);
+  }
+  return {
+    items: [...items]
+  };
+}
+function findChildContainer(items, parentChapterId) {
+  if (parentChapterId === void 0) {
+    return items;
+  }
+  for (const item of items) {
+    if (item.serialId === parentChapterId) {
+      return item.children;
+    }
+    const childContainer = findChildContainer(item.children, parentChapterId);
+    if (childContainer !== void 0) {
+      return childContainer;
+    }
+  }
+  return void 0;
+}
+function findChapterLocation(items, chapterId) {
+  return findChapterLocationInItems(items, chapterId);
+}
+function findChapterLocationInItems(items, chapterId, parentChapterId) {
+  for (const [index, item] of items.entries()) {
+    if (item.serialId === chapterId) {
+      return {
+        index,
+        parentChapterId,
+        siblings: items
+      };
+    }
+    const location = findChapterLocationInItems(
+      item.children,
+      chapterId,
+      item.serialId
+    );
+    if (location !== void 0) {
+      return location;
+    }
+  }
+  return void 0;
+}
+function insertMovedChapter(items, item, options) {
+  if (options.beforeChapterId !== void 0 || options.afterChapterId !== void 0) {
+    const targetChapterId = options.beforeChapterId ?? options.afterChapterId;
+    const location = findChapterLocation(items, targetChapterId);
+    if (location === void 0) {
+      throw new Error(`Target chapter ${targetChapterId} does not exist.`);
+    }
+    location.siblings.splice(
+      options.beforeChapterId === void 0 ? location.index + 1 : location.index,
+      0,
+      item
+    );
+    return;
+  }
+  const parentChapterId = options.root === true ? void 0 : options.parentChapterId !== void 0 ? options.parentChapterId : options.originalParentChapterId;
+  const container = findChildContainer(items, parentChapterId);
+  if (container === void 0) {
+    throw new Error(`Chapter ${parentChapterId} does not exist.`);
+  }
+  if (options.first === true) {
+    container.splice(0, 0, item);
+  } else {
+    container.push(item);
+  }
+}
+function rejectMoveIntoOwnSubtree(chapterId, item, options) {
+  const targetIds = [
+    options.parentChapterId,
+    options.beforeChapterId,
+    options.afterChapterId
+  ].filter((id) => id !== void 0);
+  for (const targetId of targetIds) {
+    if (targetId === chapterId || containsChapterId(item.children, targetId)) {
+      throw new Error(
+        `Cannot move chapter ${chapterId} into or next to its own descendant ${targetId}.`
+      );
+    }
+  }
+}
+function containsChapterId(items, chapterId) {
+  for (const item of items) {
+    if (item.serialId === chapterId || containsChapterId(item.children, chapterId)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cloneTocItem(item) {
+  return {
+    children: item.children.map(cloneTocItem),
+    ...item.serialId === void 0 ? {} : { serialId: item.serialId },
+    title: item.title
+  };
+}
+function toChapterTreeNode(item) {
+  if (item.serialId === void 0) {
+    throw new Error("Internal error: normalized chapter tree has no id.");
+  }
+  return {
+    children: item.children.flatMap(toChapterTreeNodes),
+    id: item.serialId,
+    title: normalizeTitle(item.title) ?? null
+  };
+}
+function toChapterTreeNodes(item) {
+  return item.serialId === void 0 ? item.children.flatMap(toChapterTreeNodes) : [toChapterTreeNode(item)];
+}
+function createTopologyOptions(options) {
+  return {
+    extractionPrompt: options.extractionPrompt,
+    ...options.userLanguage === void 0 ? {} : { userLanguage: options.userLanguage }
+  };
+}
+function normalizeTitle(title) {
+  const normalized = title?.trim();
+  return normalized === void 0 || normalized === "" ? void 0 : normalized;
+}
+function removeChapterFromItems(items, chapterId, options) {
+  const nextItems = [];
+  let removed = false;
+  for (const item of items) {
+    if (item.serialId === chapterId) {
+      if (!options.recursive && item.children.length > 0) {
+        throw new Error(
+          `Chapter ${chapterId} has child chapters. Use --recursive to remove it and its descendants.`
+        );
+      }
+      collectChapterIds(item, options.removedChapterIds);
+      removed = true;
+      continue;
+    }
+    const childResult = removeChapterFromItems(
+      item.children,
+      chapterId,
+      options
+    );
+    nextItems.push({
+      ...item,
+      children: childResult.items
+    });
+    removed ||= childResult.removed;
+  }
+  return {
+    items: nextItems,
+    removed
+  };
+}
+function setChapterTitleInItems(items, chapterId, title) {
+  for (const item of items) {
+    if (item.serialId === chapterId) {
+      if (title === void 0) {
+        delete item.title;
+      } else {
+        item.title = title;
+      }
+      return true;
+    }
+    if (setChapterTitleInItems(item.children, chapterId, title)) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectChapterIds(item, chapterIds) {
+  if (item.serialId !== void 0) {
+    if (Array.isArray(chapterIds)) {
+      chapterIds.push(item.serialId);
+    } else {
+      chapterIds.add(item.serialId);
+    }
+  }
+  for (const child of item.children) {
+    collectChapterIds(child, chapterIds);
+  }
+}
+export {
+  CHAPTER_STAGES,
+  addChapter,
+  advanceChapterStages,
+  applyChapterTree,
+  generateChapterGraph,
+  generateChapterSummary,
+  getChapterDetails,
+  getChapterTree,
+  listChapters,
+  moveChapter,
+  parseChapterTreeInput,
+  removeChapter,
+  resetChapter,
+  setChapterSource,
+  setChapterSummary,
+  setChapterTitle
+};
+//# sourceMappingURL=chapter.js.map