document-cli 1.10.0 → 1.11.1

package/README.md

@@ -41,7 +41,7 @@ graph TD
 
 ## Why
 
-`documents.js` is a library, not a tool — everything it does happens through function calls from TypeScript/JavaScript. Most people who want to convert a docx to a PDF, extract an `.odb` table to CSV, or poke at a PDF's structure from a terminal don't want to write a script to do it. `document-cli` is that missing entry point: every one of documents.js's 27 direct conversion pairs, its generic converter, its `.odm`/`.odb` extraction functions, and its PDF inspector become a single command-line invocation, and its six live-view editors (docx/pptx/odt/odp/ods/odg) plus its line-based markdown editor become a keyboard-driven terminal app that never needs a code editor open at all.
+`documents.js` is a library, not a tool — everything it does happens through function calls from TypeScript/JavaScript. Most people who want to convert a docx to a PDF, extract an `.odb` table to CSV, or poke at a PDF's structure from a terminal don't want to write a script to do it. `document-cli` is that missing entry point: every one of documents.js's 27 direct conversion pairs, its generic converter, its `.odm`/`.odb` extraction functions, and its PDF inspector become a single command-line invocation, and its seven live-view editors (docx/pptx/odt/odp/ods/odg/markdown) become a keyboard-driven terminal app that never needs a code editor open at all.
 
 The CLI and the TUI are deliberately not two separate implementations of the same logic. The TUI's own document-opening, saving, and PDF-export code (`src/tui/format/`) calls the identical `documents.js` functions the CLI commands call — `openDocx`/`createDocx`/`docxToPdf` and their five siblings per format, plus `readOdbTables`/`readPdf` for the two read-only sources — so there is exactly one place either surface can drift from what documents.js itself does: nowhere.
 
@@ -165,9 +165,9 @@ Diagnostics and the summary line always go to stderr; stdout is reserved for the
 
 Launch it either bare (`document-cli`, with no arguments) or explicitly with `document-cli tui [file]` — both open the same app; the explicit form additionally opens `file` immediately, skipping the launcher screen. The TUI needs an interactive terminal: a bare invocation with redirected stdout prints help text instead, and an explicit `tui` invocation with redirected stdout fails outright, since there's no terminal for Ink to draw into.
 
-It supports the same six formats documents.js's live-view editors cover — docx, pptx, odt, odp, ods, odg — each with a full navigate/edit/save experience built on that format's editor (paragraphs and runs for docx/odt, slides and shapes for pptx/odp, sheets and cells for ods, pages and vectors/shapes for odg), plus undo (whole-document snapshots taken before each committed mutation), search, a command palette, and PDF export straight from the open document. On a pptx or odp slide, `a` from the shape list also adds a real table (rows then columns, a two-step prompt) alongside the existing textbox/image choices, and `n` opens the slide's own speaker notes for either format — `PptxSlide` and `OdpSlide` both carry a real `.notes` getter/setter, so notes editing was never odp-specific, only gated that way until this phase removed the gate.
+It supports the same seven formats documents.js's live-view editors cover — docx, pptx, odt, odp, ods, odg, markdown — each with a full navigate/edit/save experience built on that format's editor (paragraphs and runs for docx/odt/markdown, slides and shapes for pptx/odp, sheets and cells for ods, pages and vectors/shapes for odg), plus undo (whole-document snapshots taken before each committed mutation), search, a command palette, and PDF export straight from the open document. On a pptx or odp slide, `a` from the shape list also adds a real table (rows then columns, a two-step prompt) alongside the existing textbox/image choices, and `n` opens the slide's own speaker notes for either format — `PptxSlide` and `OdpSlide` both carry a real `.notes` getter/setter, so notes editing was never odp-specific, only gated that way until this phase removed the gate.
 
