@polishedapps/doc-splitter 0.1.0

package/dist/main.js

@@ -0,0 +1,2294 @@
+#!/usr/bin/env node
+
+// apps/cli/src/main.ts
+import { createRequire } from "node:module";
+import { resolve as resolve4 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// packages/core/src/formats/document-format.ts
+import { extname } from "node:path";
+
+// packages/core/src/issues.ts
+function immutableWarnings(warnings) {
+  return Object.freeze([...warnings]);
+}
+function success(value, warnings = []) {
+  return Object.freeze({
+    ok: true,
+    value,
+    warnings: immutableWarnings(warnings)
+  });
+}
+function failure(error, warnings = []) {
+  return Object.freeze({
+    ok: false,
+    error: Object.freeze({ ...error }),
+    warnings: immutableWarnings(warnings)
+  });
+}
+function warning(code, message, context) {
+  return Object.freeze({
+    code,
+    severity: "warning",
+    message,
+    ...context === void 0 ? {} : { context: Object.freeze({ ...context }) }
+  });
+}
+
+// packages/core/src/formats/document-format.ts
+var DOCUMENT_FORMATS = Object.freeze([
+  Object.freeze({
+    format: "docx",
+    displayName: "DOCX",
+    extensions: Object.freeze([".docx"])
+  }),
+  Object.freeze({
+    format: "pdf",
+    displayName: "PDF",
+    extensions: Object.freeze([".pdf"])
+  })
+]);
+function detectDocumentFormat(inputFilePath) {
+  const extension = extname(inputFilePath).toLowerCase();
+  const definition = DOCUMENT_FORMATS.find(
+    (candidate) => candidate.extensions.includes(extension)
+  );
+  if (definition === void 0) {
+    return failure({
+      code: "unsupported_format",
+      message: "Unsupported input format. Supported extensions are .docx and .pdf.",
+      context: Object.freeze({ extension })
+    });
+  }
+  return success(definition.format);
+}
+
+// packages/core/src/inspection/inspect-document.ts
+import { readFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+
+// packages/core/src/formats/docx/docx-adapter.ts
+import {
+  Document,
+  Paragraph,
+  StructuredDocumentTag,
+  Table,
+  TableOfContentsElement
+} from "docxmlater";
+
+// packages/core/src/formats/document-format-adapter.ts
+var InspectionCallbackError = class extends Error {
+  cause;
+  constructor(cause) {
+    super("The inspection progress callback failed.");
+    this.name = "InspectionCallbackError";
+    this.cause = cause;
+  }
+};
+function reportInspectionProgress(callbacks, progress) {
+  try {
+    callbacks?.onProgress?.(Object.freeze({ ...progress }));
+  } catch (cause) {
+    throw new InspectionCallbackError(cause);
+  }
+}
+
+// packages/core/src/formats/docx/docx-adapter.ts
+function normalizeOutlineLevel(outlineLevel) {
+  return outlineLevel !== void 0 && Number.isInteger(outlineLevel) && outlineLevel >= 0 && outlineLevel <= 8 ? outlineLevel + 1 : null;
+}
+function parseHeadingLevel(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return null;
+  }
+  const digits = [...value].filter((character) => /\d/u.test(character)).join("");
+  const level = Number.parseInt(digits, 10);
+  const normalized = value.replaceAll(" ", "");
+  return normalized.toLowerCase().includes("heading") && level > 0 ? level : null;
+}
+function buildStyleDefinitions(styles) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const style of styles) {
+    if (style.getType() !== "paragraph") {
+      continue;
+    }
+    const styleId = style.getStyleId();
+    if (styleId.trim().length === 0) {
+      continue;
+    }
+    const properties = style.getProperties();
+    definitions.set(styleId.toLowerCase(), {
+      basedOnStyleId: properties.basedOn,
+      explicitLevel: normalizeOutlineLevel(
+        style.getParagraphFormatting()?.outlineLevel
+      ),
+      fallbackLevel: parseHeadingLevel(style.getName()) ?? parseHeadingLevel(styleId)
+    });
+  }
+  return definitions;
+}
+function resolveStyleLevel(styleId, definitions, visitedStyleIds) {
+  const normalizedId = styleId.toLowerCase();
+  const definition = definitions.get(normalizedId);
+  if (definition === void 0) {
+    return null;
+  }
+  if (definition.explicitLevel !== null) {
+    return definition.explicitLevel;
+  }
+  if (definition.basedOnStyleId !== void 0 && definition.basedOnStyleId.trim().length > 0 && !visitedStyleIds.has(normalizedId)) {
+    visitedStyleIds.add(normalizedId);
+    const inheritedLevel = resolveStyleLevel(
+      definition.basedOnStyleId,
+      definitions,
+      visitedStyleIds
+    );
+    if (inheritedLevel !== null) {
+      return inheritedLevel;
+    }
+  }
+  return definition.fallbackLevel;
+}
+function resolveParagraphLevel(paragraph, definitions) {
+  const directOutlineLevel = normalizeOutlineLevel(
+    paragraph.getFormatting().outlineLevel
+  );
+  if (directOutlineLevel !== null) {
+    return directOutlineLevel;
+  }
+  const styleId = paragraph.getStyle();
+  if (styleId === void 0) {
+    return null;
+  }
+  return resolveStyleLevel(styleId, definitions, /* @__PURE__ */ new Set()) ?? parseHeadingLevel(styleId);
+}
+function hasVisibleText(value) {
+  return value.trim().length > 0;
+}
+function rawXmlHasVisibleText(rawXml) {
+  return hasVisibleText(rawXml.replace(/<[^>]*>/gu, " "));
+}
+function hasRawXml(element) {
+  return "getRawXml" in element && typeof element.getRawXml === "function";
+}
+function hasSubstantiveContent(element) {
+  if (element instanceof Paragraph) {
+    return hasVisibleText(element.getText());
+  }
+  if (element instanceof Table) {
+    return element.getRows().some(
+      (row) => row.getCells().some((cell) => hasVisibleText(cell.getText()))
+    );
+  }
+  if (element instanceof StructuredDocumentTag) {
+    return element.getContent().some(hasSubstantiveContent);
+  }
+  if (element instanceof TableOfContentsElement) {
+    return hasVisibleText(element.getTableOfContents().getTitle());
+  }
+  if (hasRawXml(element)) {
+    return rawXmlHasVisibleText(element.getRawXml());
+  }
+  return false;
+}
+async function loadDocx(bytes) {
+  return Document.loadFromBuffer(Buffer.from(bytes));
+}
+async function inspectDocx(source, callbacks) {
+  let document;
+  try {
+    document = await loadDocx(source.bytes);
+    const bodyElements = document.getBodyElements();
+    const styleDefinitions = buildStyleDefinitions(document.getStyles());
+    const totalDocumentLength = bodyElements.length + 1;
+    const headings = [];
+    let contentIndexWithinDocument = 0;
+    for (const [indexWithinDocument, element] of bodyElements.entries()) {
+      if (hasSubstantiveContent(element)) {
+        contentIndexWithinDocument += 1;
+      }
+      if (element instanceof Paragraph) {
+        const level = resolveParagraphLevel(element, styleDefinitions);
+        if (level !== null) {
+          headings.push(
+            Object.freeze({
+              text: element.getText(),
+              level,
+              indexWithinDocument,
+              contentIndexWithinDocument
+            })
+          );
+        }
+      }
+      reportInspectionProgress(callbacks, {
+        completedUnits: indexWithinDocument + 1,
+        totalUnits: totalDocumentLength
+      });
+    }
+    document.getSection();
+    reportInspectionProgress(callbacks, {
+      completedUnits: totalDocumentLength,
+      totalUnits: totalDocumentLength
+    });
+    return success(
+      Object.freeze({
+        totalDocumentLength,
+        headings: Object.freeze(headings)
+      })
+    );
+  } catch (cause) {
+    if (cause instanceof InspectionCallbackError) {
+      throw cause;
+    }
+    return failure({
+      code: "document_unreadable",
+      message: "The DOCX document could not be read.",
+      context: Object.freeze({ sourceFilePath: source.sourceFilePath }),
+      cause
+    });
+  } finally {
+    document?.dispose();
+  }
+}
+async function createDocxSplitDocument(source, startIndexWithinDocument, endIndexWithinDocument) {
+  let document;
+  try {
+    document = await loadDocx(source.bytes);
+    for (let index = document.getBodyElementCount() - 1; index >= 0; index -= 1) {
+      if (index < startIndexWithinDocument || index >= endIndexWithinDocument) {
+        document.removeBodyElementAt(index);
+      }
+    }
+    return success(await document.toBuffer());
+  } catch (cause) {
+    return failure({
+      code: "output_write_failed",
+      message: "The DOCX split document could not be created.",
+      context: Object.freeze({ sourceFilePath: source.sourceFilePath }),
+      cause
+    });
+  } finally {
+    document?.dispose();
+  }
+}
+var docxAdapter = Object.freeze({
+  format: "docx",
+  extensions: Object.freeze([".docx"]),
+  inspect: inspectDocx,
+  createSplitDocument: createDocxSplitDocument
+});
+
+// packages/core/src/formats/pdf/pdf-adapter.ts
+import {
+  PDF,
+  PdfArray,
+  PdfDict,
+  PdfName,
+  PdfNumber,
+  PdfRef,
+  PdfString,
+  SecurityError
+} from "@libpdf/core";
+function resolver(document) {
+  return (reference) => document.getObject(reference);
+}
+function dereference(document, object) {
+  return object instanceof PdfRef ? document.getObject(object) ?? void 0 : object;
+}
+function objectIdentity(raw, resolved) {
+  return raw instanceof PdfRef ? raw.toString() : resolved;
+}
+function getOutlineDestination(document, item) {
+  const direct = item.get("Dest");
+  if (direct !== void 0) {
+    return direct;
+  }
+  const action = item.getDict("A", resolver(document));
+  if (action?.getName("S", resolver(document))?.value !== "GoTo") {
+    return void 0;
+  }
+  return action.get("D");
+}
+function collectOutlineEntries(document) {
+  const outlines = dereference(document, document.getCatalog().get("Outlines"));
+  if (!(outlines instanceof PdfDict)) {
+    return [];
+  }
+  const entries = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visitSiblings = (first, level) => {
+    let raw = first;
+    while (raw !== void 0) {
+      const item = dereference(document, raw);
+      if (!(item instanceof PdfDict)) {
+        return;
+      }
+      const identity = objectIdentity(raw, item);
+      if (visited.has(identity)) {
+        return;
+      }
+      visited.add(identity);
+      if (entries.length >= 1e5) {
+        throw new Error("The PDF outline contains too many entries.");
+      }
+      entries.push(
+        Object.freeze({
+          title: item.getString("Title", resolver(document))?.asString() ?? "",
+          level,
+          destination: getOutlineDestination(document, item)
+        })
+      );
+      visitSiblings(item.get("First"), level + 1);
+      raw = item.get("Next");
+    }
+  };
+  visitSiblings(outlines.get("First"), 1);
+  return Object.freeze(entries);
+}
+function namedDestinationKey(object) {
+  if (object instanceof PdfString) {
+    return object.asString();
+  }
+  if (object instanceof PdfName) {
+    return object.value;
+  }
+  return null;
+}
+function collectNameTree(document, root, output, visited) {
+  const dictionary = dereference(document, root);
+  if (!(dictionary instanceof PdfDict) || root === void 0) {
+    return;
+  }
+  const identity = objectIdentity(root, dictionary);
+  if (visited.has(identity)) {
+    return;
+  }
+  visited.add(identity);
+  const names = dictionary.getArray("Names", resolver(document));
+  if (names !== void 0) {
+    for (let index = 0; index + 1 < names.length; index += 2) {
+      const name = namedDestinationKey(dereference(document, names.at(index)));
+      const destination = names.at(index + 1);
+      if (name !== null && destination !== void 0 && !output.has(name)) {
+        output.set(name, destination);
+      }
+    }
+  }
+  const children = dictionary.getArray("Kids", resolver(document));
+  if (children !== void 0) {
+    for (const child of children) {
+      collectNameTree(document, child, output, visited);
+    }
+  }
+}
+function buildNamedDestinationIndex(document) {
+  const destinations = /* @__PURE__ */ new Map();
+  const catalog = document.getCatalog();
+  const legacyDestinations = catalog.getDict("Dests", resolver(document));
+  if (legacyDestinations !== void 0) {
+    for (const [name, destination] of legacyDestinations) {
+      destinations.set(name.value, destination);
+    }
+  }
+  const names = catalog.getDict("Names", resolver(document));
+  if (names !== void 0) {
+    collectNameTree(
+      document,
+      names.get("Dests"),
+      destinations,
+      /* @__PURE__ */ new Set()
+    );
+  }
+  return Object.freeze({ destinations });
+}
+function unwrapDestination(document, rawDestination, namedDestinations, visitedNames = /* @__PURE__ */ new Set()) {
+  const destination = dereference(document, rawDestination);
+  if (destination instanceof PdfArray) {
+    return { array: destination };
+  }
+  if (destination instanceof PdfDict) {
+    return unwrapDestination(
+      document,
+      destination.get("D"),
+      namedDestinations,
+      visitedNames
+    );
+  }
+  const name = namedDestinationKey(destination);
+  if (name !== null) {
+    if (visitedNames.has(name)) {
+      return { reason: `Named destination '${name}' contains a cycle.` };
+    }
+    const named = namedDestinations.destinations.get(name);
+    if (named === void 0) {
+      return { reason: `Named destination '${name}' was not found.` };
+    }
+    visitedNames.add(name);
+    return unwrapDestination(document, named, namedDestinations, visitedNames);
+  }
+  return { reason: "The outline entry has no resolvable local destination." };
+}
+function resolveDestinationPage(document, rawDestination, namedDestinations, pageIndexesByReference) {
+  const unwrapped = unwrapDestination(
+    document,
+    rawDestination,
+    namedDestinations
+  );
+  if (unwrapped.array === void 0) {
+    return {
+      reason: unwrapped.reason ?? "The outline destination could not be resolved."
+    };
+  }
+  const pageTarget = unwrapped.array.at(0);
+  if (pageTarget instanceof PdfRef) {
+    const pageIndex = pageIndexesByReference.get(pageTarget.toString());
+    return pageIndex === void 0 ? { reason: `Page reference '${pageTarget.toString()}' was not found.` } : { pageIndex };
+  }
+  const resolvedPage = dereference(document, pageTarget);
+  if (resolvedPage instanceof PdfDict) {
+    const pageReference = document.context.getRef(resolvedPage);
+    const pageIndex = pageReference === null ? void 0 : pageIndexesByReference.get(pageReference.toString());
+    return pageIndex === void 0 ? { reason: "The destination page dictionary is not in the page tree." } : { pageIndex };
+  }
+  if (resolvedPage instanceof PdfNumber && Number.isInteger(resolvedPage.value) && resolvedPage.value >= 0 && resolvedPage.value < document.getPageCount()) {
+    return { pageIndex: resolvedPage.value };
+  }
+  return { reason: "The destination does not identify a document page." };
+}
+function unreadablePdf(source, cause) {
+  return failure({
+    code: "document_unreadable",
+    message: "The PDF document could not be read.",
+    context: Object.freeze({ sourceFilePath: source.sourceFilePath }),
+    cause
+  });
+}
+function unsupportedEncryption(source, cause) {
+  return failure({
+    code: "encrypted_document_unsupported",
+    message: "Encrypted PDF documents are not supported.",
+    context: Object.freeze({ sourceFilePath: source.sourceFilePath }),
+    ...cause === void 0 ? {} : { cause }
+  });
+}
+async function inspectPdf(source, callbacks) {
+  try {
+    const document = await PDF.load(source.bytes);
+    if (document.isEncrypted) {
+      return unsupportedEncryption(source);
+    }
+    const pages = document.getPages();
+    const pageIndexesByReference = new Map(
+      pages.map((page) => [page.ref.toString(), page.index])
+    );
+    const namedDestinations = buildNamedDestinationIndex(document);
+    const outlineEntries = collectOutlineEntries(document);
+    const headings = [];
+    const warnings = [];
+    for (const [index, entry] of outlineEntries.entries()) {
+      const destination = resolveDestinationPage(
+        document,
+        entry.destination,
+        namedDestinations,
+        pageIndexesByReference
+      );
+      if (destination.pageIndex === void 0) {
+        warnings.push(
+          warning(
+            "unresolved_pdf_outline_destination",
+            `PDF outline entry '${entry.title || "BLANK"}' was skipped: ${destination.reason ?? "unknown destination error"}`,
+            {
+              title: entry.title,
+              level: entry.level,
+              outlineIndex: index,
+              reason: destination.reason ?? "unknown destination error"
+            }
+          )
+        );
+      } else {
+        headings.push(
+          Object.freeze({
+            text: entry.title,
+            level: entry.level,
+            indexWithinDocument: destination.pageIndex,
+            contentIndexWithinDocument: destination.pageIndex + 1
+          })
+        );
+      }
+      reportInspectionProgress(callbacks, {
+        completedUnits: index + 1,
+        totalUnits: outlineEntries.length
+      });
+    }
+    return success(
+      Object.freeze({
+        totalDocumentLength: document.getPageCount(),
+        headings: Object.freeze(headings)
+      }),
+      warnings
+    );
+  } catch (cause) {
+    if (cause instanceof InspectionCallbackError) {
+      throw cause;
+    }
+    return cause instanceof SecurityError ? unsupportedEncryption(source, cause) : unreadablePdf(source, cause);
+  }
+}
+async function createPdfSplitDocument(source, startIndexWithinDocument, endIndexWithinDocument) {
+  try {
+    const document = await PDF.load(source.bytes);
+    for (let index = document.getPageCount() - 1; index >= endIndexWithinDocument; index -= 1) {
+      document.removePage(index);
+    }
+    for (let index = startIndexWithinDocument - 1; index >= 0; index -= 1) {
+      document.removePage(index);
+    }
+    return success(await document.save());
+  } catch (cause) {
+    return failure({
+      code: "output_write_failed",
+      message: "The PDF split document could not be created.",
+      context: Object.freeze({ sourceFilePath: source.sourceFilePath }),
+      cause
+    });
+  }
+}
+var pdfAdapter = Object.freeze({
+  format: "pdf",
+  extensions: Object.freeze([".pdf"]),
+  inspect: inspectPdf,
+  createSplitDocument: createPdfSplitDocument
+});
+
+// packages/core/src/formats/adapter-registry.ts
+var adapters = /* @__PURE__ */ new Map([
+  ["docx", docxAdapter],
+  ["pdf", pdfAdapter]
+]);
+function getDocumentAdapter(format) {
+  const adapter = adapters.get(format);
+  if (adapter === void 0) {
+    return failure({
+      code: "internal_error",
+      message: `No document adapter is registered for '${format}'.`,
+      context: Object.freeze({ format })
+    });
+  }
+  return success(adapter);
+}
+
+// packages/core/src/inspection/heading-hierarchy.ts
+function invalidHierarchy(message, context) {
+  return failure({
+    code: "internal_error",
+    message,
+    ...context === void 0 ? {} : { context }
+  });
+}
+function normalizeWhitespace(value) {
+  return value.trim().replace(/\s+/gu, " ");
+}
+function validateCandidate(candidate, index, previous) {
+  if (!Number.isInteger(candidate.level) || candidate.level < 1) {
+    return invalidHierarchy("A heading candidate has an invalid level.", {
+      candidateIndex: index,
+      level: candidate.level
+    });
+  }
+  if (!Number.isInteger(candidate.indexWithinDocument) || candidate.indexWithinDocument < 0) {
+    return invalidHierarchy(
+      "A heading candidate has an invalid index within the document.",
+      {
+        candidateIndex: index,
+        indexWithinDocument: candidate.indexWithinDocument
+      }
+    );
+  }
+  if (!Number.isInteger(candidate.contentIndexWithinDocument) || candidate.contentIndexWithinDocument < 0) {
+    return invalidHierarchy(
+      "A heading candidate has an invalid content index within the document.",
+      {
+        candidateIndex: index,
+        contentIndexWithinDocument: candidate.contentIndexWithinDocument
+      }
+    );
+  }
+  if (previous !== void 0 && (candidate.indexWithinDocument < previous.indexWithinDocument || candidate.contentIndexWithinDocument < previous.contentIndexWithinDocument)) {
+    return invalidHierarchy("Heading candidates are not in document order.", {
+      candidateIndex: index
+    });
+  }
+  return success(void 0);
+}
+function findParentNode(level, lastHeadingByLevel) {
+  for (let candidateLevel = level - 1; candidateLevel >= 1; candidateLevel -= 1) {
+    const parent = lastHeadingByLevel.get(candidateLevel);
+    if (parent !== void 0) {
+      return parent;
+    }
+  }
+  return null;
+}
+function normalizeSingleTopLevelHeading(headings) {
+  if (headings.length <= 1 || headings[0].level !== 1 || headings.filter((heading) => heading.level === 1).length !== 1) {
+    return Object.freeze({
+      headings,
+      omittedFirstHeading: false
+    });
+  }
+  const normalizedHeadings = [];
+  const positionsByLevel = /* @__PURE__ */ new Map();
+  const lastHeadingByLevel = /* @__PURE__ */ new Map();
+  for (const sourceHeading of headings.slice(1)) {
+    const level = Math.max(1, sourceHeading.level - 1);
+    const positionWithinLevel = (positionsByLevel.get(level) ?? 0) + 1;
+    const heading = Object.freeze({
+      text: sourceHeading.text,
+      normalizedText: sourceHeading.normalizedText,
+      level,
+      indexWithinDocument: sourceHeading.indexWithinDocument,
+      contentIndexWithinDocument: sourceHeading.contentIndexWithinDocument - 1,
+      positionWithinLevel,
+      parentNode: findParentNode(level, lastHeadingByLevel),
+      isBlank: sourceHeading.isBlank
+    });
+    normalizedHeadings.push(heading);
+    positionsByLevel.set(level, positionWithinLevel);
+    lastHeadingByLevel.set(level, heading);
+    for (const previousLevel of [...lastHeadingByLevel.keys()]) {
+      if (previousLevel > level) {
+        lastHeadingByLevel.delete(previousLevel);
+      }
+    }
+  }
+  return Object.freeze({
+    headings: Object.freeze(normalizedHeadings),
+    omittedFirstHeading: true
+  });
+}
+function buildHeadingHierarchy(input) {
+  if (!Number.isInteger(input.totalDocumentLength) || input.totalDocumentLength < 0) {
+    return invalidHierarchy(
+      "The document has an invalid total document length.",
+      {
+        totalDocumentLength: input.totalDocumentLength
+      }
+    );
+  }
+  const headings = [];
+  const warnings = [];
+  const positionsByLevel = /* @__PURE__ */ new Map();
+  const lastHeadingByLevel = /* @__PURE__ */ new Map();
+  for (const [index, candidate] of input.candidates.entries()) {
+    const candidateValidation = validateCandidate(
+      candidate,
+      index,
+      input.candidates[index - 1]
+    );
+    if (!candidateValidation.ok) {
+      return candidateValidation;
+    }
+    const normalized = normalizeWhitespace(candidate.text);
+    const isBlank = normalized.length === 0;
+    const positionWithinLevel = (positionsByLevel.get(candidate.level) ?? 0) + 1;
+    const heading = Object.freeze({
+      text: normalized,
+      normalizedText: isBlank ? "BLANK" : normalized,
+      level: candidate.level,
+      indexWithinDocument: candidate.indexWithinDocument,
+      contentIndexWithinDocument: candidate.contentIndexWithinDocument,
+      positionWithinLevel,
+      parentNode: findParentNode(candidate.level, lastHeadingByLevel),
+      isBlank
+    });
+    headings.push(heading);
+    positionsByLevel.set(candidate.level, positionWithinLevel);
+    lastHeadingByLevel.set(candidate.level, heading);
+    for (const level of [...lastHeadingByLevel.keys()]) {
+      if (level > candidate.level) {
+        lastHeadingByLevel.delete(level);
+      }
+    }
+    if (isBlank) {
+      warnings.push(
+        warning("blank_heading", "A blank heading was retained as BLANK.", {
+          headingNumber: index + 1,
+          indexWithinDocument: candidate.indexWithinDocument
+        })
+      );
+    }
+  }
+  const normalization = normalizeSingleTopLevelHeading(
+    Object.freeze([...headings])
+  );
+  const retainedWarnings = normalization.omittedFirstHeading ? warnings.filter(
+    (issue) => issue.code !== "blank_heading" || issue.context?.headingNumber !== 1
+  ) : warnings;
+  const maximumLevel = normalization.headings.reduce(
+    (maximum, heading) => Math.max(maximum, heading.level),
+    0
+  );
+  return success(
+    Object.freeze({
+      headings: normalization.headings,
+      hasCoverContent: normalization.headings.length > 0 && normalization.headings[0].contentIndexWithinDocument > 1,
+      maxHeadingLevel: maximumLevel
+    }),
+    retainedWarnings
+  );
+}
+
+// packages/core/src/inspection/inspect-document.ts
+function filesystemFailure(sourceFilePath, cause) {
+  const code = cause !== null && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  const notFound = code === "ENOENT";
+  return failure({
+    code: notFound ? "input_not_found" : "input_not_readable",
+    message: notFound ? `Input file was not found: ${sourceFilePath}` : `Input file could not be read: ${sourceFilePath}`,
+    context: Object.freeze({ sourceFilePath }),
+    cause
+  });
+}
+function internalFailure(cause) {
+  const callbackFailure = cause instanceof InspectionCallbackError;
+  return failure({
+    code: "internal_error",
+    message: callbackFailure ? "The inspection progress callback failed." : "Document inspection failed unexpectedly.",
+    cause: callbackFailure ? cause.cause : cause
+  });
+}
+function headingArrayIndexFromIssue(issue) {
+  if (issue.code !== "blank_heading") {
+    return null;
+  }
+  const headingNumber = issue.context?.headingNumber;
+  if (!Number.isInteger(headingNumber) || headingNumber < 1) {
+    return null;
+  }
+  return headingNumber - 1;
+}
+function mergeWarnings(format, adapterWarnings, hierarchyWarnings) {
+  if (format !== "pdf" || adapterWarnings.length === 0) {
+    return Object.freeze([...adapterWarnings, ...hierarchyWarnings]);
+  }
+  const unresolvedIndexes = new Set(
+    adapterWarnings.flatMap((issue) => {
+      const value = issue.context?.outlineIndex;
+      return Number.isInteger(value) ? [value] : [];
+    })
+  );
+  const outlineIndexForHeading = (headingIndex) => {
+    let retainedIndex = -1;
+    for (let outlineIndex = 0; ; outlineIndex += 1) {
+      if (!unresolvedIndexes.has(outlineIndex)) {
+        retainedIndex += 1;
+        if (retainedIndex === headingIndex) {
+          return outlineIndex;
+        }
+      }
+    }
+  };
+  return Object.freeze(
+    [...adapterWarnings, ...hierarchyWarnings].map((issue, stableIndex) => {
+      const adapterIndex = issue.context?.outlineIndex;
+      const headingIndex = headingArrayIndexFromIssue(issue);
+      const sourceIndex = Number.isInteger(adapterIndex) ? adapterIndex : headingIndex === null ? Number.MAX_SAFE_INTEGER : outlineIndexForHeading(headingIndex);
+      return { issue, sourceIndex, stableIndex };
+    }).sort(
+      (left, right) => left.sourceIndex - right.sourceIndex || left.stableIndex - right.stableIndex
+    ).map(({ issue }) => issue)
+  );
+}
+async function inspectDocument(inputFilePath, callbacks) {
+  const sourceFilePath = resolve(inputFilePath);
+  const sourceFilename = basename(sourceFilePath);
+  const detectedFormat = detectDocumentFormat(inputFilePath);
+  if (!detectedFormat.ok) {
+    return detectedFormat;
+  }
+  let bytes;
+  try {
+    bytes = await readFile(sourceFilePath);
+  } catch (cause) {
+    return filesystemFailure(sourceFilePath, cause);
+  }
+  const registeredAdapter = getDocumentAdapter(detectedFormat.value);
+  if (!registeredAdapter.ok) {
+    return registeredAdapter;
+  }
+  try {
+    const adapterResult = await registeredAdapter.value.inspect(
+      { sourceFilePath, bytes },
+      callbacks
+    );
+    if (!adapterResult.ok) {
+      return adapterResult;
+    }
+    const hierarchyResult = buildHeadingHierarchy({
+      format: detectedFormat.value,
+      totalDocumentLength: adapterResult.value.totalDocumentLength,
+      candidates: adapterResult.value.headings
+    });
+    if (!hierarchyResult.ok) {
+      return failure(hierarchyResult.error, adapterResult.warnings);
+    }
+    const warnings = mergeWarnings(
+      detectedFormat.value,
+      adapterResult.warnings,
+      hierarchyResult.warnings
+    );
+    const inspection = Object.freeze({
+      format: detectedFormat.value,
+      sourceFilePath,
+      sourceFilename,
+      sourceBytes: bytes,
+      totalDocumentLength: adapterResult.value.totalDocumentLength,
+      hasCoverContent: hierarchyResult.value.hasCoverContent,
+      maxHeadingLevel: hierarchyResult.value.maxHeadingLevel,
+      headings: hierarchyResult.value.headings,
+      warnings
+    });
+    return success(inspection, warnings);
+  } catch (cause) {
+    return internalFailure(cause);
+  }
+}
+
+// packages/core/src/planning/filename-rules.ts
+var WINDOWS_RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function normalizeStructuralPunctuation(value) {
+  let normalized = "";
+  for (const character of value) {
+    if (character === ":" || character === ";" || character === "|" || character === "/" || character === "\\") {
+      normalized += " - ";
+    } else if (character === "?" || character === "!" || character === "*" || character === '"' || character === "<" || character === ">" || /[\p{Cc}]/u.test(character)) {
+      normalized += " ";
+    } else {
+      normalized += character;
+    }
+  }
+  return normalized;
+}
+function trimFilesystemUnsafeEdges(value) {
+  return value.trim().replace(/^\.+|\.+$/gu, "").trim().replace(/^-+|-+$/gu, "").trim();
+}
+function toTitleCase(value) {
+  const lower = value.toLocaleLowerCase();
+  return lower.replace(
+    new RegExp("(^|[^\\p{L}\\p{N}])(\\p{L})", "gu"),
+    (_match, prefix, letter) => `${prefix}${letter.toLocaleUpperCase()}`
+  );
+}
+function normalizeFilenameComponent(input, transformToTitleCase) {
+  let value = input.trim().length === 0 ? "BLANK" : input.trim();
+  value = normalizeStructuralPunctuation(value);
+  value = value.replace(/\s+/gu, " ").trim();
+  value = trimFilesystemUnsafeEdges(value);
+  if (transformToTitleCase) {
+    value = toTitleCase(value);
+  }
+  if (WINDOWS_RESERVED_NAMES.has(value.toUpperCase())) {
+    value = `${value}_`;
+  }
+  return value.trim().length === 0 ? "BLANK" : value;
+}
+
+// packages/core/src/planning/plan-split.ts
+function sortedHeadings(headings, sourceOrder) {
+  return [...headings].sort(
+    (left, right) => left.indexWithinDocument - right.indexWithinDocument || (sourceOrder.get(left) ?? 0) - (sourceOrder.get(right) ?? 0)
+  );
+}
+function buildChildrenByParent(headings, sourceOrder) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const heading of headings) {
+    if (heading.parentNode === null) {
+      continue;
+    }
+    const siblings = childrenByParent.get(heading.parentNode) ?? [];
+    siblings.push(heading);
+    childrenByParent.set(heading.parentNode, siblings);
+  }
+  return new Map(
+    [...childrenByParent].map(([parent, children]) => [
+      parent,
+      Object.freeze(sortedHeadings(children, sourceOrder))
+    ])
+  );
+}
+function needsParentIntroOutput(heading, children) {
+  const firstChild = children[0];
+  return firstChild !== void 0 && firstChild.contentIndexWithinDocument > heading.contentIndexWithinDocument + 1;
+}
+function collectOutputHeadings(heading, splitAtLevel, childrenByParent, selected) {
+  if (heading.level === splitAtLevel) {
+    selected.push(heading);
+    return true;
+  }
+  const children = childrenByParent.get(heading) ?? [];
+  if (children.length === 0) {
+    selected.push(heading);
+    return true;
+  }
+  let subtreeProducedOutput = false;
+  for (const child of children) {
+    subtreeProducedOutput = collectOutputHeadings(child, splitAtLevel, childrenByParent, selected) || subtreeProducedOutput;
+  }
+  if (subtreeProducedOutput && needsParentIntroOutput(heading, children)) {
+    selected.push(heading);
+    return true;
+  }
+  if (!subtreeProducedOutput) {
+    selected.push(heading);
+    return true;
+  }
+  return false;
+}
+function selectOutputHeadings(headings, sourceOrder, childrenByParent, splitAtLevel) {
+  const roots = sortedHeadings(
+    headings.filter((heading) => heading.parentNode === null),
+    sourceOrder
+  );
+  const selected = [];
+  for (const root of roots) {
+    collectOutputHeadings(root, splitAtLevel, childrenByParent, selected);
+  }
+  return Object.freeze(sortedHeadings(selected, sourceOrder));
+}
+function isDescendantOf(candidate, ancestor) {
+  let current = candidate.parentNode;
+  while (current !== null) {
+    if (current === ancestor) {
+      return true;
+    }
+    current = current.parentNode;
+  }
+  return false;
+}
+function isFirstSelectedDescendant(heading, ancestor, selected) {
+  return selected.find((candidate) => isDescendantOf(candidate, ancestor)) === heading;
+}
+function outputStartIndex(heading, itemIndex, hasCoverContent, selected, selectedSet) {
+  let startIndex = itemIndex === 0 && !hasCoverContent ? 0 : heading.indexWithinDocument;
+  let ancestor = heading.parentNode;
+  while (ancestor !== null && !selectedSet.has(ancestor) && isFirstSelectedDescendant(heading, ancestor, selected)) {
+    startIndex = ancestor.indexWithinDocument;
+    ancestor = ancestor.parentNode;
+  }
+  return startIndex;
+}
+function isParentIntroOutput(heading, splitAtLevel, childrenByParent, selected) {
+  if (heading.level >= splitAtLevel) {
+    return false;
+  }
+  const children = childrenByParent.get(heading) ?? [];
+  return needsParentIntroOutput(heading, children) && selected.some(
+    (candidate) => candidate !== heading && isDescendantOf(candidate, heading)
+  );
+}
+function assignSiblingPositions(siblings, childrenByParent, siblingPositions, siblingCounts) {
+  siblings.forEach((heading, index) => {
+    siblingPositions.set(heading, index + 1);
+    siblingCounts.set(heading, siblings.length);
+    assignSiblingPositions(
+      childrenByParent.get(heading) ?? [],
+      childrenByParent,
+      siblingPositions,
+      siblingCounts
+    );
+  });
+}
+function buildHeadingIndexMetrics(headings, sourceOrder, childrenByParent) {
+  const roots = sortedHeadings(
+    headings.filter((heading) => heading.parentNode === null),
+    sourceOrder
+  );
+  const siblingPositions = /* @__PURE__ */ new Map();
+  const siblingCounts = /* @__PURE__ */ new Map();
+  assignSiblingPositions(
+    roots,
+    childrenByParent,
+    siblingPositions,
+    siblingCounts
+  );
+  return { siblingPositions, siblingCounts };
+}
+function indexWidth(heading, metrics) {
+  return String(metrics.siblingCounts.get(heading) ?? 1).length;
+}
+function siblingPosition(heading, metrics) {
+  return metrics.siblingPositions.get(heading) ?? heading.positionWithinLevel;
+}
+function simpleNodeIndex(heading, metrics) {
+  return String(siblingPosition(heading, metrics)).padStart(
+    indexWidth(heading, metrics),
+    "0"
+  );
+}
+function nodeChain(heading) {
+  const nodes = [];
+  let current = heading;
+  while (current !== null) {
+    nodes.unshift(current);
+    current = current.parentNode;
+  }
+  return nodes;
+}
+function nodeChainIndex(heading, metrics) {
+  return nodeChain(heading).map((node) => simpleNodeIndex(node, metrics)).join(".");
+}
+function parentIntroDisplayIndex(heading, options, metrics) {
+  return options.useMultiLevelIndexInFilenames ? `${nodeChainIndex(heading, metrics)}.0` : "0";
+}
+function outputIndex(heading, options, itemIndex, overallWidth, metrics, parentIntro) {
+  if (parentIntro) {
+    return parentIntroDisplayIndex(heading, options, metrics);
+  }
+  if (options.useMultiLevelIndexInFilenames) {
+    return nodeChainIndex(heading, metrics);
+  }
+  if (options.parentHeadingMode !== "notUsed") {
+    return simpleNodeIndex(heading, metrics);
+  }
+  return String(itemIndex).padStart(overallWidth, "0");
+}
+function indexedSegment(headingName, heading, options, itemIndex, overallWidth, metrics, parentIntro) {
+  return options.addIndexToFilenames ? `${outputIndex(heading, options, itemIndex, overallWidth, metrics, parentIntro)} - ${headingName}` : headingName;
+}
+function indexedParentSegment(headingName, heading, options, metrics) {
+  if (!options.addIndexToFilenames) {
+    return headingName;
+  }
+  const index = options.useMultiLevelIndexInFilenames ? nodeChainIndex(heading, metrics) : simpleNodeIndex(heading, metrics);
+  return `${index} - ${headingName}`;
+}
+function parentSegments(heading, options, metrics) {
+  return nodeChain(heading).slice(0, -1).map(
+    (parent) => indexedParentSegment(
+      normalizeFilenameComponent(parent.text, options.transformToTitleCase),
+      parent,
+      options,
+      metrics
+    )
+  );
+}
+function joinFilenameParts(parts) {
+  return parts.filter((part) => part.trim().length > 0).join(" - ");
+}
+function buildHeadingRelativePath(input) {
+  const headingName = normalizeFilenameComponent(
+    input.heading.text,
+    input.options.transformToTitleCase
+  );
+  if (input.options.parentHeadingMode === "notUsed") {
+    const parts = input.options.includeOriginalFilename ? [input.originalStem] : [];
+    if (input.options.addIndexToFilenames) {
+      parts.push(
+        outputIndex(
+          input.heading,
+          input.options,
+          input.itemIndex,
+          input.overallWidth,
+          input.metrics,
+          input.parentIntro
+        )
+      );
+    }
+    parts.push(headingName);
+    return `${joinFilenameParts(parts)}${input.extension}`;
+  }
+  const parents = parentSegments(input.heading, input.options, input.metrics);
+  const headingSegment = indexedSegment(
+    headingName,
+    input.heading,
+    input.options,
+    input.itemIndex,
+    input.overallWidth,
+    input.metrics,
+    input.parentIntro
+  );
+  if (input.options.parentHeadingMode === "inFilename") {
+    return `${joinFilenameParts([
+      ...input.options.includeOriginalFilename ? [input.originalStem] : [],
+      ...parents,
+      headingSegment
+    ])}${input.extension}`;
+  }
+  if (input.parentIntro) {
+    const folders = [
+      ...parents,
+      indexedParentSegment(
+        headingName,
+        input.heading,
+        input.options,
+        input.metrics
+      )
+    ];
+    const introHeading = input.options.addIndexToFilenames ? `${parentIntroDisplayIndex(input.heading, input.options, input.metrics)} - ${headingName}` : headingName;
+    const filename2 = `${joinFilenameParts([
+      ...input.options.includeOriginalFilename ? [input.originalStem] : [],
+      introHeading
+    ])}${input.extension}`;
+    return [...folders, filename2].join("/");
+  }
+  const filename = `${joinFilenameParts([
+    ...input.options.includeOriginalFilename ? [input.originalStem] : [],
+    headingSegment
+  ])}${input.extension}`;
+  return [...parents, filename].join("/");
+}
+function rootHeading(heading) {
+  let current = heading;
+  while (current.parentNode !== null) {
+    current = current.parentNode;
+  }
+  return current;
+}
+function buildCoverRelativePath(options, originalStem, extension, selected) {
+  const width = options.parentHeadingMode === "notUsed" ? String(selected.length).length : String(new Set(selected.map(rootHeading)).size).length;
+  const cover = options.addIndexToFilenames ? `${"0".padStart(Math.max(1, width), "0")} - Cover` : "Cover";
+  return `${joinFilenameParts([
+    ...options.includeOriginalFilename ? [originalStem] : [],
+    cover
+  ])}${extension}`;
+}
+function filenameParts(sourceFilename, format) {
+  const finalSeparator = Math.max(
+    sourceFilename.lastIndexOf("/"),
+    sourceFilename.lastIndexOf("\\")
+  );
+  const filename = sourceFilename.slice(finalSeparator + 1);
+  const finalDot = filename.lastIndexOf(".");
+  return finalDot > 0 ? { stem: filename.slice(0, finalDot), extension: filename.slice(finalDot) } : { stem: filename, extension: `.${format}` };
+}
+function collisionKey(relativePath) {
+  return relativePath.toLowerCase();
+}
+function suffixRelativePath(relativePath, suffix) {
+  const slash = relativePath.lastIndexOf("/");
+  const directory = slash < 0 ? "" : relativePath.slice(0, slash + 1);
+  const filename = relativePath.slice(slash + 1);
+  const dot = filename.lastIndexOf(".");
+  const stem = dot < 0 ? filename : filename.slice(0, dot);
+  const extension = dot < 0 ? "" : filename.slice(dot);
+  return `${directory}${stem} (${suffix})${extension}`;
+}
+function ensureUnique(relativePath, counters) {
+  const originalKey = collisionKey(relativePath);
+  if (!counters.has(originalKey)) {
+    counters.set(originalKey, 0);
+    return { relativePath, duplicateWarning: null };
+  }
+  let suffix = (counters.get(originalKey) ?? 0) + 1;
+  counters.set(originalKey, suffix);
+  let uniquePath = suffixRelativePath(relativePath, suffix);
+  while (counters.has(collisionKey(uniquePath))) {
+    suffix += 1;
+    uniquePath = suffixRelativePath(relativePath, suffix);
+  }
+  counters.set(collisionKey(uniquePath), 0);
+  return {
+    relativePath: uniquePath,
+    duplicateWarning: warning(
+      "duplicate_path_suffix",
+      `A duplicate output path was renamed to "${uniquePath}".`,
+      Object.freeze({
+        originalRelativePath: relativePath,
+        relativePath: uniquePath
+      })
+    )
+  };
+}
+function planningFailure(message, inspection) {
+  return failure(
+    Object.freeze({ code: "invalid_split_options", message }),
+    inspection.warnings
+  );
+}
+function planSplit(inspection, options) {
+  if (!Number.isInteger(options.splitAtLevel) || options.splitAtLevel < 1) {
+    return planningFailure(
+      "The split level must be a positive integer.",
+      inspection
+    );
+  }
+  if (inspection.headings.length === 0) {
+    return failure(
+      Object.freeze({
+        code: "no_headings",
+        message: "No usable headings were found in the document."
+      }),
+      inspection.warnings
+    );
+  }
+  const sourceOrder = new Map(
+    inspection.headings.map((heading, index) => [heading, index])
+  );
+  const childrenByParent = buildChildrenByParent(
+    inspection.headings,
+    sourceOrder
+  );
+  const selected = selectOutputHeadings(
+    inspection.headings,
+    sourceOrder,
+    childrenByParent,
+    options.splitAtLevel
+  );
+  const selectedSet = new Set(selected);
+  const metrics = buildHeadingIndexMetrics(
+    inspection.headings,
+    sourceOrder,
+    childrenByParent
+  );
+  const overallWidth = Math.max(1, String(selected.length).length);
+  const sourceName = filenameParts(
+    inspection.sourceFilename,
+    inspection.format
+  );
+  const optionSnapshot = Object.freeze({ ...options });
+  const starts = [];
+  if (inspection.hasCoverContent) {
+    starts.push({ kind: "cover", startIndexWithinDocument: 0 });
+  }
+  selected.forEach((heading, index) => {
+    starts.push({
+      kind: isParentIntroOutput(
+        heading,
+        options.splitAtLevel,
+        childrenByParent,
+        selected
+      ) ? "parent-intro" : "section",
+      heading,
+      startIndexWithinDocument: outputStartIndex(
+        heading,
+        index,
+        inspection.hasCoverContent,
+        selected,
+        selectedSet
+      )
+    });
+  });
+  const collisionCounters = /* @__PURE__ */ new Map();
+  const duplicateWarnings = [];
+  const outputs = starts.map((start, index) => {
+    const nextStart = starts[index + 1]?.startIndexWithinDocument;
+    const unnormalizedEnd = nextStart ?? inspection.totalDocumentLength;
+    const endIndexWithinDocument = inspection.format === "pdf" && unnormalizedEnd <= start.startIndexWithinDocument ? Math.min(
+      inspection.totalDocumentLength,
+      start.startIndexWithinDocument + 1
+    ) : unnormalizedEnd;
+    const candidatePath = start.kind === "cover" ? buildCoverRelativePath(
+      options,
+      sourceName.stem,
+      sourceName.extension,
+      selected
+    ) : buildHeadingRelativePath({
+      heading: start.heading,
+      options,
+      originalStem: sourceName.stem,
+      extension: sourceName.extension,
+      itemIndex: selected.indexOf(start.heading) + 1,
+      overallWidth,
+      metrics,
+      parentIntro: start.kind === "parent-intro"
+    });
+    const unique = ensureUnique(candidatePath, collisionCounters);
+    const outputWarnings = unique.duplicateWarning === null ? Object.freeze([]) : Object.freeze([unique.duplicateWarning]);
+    if (unique.duplicateWarning !== null) {
+      duplicateWarnings.push(unique.duplicateWarning);
+    }
+    return Object.freeze({
+      kind: start.kind,
+      relativePath: unique.relativePath,
+      startIndexWithinDocument: start.startIndexWithinDocument,
+      endIndexWithinDocument,
+      sourceHeading: start.kind === "cover" ? null : start.heading,
+      warnings: outputWarnings
+    });
+  });
+  const warnings = Object.freeze([
+    ...inspection.warnings,
+    ...duplicateWarnings
+  ]);
+  const plan = Object.freeze({
+    format: inspection.format,
+    sourceFilePath: inspection.sourceFilePath,
+    sourceFilenameWithoutExtension: sourceName.stem,
+    options: optionSnapshot,
+    outputs: Object.freeze(outputs),
+    warnings
+  });
+  return success(plan, warnings);
+}
+
+// packages/core/src/execution/execute-split.ts
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve as resolve2, sep } from "node:path";
+function withPlanWarnings(error, plan) {
+  return failure(error, plan.warnings);
+}
+function resolvePlannedPath(rootDirectoryPath, relativePath) {
+  const resolvedPath = resolve2(rootDirectoryPath, ...relativePath.split("/"));
+  const pathWithinRoot = relative(rootDirectoryPath, resolvedPath);
+  if (pathWithinRoot === "" || pathWithinRoot === ".." || pathWithinRoot.startsWith(`..${sep}`) || isAbsolute(pathWithinRoot)) {
+    return failure({
+      code: "unsafe_output_path",
+      message: `The planned output path leaves the selected output directory: ${relativePath}`,
+      context: Object.freeze({ relativePath })
+    });
+  }
+  return success(resolvedPath);
+}
+function nodeErrorCode(cause) {
+  return cause !== null && typeof cause === "object" && "code" in cause ? String(cause.code) : void 0;
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (cause) {
+    if (nodeErrorCode(cause) === "ENOENT") {
+      return false;
+    }
+    throw cause;
+  }
+}
+async function chooseSourceNamedOutputRoot(parentDirectoryPath, sourceFilenameWithoutExtension) {
+  let suffix = 0;
+  while (true) {
+    const directoryName = suffix === 0 ? sourceFilenameWithoutExtension : `${sourceFilenameWithoutExtension} (${suffix})`;
+    const candidate = join(parentDirectoryPath, directoryName);
+    if (!await pathExists(candidate)) {
+      return candidate;
+    }
+    suffix += 1;
+  }
+}
+async function preflightDirectDestinations(outputRoot, finalPaths) {
+  for (const finalPath of finalPaths) {
+    if (await pathExists(finalPath)) {
+      return finalPath;
+    }
+    let parentPath = dirname(finalPath);
+    while (parentPath !== outputRoot) {
+      try {
+        const parentStat = await stat(parentPath);
+        if (!parentStat.isDirectory()) {
+          return parentPath;
+        }
+      } catch (cause) {
+        if (nodeErrorCode(cause) !== "ENOENT") {
+          throw cause;
+        }
+      }
+      parentPath = dirname(parentPath);
+    }
+  }
+  return null;
+}
+function outputDirectoryFailure(message, directoryPath, cause) {
+  return {
+    code: "output_directory_unavailable",
+    message,
+    context: Object.freeze({ directoryPath }),
+    cause
+  };
+}
+function outputWriteFailure(message, outputPath, cause) {
+  return {
+    code: "output_write_failed",
+    message,
+    context: Object.freeze({ outputPath }),
+    ...cause === void 0 ? {} : { cause }
+  };
+}
+async function executeSplit(inspection, plan, executionOptions, callbacks) {
+  if (executionOptions.outputDirectoryMode !== "direct" && executionOptions.outputDirectoryMode !== "sourceNamedSubfolder" || executionOptions.selectedOutputDirectoryPath.trim().length === 0) {
+    return withPlanWarnings(
+      {
+        code: "invalid_split_options",
+        message: "A valid output directory and mode are required."
+      },
+      plan
+    );
+  }
+  const adapterResult = getDocumentAdapter(inspection.format);
+  if (!adapterResult.ok) {
+    return withPlanWarnings(adapterResult.error, plan);
+  }
+  const selectedDirectoryPath = resolve2(
+    executionOptions.selectedOutputDirectoryPath
+  );
+  let finalOutputDirectoryPath;
+  try {
+    await mkdir(selectedDirectoryPath, { recursive: true });
+    finalOutputDirectoryPath = executionOptions.outputDirectoryMode === "direct" ? selectedDirectoryPath : await chooseSourceNamedOutputRoot(
+      selectedDirectoryPath,
+      plan.sourceFilenameWithoutExtension
+    );
+  } catch (cause) {
+    return withPlanWarnings(
+      outputDirectoryFailure(
+        "The selected output directory is unavailable.",
+        selectedDirectoryPath,
+        cause
+      ),
+      plan
+    );
+  }
+  const finalPaths = [];
+  for (const output of plan.outputs) {
+    const resolvedPath = resolvePlannedPath(
+      finalOutputDirectoryPath,
+      output.relativePath
+    );
+    if (!resolvedPath.ok) {
+      return withPlanWarnings(resolvedPath.error, plan);
+    }
+    finalPaths.push(resolvedPath.value);
+  }
+  if (executionOptions.outputDirectoryMode === "direct") {
+    try {
+      const conflictPath = await preflightDirectDestinations(
+        finalOutputDirectoryPath,
+        finalPaths
+      );
+      if (conflictPath !== null) {
+        return withPlanWarnings(
+          outputWriteFailure(
+            "An output destination already exists or is blocked by a file.",
+            conflictPath
+          ),
+          plan
+        );
+      }
+    } catch (cause) {
+      return withPlanWarnings(
+        outputWriteFailure(
+          "An output destination could not be checked.",
+          finalOutputDirectoryPath,
+          cause
+        ),
+        plan
+      );
+    }
+  }
+  if (executionOptions.outputDirectoryMode === "sourceNamedSubfolder") {
+    try {
+      await mkdir(finalOutputDirectoryPath);
+    } catch (cause) {
+      return withPlanWarnings(
+        outputDirectoryFailure(
+          "The generated output directory could not be created.",
+          finalOutputDirectoryPath,
+          cause
+        ),
+        plan
+      );
+    }
+  }
+  for (const [index, output] of plan.outputs.entries()) {
+    const finalPath = finalPaths[index];
+    let splitResult;
+    try {
+      splitResult = await adapterResult.value.createSplitDocument(
+        {
+          sourceFilePath: inspection.sourceFilePath,
+          bytes: inspection.sourceBytes
+        },
+        output.startIndexWithinDocument,
+        output.endIndexWithinDocument
+      );
+    } catch (cause) {
+      return withPlanWarnings(
+        {
+          code: "internal_error",
+          message: "Split-document creation failed unexpectedly.",
+          cause
+        },
+        plan
+      );
+    }
+    if (!splitResult.ok) {
+      return withPlanWarnings(splitResult.error, plan);
+    }
+    try {
+      await mkdir(dirname(finalPath), { recursive: true });
+      await writeFile(finalPath, splitResult.value, { flag: "wx" });
+    } catch (cause) {
+      return withPlanWarnings(
+        outputWriteFailure(
+          "A split document could not be written.",
+          finalPath,
+          cause
+        ),
+        plan
+      );
+    }
+    try {
+      callbacks?.onProgress?.(
+        Object.freeze({
+          completedFiles: index + 1,
+          totalFiles: plan.outputs.length,
+          relativePath: output.relativePath
+        })
+      );
+    } catch (cause) {
+      return withPlanWarnings(
+        {
+          code: "internal_error",
+          message: "The execution progress callback failed.",
+          cause
+        },
+        plan
+      );
+    }
+  }
+  const createdFilePaths = Object.freeze(finalPaths);
+  return success(
+    Object.freeze({
+      finalOutputDirectoryPath,
+      totalFiles: createdFilePaths.length,
+      createdFiles: createdFilePaths.length,
+      createdFilePaths
+    }),
+    plan.warnings
+  );
+}
+
+// packages/core/src/planning/planning-types.ts
+var DEFAULT_SPLIT_OPTIONS = Object.freeze({
+  splitAtLevel: 1,
+  parentHeadingMode: "notUsed",
+  addIndexToFilenames: true,
+  useMultiLevelIndexInFilenames: false,
+  includeOriginalFilename: false,
+  transformToTitleCase: true
+});
+
+// packages/core/src/index.ts
+var PROJECT_NAME = "DocSplitter";
+
+// apps/cli/src/main.ts
+import { Command, CommanderError, Option } from "commander";
+
+// apps/cli/src/exit-codes.ts
+var EXIT_SUCCESS = 0;
+var EXIT_USAGE = 2;
+var EXIT_UNSUPPORTED_FORMAT = 3;
+var EXIT_INPUT = 4;
+var EXIT_NO_HEADINGS = 5;
+var EXIT_PLANNING = 6;
+var EXIT_EXECUTION = 7;
+var EXIT_INTERNAL = 8;
+var EXIT_INTERRUPTED = 130;
+function exitCodeForError(code) {
+  switch (code) {
+    case "unsupported_format":
+      return EXIT_UNSUPPORTED_FORMAT;
+    case "input_not_found":
+    case "input_not_readable":
+    case "document_unreadable":
+    case "encrypted_document_unsupported":
+      return EXIT_INPUT;
+    case "no_headings":
+      return EXIT_NO_HEADINGS;
+    case "invalid_split_options":
+    case "split_level_unavailable":
+    case "unsafe_output_path":
+      return EXIT_PLANNING;
+    case "output_directory_unavailable":
+    case "output_write_failed":
+      return EXIT_EXECUTION;
+    case "internal_error":
+      return EXIT_INTERNAL;
+    default:
+      return EXIT_INTERNAL;
+  }
+}
+
+// apps/cli/src/presentation/human-output.ts
+function renderWarnings(warnings) {
+  if (warnings.length === 0) {
+    return [];
+  }
+  return [
+    "",
+    "Warnings:",
+    ...warnings.map((issue) => `- [${issue.code}] ${issue.message}`)
+  ];
+}
+function renderHumanInspection(inspection) {
+  const headingSummary = inspection.headings.length === 1 ? "1 (maximum level " + inspection.maxHeadingLevel + ")" : `${inspection.headings.length} (maximum level ${inspection.maxHeadingLevel})`;
+  const lines = [
+    `Input: ${inspection.sourceFilePath}`,
+    `Format: ${inspection.format.toUpperCase()}`,
+    `Document length: ${inspection.totalDocumentLength}`,
+    `Cover content: ${inspection.hasCoverContent ? "yes" : "no"}`,
+    `Headings: ${headingSummary}`,
+    "",
+    ...inspection.headings.map(
+      (heading) => `${"  ".repeat(Math.max(0, heading.level - 1))}- ${heading.normalizedText} (level ${heading.level}, document index ${heading.indexWithinDocument})`
+    ),
+    ...renderWarnings(inspection.warnings)
+  ];
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function renderHumanPlan(plan) {
+  const outputWarnings = new Set(
+    plan.outputs.flatMap((output) => output.warnings)
+  );
+  const planOnlyWarnings = plan.warnings.filter(
+    (issue) => !outputWarnings.has(issue)
+  );
+  const lines = [
+    `Input: ${plan.sourceFilePath}`,
+    `Format: ${plan.format.toUpperCase()}`,
+    `Outputs: ${plan.outputs.length}`,
+    "",
+    ...plan.outputs.map((output) => {
+      const warningCodes = output.warnings.map((issue) => issue.code);
+      const warningSuffix = warningCodes.length === 0 ? "" : ` | warnings: ${warningCodes.join(", ")}`;
+      return `- filename: ${JSON.stringify(output.relativePath)} | kind: ${output.kind} | range: [${output.startIndexWithinDocument}, ${output.endIndexWithinDocument})${warningSuffix}`;
+    }),
+    ...renderWarnings(planOnlyWarnings)
+  ];
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function renderHumanSplitPreview(plan) {
+  const lines = [
+    "Files to create:",
+    ...plan.outputs.map((output) => `- ${JSON.stringify(output.relativePath)}`),
+    ...renderWarnings(plan.warnings)
+  ];
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function renderHumanCancellation() {
+  return "Split cancelled.\n";
+}
+function renderHumanSplitSuccess(result, warnings = []) {
+  const fileLabel = result.createdFiles === 1 ? "file" : "files";
+  const lines = [
+    `Done. Created ${result.createdFiles} output ${fileLabel}.`,
+    `Output directory: ${result.finalOutputDirectoryPath}`,
+    "Created files:",
+    ...result.createdFilePaths.map((path) => `- ${path}`),
+    ...renderWarnings(warnings)
+  ];
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function renderHumanError(error) {
+  return `${error.message} [${error.code}]
+`;
+}
+
+// apps/cli/src/presentation/json-output.ts
+function serialize(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function renderJsonFailure(command, error, warnings) {
+  return serialize({
+    schemaVersion: 1,
+    command,
+    ok: false,
+    error: {
+      code: error.code,
+      message: error.message
+    },
+    warnings
+  });
+}
+function jsonHeadingId(heading, headingIds) {
+  const headingId = headingIds.get(heading);
+  if (headingId === void 0) {
+    throw new Error("A heading reference is outside the inspection result.");
+  }
+  return headingId;
+}
+function toJsonInspectionResult(inspection) {
+  const headingIds = new Map(
+    inspection.headings.map((heading, index) => [
+      heading,
+      `heading-${index + 1}`
+    ])
+  );
+  return {
+    format: inspection.format,
+    sourceFilePath: inspection.sourceFilePath,
+    sourceFilename: inspection.sourceFilename,
+    totalDocumentLength: inspection.totalDocumentLength,
+    hasCoverContent: inspection.hasCoverContent,
+    maxHeadingLevel: inspection.maxHeadingLevel,
+    headings: inspection.headings.map((heading) => ({
+      headingId: jsonHeadingId(heading, headingIds),
+      text: heading.text,
+      normalizedText: heading.normalizedText,
+      level: heading.level,
+      indexWithinDocument: heading.indexWithinDocument,
+      contentIndexWithinDocument: heading.contentIndexWithinDocument,
+      positionWithinLevel: heading.positionWithinLevel,
+      parentHeadingId: heading.parentNode === null ? null : jsonHeadingId(heading.parentNode, headingIds),
+      isBlank: heading.isBlank
+    })),
+    warnings: inspection.warnings
+  };
+}
+function toJsonSplitPlan(inspection, plan) {
+  const headingIds = new Map(
+    inspection.headings.map((heading, index) => [
+      heading,
+      `heading-${index + 1}`
+    ])
+  );
+  return {
+    format: plan.format,
+    sourceFilePath: plan.sourceFilePath,
+    sourceFilenameWithoutExtension: plan.sourceFilenameWithoutExtension,
+    options: plan.options,
+    outputs: plan.outputs.map((output) => ({
+      kind: output.kind,
+      relativePath: output.relativePath,
+      startIndexWithinDocument: output.startIndexWithinDocument,
+      endIndexWithinDocument: output.endIndexWithinDocument,
+      sourceHeadingId: output.sourceHeading === null ? null : jsonHeadingId(output.sourceHeading, headingIds),
+      warnings: output.warnings
+    })),
+    warnings: plan.warnings
+  };
+}
+function renderJsonInspectionSuccess(inspection, warnings) {
+  return serialize({
+    schemaVersion: 1,
+    command: "inspect",
+    ok: true,
+    data: toJsonInspectionResult(inspection),
+    warnings
+  });
+}
+function renderJsonInspectionFailure(error, warnings) {
+  return renderJsonFailure("inspect", error, warnings);
+}
+function renderJsonPlanSuccess(inspection, plan, warnings) {
+  return serialize({
+    schemaVersion: 1,
+    command: "plan",
+    ok: true,
+    data: toJsonSplitPlan(inspection, plan),
+    warnings
+  });
+}
+function renderJsonPlanFailure(error, warnings) {
+  return renderJsonFailure("plan", error, warnings);
+}
+function renderJsonSplitSuccess(inspection, selectedOutputDirectoryPath, outputDirectoryMode, plan, result, warnings) {
+  return serialize({
+    schemaVersion: 1,
+    command: "split",
+    ok: true,
+    data: {
+      sourceFilePath: inspection.sourceFilePath,
+      selectedOutputDirectoryPath,
+      outputDirectoryMode,
+      finalOutputDirectoryPath: result.finalOutputDirectoryPath,
+      totalFiles: result.totalFiles,
+      createdFiles: result.createdFiles,
+      createdRelativePaths: plan.outputs.map((output) => output.relativePath)
+    },
+    warnings
+  });
+}
+function renderJsonSplitFailure(error, warnings) {
+  return renderJsonFailure("split", error, warnings);
+}
+
+// apps/cli/src/commands/inspect-command.ts
+var processWriters = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text)
+};
+function noHeadingsError() {
+  return Object.freeze({
+    code: "no_headings",
+    message: "No usable headings were found in the document."
+  });
+}
+function internalError(cause) {
+  return Object.freeze({
+    code: "internal_error",
+    message: "The inspect command failed unexpectedly.",
+    cause
+  });
+}
+function presentFailure(error, warnings, options, writers) {
+  if (options.json === true) {
+    writers.stdout(renderJsonInspectionFailure(error, warnings));
+  } else {
+    writers.stderr(renderHumanError(error));
+  }
+  return exitCodeForError(error.code);
+}
+async function runInspectCommand(inputFilePath, options = {}, writers = processWriters) {
+  try {
+    const result = await inspectDocument(inputFilePath);
+    if (!result.ok) {
+      return presentFailure(result.error, result.warnings, options, writers);
+    }
+    if (result.value.headings.length === 0) {
+      return presentFailure(
+        noHeadingsError(),
+        result.warnings,
+        options,
+        writers
+      );
+    }
+    writers.stdout(
+      options.json === true ? renderJsonInspectionSuccess(result.value, result.warnings) : renderHumanInspection(result.value)
+    );
+    return EXIT_SUCCESS;
+  } catch (cause) {
+    const error = internalError(cause);
+    presentFailure(error, [], options, writers);
+    return EXIT_INTERNAL;
+  }
+}
+
+// apps/cli/src/commands/split-options.ts
+function invalidOptionsError(message) {
+  return Object.freeze({ code: "invalid_split_options", message });
+}
+function parentHeadingMode(value) {
+  switch (value) {
+    case "filename":
+      return "inFilename";
+    case "folders":
+      return "asFolder";
+    case "none":
+    case void 0:
+      return "notUsed";
+  }
+}
+function parseSplitOptions(input, rawArguments = []) {
+  if (rawArguments.includes("--index") && rawArguments.includes("--no-index") || rawArguments.includes("--title-case") && rawArguments.includes("--no-title-case")) {
+    return {
+      ok: false,
+      error: invalidOptionsError(
+        "Contradictory split options cannot be used together."
+      )
+    };
+  }
+  const levelText = input.level ?? String(DEFAULT_SPLIT_OPTIONS.splitAtLevel);
+  if (!/^[1-9]\d*$/u.test(levelText)) {
+    return {
+      ok: false,
+      error: invalidOptionsError("The split level must be a positive integer.")
+    };
+  }
+  const splitAtLevel = Number(levelText);
+  if (!Number.isSafeInteger(splitAtLevel)) {
+    return {
+      ok: false,
+      error: invalidOptionsError("The split level must be a positive integer.")
+    };
+  }
+  return {
+    ok: true,
+    options: Object.freeze({
+      splitAtLevel,
+      parentHeadingMode: parentHeadingMode(input.parentHeadings),
+      addIndexToFilenames: input.index ?? DEFAULT_SPLIT_OPTIONS.addIndexToFilenames,
+      useMultiLevelIndexInFilenames: input.multilevelIndex ?? DEFAULT_SPLIT_OPTIONS.useMultiLevelIndexInFilenames,
+      includeOriginalFilename: input.originalName ?? DEFAULT_SPLIT_OPTIONS.includeOriginalFilename,
+      transformToTitleCase: input.titleCase ?? DEFAULT_SPLIT_OPTIONS.transformToTitleCase
+    })
+  };
+}
+
+// apps/cli/src/commands/plan-command.ts
+var processWriters2 = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text)
+};
+function internalError2(cause) {
+  return Object.freeze({
+    code: "internal_error",
+    message: "The plan command failed unexpectedly.",
+    cause
+  });
+}
+function presentFailure2(error, warnings, options, writers) {
+  if (options.json === true) {
+    writers.stdout(renderJsonPlanFailure(error, warnings));
+  } else {
+    writers.stderr(renderHumanError(error));
+  }
+  return exitCodeForError(error.code);
+}
+function presentUsageFailure(error, options, writers) {
+  if (options.json === true) {
+    writers.stdout(renderJsonPlanFailure(error, []));
+  } else {
+    writers.stderr(renderHumanError(error));
+  }
+  return EXIT_USAGE;
+}
+async function runPlanCommand(inputFilePath, options = {}, writers = processWriters2, rawArguments = []) {
+  try {
+    const parsedOptions = parseSplitOptions(options, rawArguments);
+    if (!parsedOptions.ok) {
+      return presentUsageFailure(parsedOptions.error, options, writers);
+    }
+    const inspection = await inspectDocument(inputFilePath);
+    if (!inspection.ok) {
+      return presentFailure2(
+        inspection.error,
+        inspection.warnings,
+        options,
+        writers
+      );
+    }
+    const plan = planSplit(inspection.value, parsedOptions.options);
+    if (!plan.ok) {
+      return presentFailure2(plan.error, plan.warnings, options, writers);
+    }
+    writers.stdout(
+      options.json === true ? renderJsonPlanSuccess(inspection.value, plan.value, plan.warnings) : renderHumanPlan(plan.value)
+    );
+    return EXIT_SUCCESS;
+  } catch (cause) {
+    const error = internalError2(cause);
+    presentFailure2(error, [], options, writers);
+    return EXIT_INTERNAL;
+  }
+}
+
+// apps/cli/src/commands/split-command.ts
+import { createInterface } from "node:readline";
+import { resolve as resolve3 } from "node:path";
+var CONFIRMATION_PROMPT = "Create these files? [y/N]";
+async function promptForSplitConfirmation(readLine, write) {
+  while (true) {
+    write(`${CONFIRMATION_PROMPT} `);
+    const answer = await readLine();
+    if (answer === void 0) {
+      write("\n");
+      return "interrupted";
+    }
+    if (answer === null) {
+      write("\n");
+      return "no";
+    }
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === "y" || normalized === "yes") {
+      return "yes";
+    }
+    if (normalized === "" || normalized === "n" || normalized === "no") {
+      return "no";
+    }
+  }
+}
+async function confirmWithProcessStreams() {
+  const lines = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    crlfDelay: Infinity
+  });
+  const iterator = lines[Symbol.asyncIterator]();
+  let interrupted;
+  const interruption = new Promise((resolveInterruption) => {
+    interrupted = () => resolveInterruption(void 0);
+    lines.once("SIGINT", interrupted);
+  });
+  try {
+    return await promptForSplitConfirmation(
+      async () => {
+        const next = await Promise.race([iterator.next(), interruption]);
+        if (next === void 0) {
+          return void 0;
+        }
+        return next.done === true ? null : next.value;
+      },
+      (text) => process.stdout.write(text)
+    );
+  } finally {
+    if (interrupted !== void 0) {
+      lines.off("SIGINT", interrupted);
+    }
+    lines.close();
+  }
+}
+var processIo = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text),
+  confirm: confirmWithProcessStreams,
+  currentWorkingDirectory: () => process.cwd()
+};
+function invalidOptionsError2(message) {
+  return Object.freeze({ code: "invalid_split_options", message });
+}
+function internalError3(cause) {
+  return Object.freeze({
+    code: "internal_error",
+    message: "The split command failed unexpectedly.",
+    cause
+  });
+}
+function presentFailure3(error, warnings, options, io) {
+  if (options.json === true) {
+    io.stdout(renderJsonSplitFailure(error, warnings));
+  } else {
+    io.stderr(renderHumanError(error));
+  }
+  return exitCodeForError(error.code);
+}
+function presentUsageFailure2(error, options, io) {
+  if (options.json === true) {
+    io.stdout(renderJsonSplitFailure(error, []));
+  } else {
+    io.stderr(renderHumanError(error));
+  }
+  return EXIT_USAGE;
+}
+async function runSplitCommand(inputFilePath, options = {}, io = processIo, rawArguments = []) {
+  try {
+    const parsedOptions = parseSplitOptions(options, rawArguments);
+    if (!parsedOptions.ok) {
+      return presentUsageFailure2(parsedOptions.error, options, io);
+    }
+    if (options.json === true && options.yes !== true) {
+      return presentUsageFailure2(
+        invalidOptionsError2("Split execution with --json also requires --yes."),
+        options,
+        io
+      );
+    }
+    const selectedOutputDirectoryPath = resolve3(
+      io.currentWorkingDirectory(),
+      options.output ?? "."
+    );
+    const outputDirectoryMode = options.subfolder === true ? "sourceNamedSubfolder" : "direct";
+    const inspection = await inspectDocument(inputFilePath);
+    if (!inspection.ok) {
+      return presentFailure3(inspection.error, inspection.warnings, options, io);
+    }
+    const plan = planSplit(inspection.value, parsedOptions.options);
+    if (!plan.ok) {
+      return presentFailure3(plan.error, plan.warnings, options, io);
+    }
+    const previewShown = options.json !== true && !(options.quiet === true && options.yes === true);
+    if (previewShown) {
+      io.stdout(renderHumanSplitPreview(plan.value));
+    }
+    if (options.yes !== true) {
+      const confirmation = await io.confirm();
+      if (confirmation === "interrupted") {
+        return EXIT_INTERRUPTED;
+      }
+      if (confirmation === "no") {
+        io.stdout(renderHumanCancellation());
+        return EXIT_SUCCESS;
+      }
+    }
+    if (options.quiet !== true) {
+      io.stderr("Creating output files...\n");
+    }
+    const execution = await executeSplit(
+      inspection.value,
+      plan.value,
+      {
+        selectedOutputDirectoryPath,
+        outputDirectoryMode
+      },
+      options.quiet === true ? void 0 : {
+        onProgress: (progress) => {
+          io.stderr(
+            `Created ${progress.completedFiles} of ${progress.totalFiles} files.
+`
+          );
+        }
+      }
+    );
+    if (!execution.ok) {
+      return presentFailure3(execution.error, execution.warnings, options, io);
+    }
+    if (options.json === true) {
+      io.stdout(
+        renderJsonSplitSuccess(
+          inspection.value,
+          selectedOutputDirectoryPath,
+          outputDirectoryMode,
+          plan.value,
+          execution.value,
+          execution.warnings
+        )
+      );
+    } else {
+      io.stdout(
+        renderHumanSplitSuccess(
+          execution.value,
+          previewShown ? [] : execution.warnings
+        )
+      );
+    }
+    return EXIT_SUCCESS;
+  } catch (cause) {
+    const error = internalError3(cause);
+    presentFailure3(error, [], options, io);
+    return EXIT_INTERNAL;
+  }
+}
+
+// apps/cli/src/main.ts
+function readCliVersion() {
+  if (true) {
+    return "0.1.0";
+  }
+  return createRequire(import.meta.url)("../package.json").version;
+}
+var CLI_VERSION = readCliVersion();
+var ROOT_HELP = `
+Default split workflow:
+  doc-splitter <input> [split options] [--output <directory>] [--subfolder]
+    [--yes] [--json] [--quiet]
+
+Split options:
+  --level <number>                  split at this heading level
+  --parent-headings <mode>         none, filename, or folders
+  --index / --no-index             include or omit filename indexes
+  --multilevel-index               use hierarchical filename indexes
+  --original-name                  prefix filenames with the input stem
+  --title-case / --no-title-case   transform or preserve heading-name casing
+
+Execution options:
+  --output <directory>              select the output directory
+  --subfolder                       create a unique source-named subfolder
+  --yes                             confirm execution without prompting
+  --json                            write one versioned JSON result
+  --quiet                           suppress progress and confirmed preview
+`;
+function addSplitOptions(command) {
+  return command.option("--level <number>", "split at this heading level").addOption(
+    new Option(
+      "--parent-headings <mode>",
+      "place parent headings in filenames or folders"
+    ).choices(["none", "filename", "folders"])
+  ).option("--index", "include indexes in filenames").option("--no-index", "omit indexes from filenames").option("--multilevel-index", "use hierarchical indexes in filenames").option("--original-name", "prefix filenames with the input stem").option("--title-case", "transform heading names to title case").option("--no-title-case", "preserve heading-name casing");
+}
+function setProcessExitCode(exitCode) {
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}
+function createCli() {
+  const command = new Command().name("doc-splitter").description(`${PROJECT_NAME} command-line interface`).usage("[options] <input>\n       doc-splitter <command> [options]").version(CLI_VERSION).showHelpAfterError().addHelpText("after", ROOT_HELP);
+  command.command("inspect").description("Inspect the heading hierarchy of a DOCX or PDF document").argument("<input>", "input DOCX or PDF file").option("--json", "write one versioned JSON result to stdout").option("--quiet", "suppress progress and nonessential human output").action(async (input, options) => {
+    const exitCode = await runInspectCommand(input, options);
+    setProcessExitCode(exitCode);
+  });
+  addSplitOptions(
+    command.command("plan").description("Calculate output paths and ranges without creating files").argument("<input>", "input DOCX or PDF file")
+  ).option("--json", "write one versioned JSON result to stdout").option("--quiet", "suppress progress and nonessential human output").action(
+    async (input, options, actionCommand) => {
+      const exitCode = await runPlanCommand(
+        input,
+        options,
+        void 0,
+        actionCommand.parent?.args ?? []
+      );
+      setProcessExitCode(exitCode);
+    }
+  );
+  addSplitOptions(
+    command.command("__split", { hidden: true, isDefault: true }).description("Split a DOCX or PDF document").argument("<input>", "input DOCX or PDF file")
+  ).option("--output <directory>", "select the output directory").option("--subfolder", "create a unique source-named output subfolder").option("--yes", "confirm execution without prompting").option("--json", "write one versioned JSON result to stdout").option("--quiet", "suppress progress and nonessential human output").action(
+    async (input, options, actionCommand) => {
+      const exitCode = await runSplitCommand(
+        input,
+        options,
+        void 0,
+        actionCommand.parent?.args ?? []
+      );
+      setProcessExitCode(exitCode);
+    }
+  );
+  return command;
+}
+function jsonCommandForArguments(argv) {
+  switch (argv[2]) {
+    case "inspect":
+      return "inspect";
+    case "plan":
+      return "plan";
+    default:
+      return "split";
+  }
+}
+function presentJsonUsageFailure(argv, error) {
+  const usageError = Object.freeze({
+    code: "invalid_split_options",
+    message: error.message
+  });
+  process.stdout.write(
+    renderJsonFailure(jsonCommandForArguments(argv), usageError, [])
+  );
+}
+async function runCli(argv = process.argv) {
+  const command = createCli().exitOverride();
+  for (const subcommand of command.commands) {
+    subcommand.exitOverride();
+  }
+  try {
+    await command.parseAsync([...argv]);
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (error.exitCode !== 0) {
+        process.exitCode = EXIT_USAGE;
+        if (argv.includes("--json")) {
+          presentJsonUsageFailure(argv, error);
+        }
+      }
+      return;
+    }
+    throw error;
+  }
+}
+var entryPath = process.argv[1];
+if (entryPath !== void 0 && import.meta.url === pathToFileURL(resolve4(entryPath)).href) {
+  runCli().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = EXIT_INTERNAL;
+  });
+}
+export {
+  createCli,
+  runCli
+};