wiki-graph-core 0.3.1 → 0.4.0

package/dist/facade/chapter.js

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