-Markdown (`.md`/`.markdown`) is also a fully supported TUI format, but a structurally different one: documents.js has no `MarkdownEditor` the way it has a `DocxEditor`/`OdtEditor` (its own markdown support is a thin read/write pair over a plain string, not an `XmlElement` tree to hold a live view into), so the TUI edits a markdown document as its own raw source text rather than through a live-view editor object. Opening a `.md` file loads its bytes verbatim as a source string (`decodeMarkdownText`); the root screen lists that source split into lines, one row each, with search filtering by line content; selecting a line opens a line editor that replaces its text in place; `Ctrl+S` writes the (possibly edited) source straight back to disk (`encodeMarkdownText`), the identical byte↔text boundary opening it went through in reverse — never through `readMarkdownContent`/`buildMarkdownText`. PDF export is the one place the `ContentDocument` pivot enters at all: exporting calls `markdownToPdf` directly on the current source text, run fresh on every export rather than kept in sync with in-progress edits. There is no "create a new markdown document" flow (documents.js has no `createMarkdown()`), so a markdown document can only be opened from an existing file, never created fresh from the TUI's new-document screen the way docx/pptx/odt/odp/ods/odg can.
+Markdown (`.md`/`.markdown`) shares the same paragraph/run/table body-list screens docx and odt already use, through documents.js's own `MarkdownEditor` (`openMarkdown`/`createMarkdownEditor`) — a genuine live view over a mutable `ContentDocument`, the same live-view contract every other editor here follows, even though there is no `XmlElement` tree underneath it the way there is for docx/odt (`MarkdownEditor.toMarkdownText()` re-serialises the whole document fresh on every call, rather than exposing a `toBytes()`). Appending a paragraph, appending a run, and toggling bold/italic all go through the identical reducer actions docx/odt use; a markdown run has no underline, colour, font family, or font size at all (CommonMark/GFM has no construct for any of the four), so those keys — along with image insertion, which `MarkdownParagraph` has no counterpart for — are simply absent from a markdown paragraph's own key hints rather than opening a prompt that could only end in a warning. A markdown table can be created and its cells edited through the same 'T' wizard and table-view screens docx/odt use, but GFM tables have no cell-merge concept, so a merge requested alongside table creation still creates the table (unmerged) and reports why the merge itself didn't happen. `:view-source` (markdown documents only) shows the literal text the document was opened with side by side with what a save would write right now — these can genuinely differ even with no edits made this session, from a heading-style, bullet-marker, or line-ending choice the writer normalises. Every save re-serialises the whole document fresh through `buildMarkdownText`, a deliberate, permanent consequence of structured editing rather than something to work around. Diagnostics from the read side (a clamped heading level, a dropped front-matter key, a fenced code block's own info string with nowhere to go, …) now surface into the same diagnostics panel a PDF export's own substitutions already populate, the moment a `.md` file is opened, not only on export. documents.js's own `createMarkdownEditor()` exists now, but this TUI does not yet wire a "new markdown document" flow into `:new`/the new-document picker, so a markdown document can still only be opened from an existing file.
 
 Three further formats open read-only: a `.odb` browses its tables and rows with no write path at all (documents.js's own `.odb` support has no write direction to offer), a `.pdf` browses its pages and positioned items rather than being edited in place, and a `.xlsx` opens as a converted PDF preview — documents.js has no xlsx editor to hold a live view into, so opening one runs `xlsxToPdf` once at open time and browses the result through the identical page-list/page-items/item-detail screens a real `.pdf` uses, with the original bytes kept alongside so a later export re-runs `xlsxToPdf` with the caller's own fonts and diagnostics rather than reusing the fixed preview conversion. A `.odb` additionally browses its *structure* alongside its data: `f` from the table list opens the form browser and `r` the report browser, each listing what the database declares and opening one to show it in full — a form's own data source and field-bound controls (sub-forms nested under their parent), a report's data-source command, band and group structure, and every `rpt:` formula. Both are rendered through the same `src/odb-structure.ts` the `odb-forms`/`odb-reports` commands print, so the two views cannot drift apart, and search filters by line (`/SUM` narrows a long report to its aggregate expressions). A standalone `.odf` formula document has no TUI editor either — nothing to edit interactively, only a PDF conversion.
 

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as odbFormSummary, c as formatDocxExtrasLines, d as writeOutput, f as loadProvidedFonts, h as isDocumentFormat, i as formatOdbReportLines, l as readInput, m as inferFormatFromExtension, n as describeOdbReport, o as formatMetadataLines, r as formatOdbFormLines, s as presentMetadataEntries, t as describeOdbForm, u as resolveDefaultOutputPath } from "./odb-structure-Du1w_hOU.js";
+import { a as odbFormSummary, c as formatDocxExtrasLines, d as writeOutput, f as loadProvidedFonts, h as isDocumentFormat, i as formatOdbReportLines, l as readInput, m as inferFormatFromExtension, n as describeOdbReport, o as formatMetadataLines, r as formatOdbFormLines, s as presentMetadataEntries, t as describeOdbForm, u as resolveDefaultOutputPath } from "./odb-structure-CS2Eybob.js";
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 import { writeFile } from "node:fs/promises";
-import { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError, OdbNoEmbeddedDataSourceError, OdbReportNotSpecifiedError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, UnrecognizedDocumentSchemaError, buildDocxPackage, buildMarkdownText, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, convertWordprocessingToLayout, createFontMeasurer, createFontRegistry, createLocalDocumentConverter, decodeMarkdownText, decodePackage, documentFromJson, documentPackageWithSchema, encodeMarkdownText, encodePackage, evaluateSelect, extractSourceFonts, hsqldbCellDisplayText, layoutDocumentWithSchema, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocxContent, readDocxExtras, readMarkdownContent, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readOdfFormulaContent, readOdgContent, readOdpContent, readOdsContent, readOdtContent, readPdf, readPptxContent, writePdf, xlsxToPdf } from "documents.js";
+import { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError, OdbNoEmbeddedDataSourceError, OdbReportNotSpecifiedError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, UnrecognizedDocumentSchemaError, UnsupportedFontSourceFormatError, buildDocumentBytes, createLocalDocumentConverter, decodePackage, documentFromJson, documentPackageWithSchema, evaluateSelect, extractSourceFontsForFormat, hsqldbCellDisplayText, layoutDocumentWithSchema, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocumentMetadata, readDocxExtras, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, setDocumentMetadata } from "documents.js";
 import { basename, dirname, extname, join } from "node:path";
-import { decodePackage as decodePackage$1, encodePackage as encodePackage$1 } from "odf.js";
+import { decodePackage as decodePackage$1 } from "odf.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/runtime/abort.ts
 function combineSignals(a, b) {
@@ -116,6 +116,7 @@ function mapErrorToExit(error, abortReason) {
 	if (abortReason === "timeout") return 124;
 	if (error instanceof OdmUnresolvedSectionError || error instanceof OdbTableNotSpecifiedError || error instanceof OdbTableNotFoundError || error instanceof OdbNoEmbeddedDataSourceError || error instanceof OdbUnsupportedFormatError || error instanceof OdbReportNotSpecifiedError) return 3;
 	if (error instanceof HsqldbSqlUnsupportedError || error instanceof HsqldbSqlParseError || error instanceof HsqldbSqlEvaluationError) return 1;
+	if (error instanceof UnsupportedFontSourceFormatError) return 2;
 	if (error instanceof PdfEncryptedError || error instanceof PdfParseError) return 1;
 	return 1;
 }
@@ -306,27 +307,6 @@ function registerDocxExtrasCommand(program) {
 }
 //#endregion
 //#region src/commands/fonts.ts
-const FONT_SOURCE_FORMATS = {
-	docx: true,
-	pptx: true,
-	odt: true,
-	odp: true,
-	ods: true,
-	odg: true
-};
-function isFontSourceFormat(format) {
-	return format in FONT_SOURCE_FORMATS;
-}
-function resolveFontSourcePackage(format, bytes) {
-	if (format === "docx" || format === "pptx") return {
-		kind: format,
-		package: decodePackage(bytes)
-	};
-	return {
-		kind: "odf",
-		package: decodePackage$1(bytes)
-	};
-}
 async function runFonts(input, options) {
 	const command = "fonts";
 	const { signal, getAbortReason } = createRuntimeSignal({});
@@ -336,13 +316,8 @@ async function runFonts(input, options) {
 			process.stderr.write(`[${command}] cannot infer a document format from '${input}'; expected one of docx, pptx, odt, odp, ods, odg\n`);
 			return 2;
 		}
-		if (!isFontSourceFormat(format)) {
-			process.stderr.write(`[${command}] '${format}' documents carry no source-embedded font faces this command can extract; expected one of docx, pptx, odt, odp, ods, odg\n`);
-			return 2;
-		}
 		const inputBytes = await readInput(input, { signal });
-		const source = resolveFontSourcePackage(format, new Uint8Array(inputBytes));
-		const summaries = extractSourceFonts(source).map((face) => ({
+		const summaries = extractSourceFontsForFormat(format, new Uint8Array(inputBytes)).map((face) => ({
 			family: face.family,
 			bold: face.bold,
 			italic: face.italic,
@@ -387,23 +362,6 @@ function registerFormatsCommand(program) {
 }
 //#endregion
 //#region src/commands/from-package.ts
-function buildBytesForTarget(pkg, target) {
-	if (target === "pdf") {
-		if (pkg.layout === void 0) throw new Error("this DocumentPackage has no layout -- only a package dumped from a <format>-to-pdf or pdf-to-<format> conversion carries one; a bridge conversion's own dump (e.g. odt-to-docx) never does, so 'pdf' is not a reachable target from it");
-		return writePdf(pkg.layout);
-	}
-	switch (target) {
-		case "docx": return encodePackage(buildDocxPackage(pkg.content));
-		case "pptx": return encodePackage(buildPptxPackage(pkg.content));
-		case "odt": return encodePackage$1(buildOdtPackage(pkg.content));
-		case "odp": return encodePackage$1(buildOdpPackage(pkg.content));
-		case "ods": return encodePackage$1(buildOdsPackage(pkg.content));
-		case "odg": return encodePackage$1(buildOdgPackage(pkg.content));
-		case "markdown": return encodeMarkdownText(buildMarkdownText(pkg.content));
-		case "xlsx": throw new Error("'xlsx' cannot be built from a DocumentPackage directly -- documents.js does not re-export a ContentDocument-to-xlsx builder; convert to 'ods' here, then run 'ods-to-xlsx' on the result instead");
-		case "odf": throw new Error("'odf' (a standalone formula document) cannot be built from a DocumentPackage -- there is no ContentDocument-to-odf builder");
-	}
-}
 async function runFromPackage(input, output, options) {
 	const command = "from-package";
 	if (output !== void 0 && options.out !== void 0 && output !== options.out) {
@@ -432,7 +390,7 @@ async function runFromPackage(input, output, options) {
 			process.stderr.write(`[${command}] '${input}' is a ${result.kind}, not a DocumentPackage -- only a file written by --dump-package can be read back by this command\n`);
 			return 2;
 		}
-		const bytes = buildBytesForTarget(result.value, target.format);
+		const bytes = buildDocumentBytes(result.value, target.format);
 		await writeOutput(resolvedOutput, bytes);
 		createDiagnosticReporter({
 			json: options.json,
@@ -467,20 +425,6 @@ function registerFromPackageCommand(program) {
 }
 //#endregion
 //#region src/commands/metadata.ts
-function readMetadataForFormat(format, bytes, signal) {
-	switch (format) {
-		case "docx": return readDocxContent(decodePackage(bytes)).metadata;
-		case "pptx": return readPptxContent(decodePackage(bytes)).metadata;
-		case "odt": return readOdtContent(decodePackage$1(bytes)).metadata;
-		case "odp": return readOdpContent(decodePackage$1(bytes)).metadata;
-		case "ods": return readOdsContent(decodePackage$1(bytes)).metadata;
-		case "odg": return readOdgContent(decodePackage$1(bytes)).metadata;
-		case "odf": return readOdfFormulaContent(decodePackage$1(bytes)).metadata;
-		case "markdown": return readMarkdownContent(decodeMarkdownText(bytes)).metadata;
-		case "pdf": return readPdf(bytes, { signal }).metadata;
-		case "xlsx": return readPdf(xlsxToPdf(bytes, { signal }), { signal }).metadata;
-	}
-}
 async function runMetadata(input, options) {
 	const command = "metadata";
 	const source = inferFormatFromExtension(input);
@@ -491,7 +435,7 @@ async function runMetadata(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const metadata = readMetadataForFormat(source, new Uint8Array(inputBytes), signal);
+		const metadata = readDocumentMetadata(source, new Uint8Array(inputBytes), { signal });
 		if (options.json) {
 			process.stdout.write(`${JSON.stringify(metadata)}\n`);
 			return 0;
@@ -739,32 +683,6 @@ const ODB_REPORT_TARGET_FORMATS = {
 function isOdbReportTargetFormat(format) {
 	return format in ODB_REPORT_TARGET_FORMATS;
 }
-function renderOdbReportBytes(content, target, options) {
-	if (target === "docx") return encodePackage(buildDocxPackage(content));
-	if (target === "odt") return encodePackage$1(buildOdtPackage(content));
-	if (content.kind !== "wordprocessing") throw new Error("readOdbReportContent returned a non-wordprocessing ContentDocument");
-	const fonts = createFontRegistry({
-		fonts: options.fonts,
-		onSubstitution: (substitution) => {
-			if (options.reportFontSubstitution !== void 0) {
-				options.reportFontSubstitution(substitution);
-				return;
-			}
-			options.onDiagnosticCounted();
-			options.reporter.report(fontSubstitutionToDiagnostic(substitution));
-		}
-	});
-	const { document: layout, formulas } = convertWordprocessingToLayout(content, { measurer: createFontMeasurer(fonts) });
-	return writePdf(layout, {
-		signal: options.signal,
-		onSubstitution: (substitution, context) => {
-			options.onDiagnosticCounted();
-			options.reporter.report(substitutionToDiagnostic(substitution, context.pageIndex));
-		},
-		formulas,
-		fonts
-	});
-}
 async function runOdbRenderReport(input, output, options) {
 	const command = "odb-render-report";
 	if (output !== void 0 && options.out !== void 0 && output !== options.out) {
@@ -798,13 +716,21 @@ async function runOdbRenderReport(input, output, options) {
 		const inputBytes = await readInput(input, { signal });
 		const fonts = await loadProvidedFonts(options.fontFile ?? [], { signal });
 		const pkg = decodePackage$1(new Uint8Array(inputBytes));
-		const bytes = renderOdbReportBytes(readOdbReportContent(pkg, { report: options.report }), targetFormat, {
-			fonts,
+		const content = readOdbReportContent(pkg, { report: options.report });
+		const bytes = targetFormat === "docx" ? odbReportToDocx(content) : targetFormat === "odt" ? odbReportToOdt(content) : odbReportToPdf(content, {
 			signal,
-			reporter,
-			reportFontSubstitution,
-			onDiagnosticCounted: () => {
+			fonts,
+			onFontSubstitution: (substitution) => {
+				if (reportFontSubstitution !== void 0) {
+					reportFontSubstitution(substitution);
+					return;
+				}
+				diagnosticCount += 1;
+				reporter.report(fontSubstitutionToDiagnostic(substitution));
+			},
+			onSubstitution: (substitution, context) => {
 				diagnosticCount += 1;
+				reporter.report(substitutionToDiagnostic(substitution, context.pageIndex));
 			}
 		});
 		await writeOutput(resolvedOutput, bytes);
@@ -1047,63 +973,9 @@ function registerPdfInspectCommand(program) {
 }
 //#endregion
 //#region src/commands/set-metadata.ts
-const REBUILD_FORMATS = {
-	docx: true,
-	pptx: true,
-	odt: true,
-	odp: true,
-	ods: true,
-	odg: true,
-	markdown: true
-};
-function isRebuildFormat(format) {
-	return format in REBUILD_FORMATS;
-}
-function readContentForFormat(format, bytes) {
-	switch (format) {
-		case "docx": return readDocxContent(decodePackage(bytes));
-		case "pptx": return readPptxContent(decodePackage(bytes));
-		case "odt": return readOdtContent(decodePackage$1(bytes));
-		case "odp": return readOdpContent(decodePackage$1(bytes));
-		case "ods": return readOdsContent(decodePackage$1(bytes));
-		case "odg": return readOdgContent(decodePackage$1(bytes));
-		case "markdown": return readMarkdownContent(decodeMarkdownText(bytes));
-	}
-}
-function buildBytesForRebuildFormat(format, content) {
-	switch (format) {
-		case "docx": return encodePackage(buildDocxPackage(content));
-		case "pptx": return encodePackage(buildPptxPackage(content));
-		case "odt": return encodePackage$1(buildOdtPackage(content));
-		case "odp": return encodePackage$1(buildOdpPackage(content));
-		case "ods": return encodePackage$1(buildOdsPackage(content));
-		case "odg": return encodePackage$1(buildOdgPackage(content));
-		case "markdown": return encodeMarkdownText(buildMarkdownText(content));
-	}
-}
-function mergeMetadata(current, overrides) {
-	return {
-		...current,
-		...overrides.title !== void 0 ? { title: overrides.title } : {},
-		...overrides.author !== void 0 ? { author: overrides.author } : {},
-		...overrides.subject !== void 0 ? { subject: overrides.subject } : {},
-		...overrides.keywords !== void 0 ? { keywords: overrides.keywords } : {}
-	};
-}
 function parseKeywords(csv) {
 	return csv.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 }
-function classifyWritePath(source, target) {
-	if (source === "pdf" && target === "pdf") return { kind: "pdf" };
-	if (target === "xlsx" || source === "xlsx") return { errorMessage: "'xlsx' is not a supported set-metadata source or target -- documents.js does not re-export a ContentDocument-to-xlsx builder or a readXlsxContent from its own public surface (see that package's own README, Architecture section); convert with 'xlsx-to-ods'/'ods-to-xlsx' first, then set metadata on the ods" };
-	if (target === "odf" || source === "odf") return { errorMessage: "'odf' (a standalone formula document) is not a supported set-metadata source or target -- it has no write path back out at all" };
-	if (!isRebuildFormat(source) || !isRebuildFormat(target)) return { errorMessage: `set-metadata only patches metadata in place; it does not convert format -- source ('${source}') and target ('${target}') must be the same format (or both 'pdf'). Run 'convert'/'from-package' first if you need a different target format.` };
-	if (source !== target) return { errorMessage: `set-metadata only patches metadata in place; it does not convert format -- source ('${source}') and target ('${target}') must be the same format. Run 'convert'/'from-package' first if you need a different target format.` };
-	return {
-		kind: "rebuild",
-		format: source
-	};
-}
 async function runSetMetadata(input, output, options) {
 	const command = "set-metadata";
 	if (output !== void 0 && options.out !== void 0 && output !== options.out) {
@@ -1120,11 +992,6 @@ async function runSetMetadata(input, output, options) {
 		process.stderr.write(`[${command}] cannot infer a source format from '${input}'; rename the file with a recognised extension (${KNOWN_DOCUMENT_FORMATS})\n`);
 		return 2;
 	}
-	const writePath = classifyWritePath(source, target.format);
-	if ("errorMessage" in writePath) {
-		process.stderr.write(`[${command}] ${writePath.errorMessage}\n`);
-		return 2;
-	}
 	const overrides = {
 		title: options.setTitle,
 		author: options.setAuthor,
@@ -1135,21 +1002,7 @@ async function runSetMetadata(input, output, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const bytes = writePath.kind === "pdf" ? (() => {
-			const layout = readPdf(new Uint8Array(inputBytes), { signal });
-			const patched = {
-				...layout,
-				metadata: mergeMetadata(layout.metadata, overrides)
-			};
-			return writePdf(patched, { signal });
-		})() : (() => {
-			const content = readContentForFormat(writePath.format, new Uint8Array(inputBytes));
-			const nextContent = {
-				...content,
-				metadata: mergeMetadata(content.metadata, overrides)
-			};
-			return buildBytesForRebuildFormat(writePath.format, nextContent);
-		})();
+		const bytes = setDocumentMetadata(source, target.format, new Uint8Array(inputBytes), overrides, { signal });
 		await writeOutput(resolvedOutput, bytes);
 		createDiagnosticReporter({
 			json: options.json,
@@ -1194,7 +1047,7 @@ function registerSetMetadataCommand(program) {
 }
 //#endregion
 //#region package.json
-var version = "1.10.0";
+var version = "1.11.1";
 //#endregion
 //#region src/program.ts
 function createProgram() {
@@ -1221,7 +1074,7 @@ function createProgram() {
 //#region src/cli.ts
 async function launchTui(startPath, signal) {
 	try {
-		const { runTui } = await import("./tui-BVeYd0ry.js");
+		const { runTui } = await import("./tui-Bw_z7xq6.js");
 		await runTui({
 			startPath,
 			signal