document-cli 1.3.0 → 1.5.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import { readFile, 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, documentFromJson, documentPackageWithSchema, encodeMarkdownText, encodePackage, evaluateSelect, hsqldbCellDisplayText, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, writePdf } from "documents.js";
+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 { basename, dirname, extname, join } from "node:path";
 import { Command, InvalidArgumentError } from "commander";
-import { decodePackage, encodePackage as encodePackage$1 } from "odf.js";
+import { decodePackage as decodePackage$1, encodePackage as encodePackage$1 } from "odf.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/format.ts
 const EXTENSION_TO_FORMAT = {
@@ -532,8 +532,158 @@ function registerConversionCommands(program) {
 	});
 }
 //#endregion
+//#region src/docx-extras-format.ts
+const INDENT$1 = "  ";
+function indent$1(depth) {
+	return INDENT$1.repeat(depth);
+}
+function commentLine(comment, position) {
+	const author = comment.author ?? "(no author)";
+	return `${indent$1(1)}[${position}] ${author}: ${comment.text}`;
+}
+function footnoteLine(footnote, position) {
+	const typeSuffix = footnote.type === void 0 ? "" : ` (${footnote.type})`;
+	return `${indent$1(1)}[${position}]${typeSuffix} ${footnote.text}`;
+}
+function commentsSection(comments) {
+	if (comments.length === 0) return [];
+	return ["comments", ...comments.map((comment, index) => commentLine(comment, index + 1))];
+}
+function footnotesSection(footnotes) {
+	if (footnotes.length === 0) return [];
+	return ["footnotes", ...footnotes.map((footnote, index) => footnoteLine(footnote, index + 1))];
+}
+function headerOrFooterSection(label, values) {
+	if (values.length === 0) return [];
+	return [label, ...values.map((text, index) => `${indent$1(1)}[${index + 1}] ${text}`)];
+}
+function numberingLevelLine(ilvl, level) {
+	const restartSuffix = level.restart === void 0 ? "" : `, restarts at level ${level.restart}`;
+	return `${indent$1(2)}level ${ilvl}: ${level.format} ${JSON.stringify(level.text)} starting at ${level.startAt}${restartSuffix}`;
+}
+function numberingSection(numbering) {
+	const numIds = Object.keys(numbering);
+	if (numIds.length === 0) return [];
+	const lines = ["numbering"];
+	for (const numId of numIds) {
+		const definition = numbering[numId];
+		if (definition === void 0) continue;
+		lines.push(`${indent$1(1)}numId ${numId}`);
+		const ilvls = Object.keys(definition.levels).sort((a, b) => Number(a) - Number(b));
+		for (const ilvl of ilvls) {
+			const level = definition.levels[ilvl];
+			if (level === void 0) continue;
+			lines.push(numberingLevelLine(ilvl, level));
+		}
+	}
+	return lines;
+}
+function formatDocxExtrasLines(extras) {
+	const nonEmptySections = [
+		commentsSection(extras.comments),
+		footnotesSection(extras.footnotes),
+		headerOrFooterSection("headers", extras.headers),
+		headerOrFooterSection("footers", extras.footers),
+		numberingSection(extras.numbering)
+	].filter((section) => section.length > 0);
+	if (nonEmptySections.length === 0) return ["This document carries no comments, footnotes, headers, footers, or numbering definitions."];
+	return nonEmptySections.flatMap((section, index) => index === 0 ? section : ["", ...section]);
+}
+//#endregion
+//#region src/commands/docx-extras.ts
+async function runDocxExtras(input, options) {
+	const command = "docx-extras";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const extras = readDocxExtras(pkg);
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(extras)}\n`);
+			return 0;
+		}
+		for (const line of formatDocxExtrasLines(extras)) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		process.stderr.write(`[${command}] ${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerDocxExtrasCommand(program) {
+	program.command("docx-extras <input>").description("print a docx's own comments, footnotes, headers, footers, and numbering definitions -- data readDocxContent's ContentDocument cannot carry").option("--json", "emit the raw DocxExtras object as JSON instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runDocxExtras(input, options);
+	});
+}
+//#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({});
+	try {
+		const format = inferFormatFromExtension(input);
+		if (format === void 0) {
+			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) => ({
+			family: face.family,
+			bold: face.bold,
+			italic: face.italic,
+			byteLength: face.bytes.length
+		}));
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(summaries)}\n`);
+			return 0;
+		}
+		if (summaries.length === 0) {
+			process.stdout.write("This document embeds no source fonts.\n");
+			return 0;
+		}
+		for (const face of summaries) {
+			const style = [face.bold ? "bold" : void 0, face.italic ? "italic" : void 0].filter((value) => value !== void 0).join(" ");
+			process.stdout.write(`${face.family}${style === "" ? "" : ` (${style})`} -- ${face.byteLength} bytes\n`);
+		}
+		return 0;
+	} catch (error) {
+		process.stderr.write(`${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerFontsCommand(program) {
+	program.command("fonts <input>").description("list every source-embedded font face a docx/pptx/odt/odp/ods/odg document carries (family, weight/style, byte length)").option("--json", "emit the face list as a JSON array instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runFonts(input, options);
+	});
+}
+//#endregion
 //#region src/commands/formats.ts
-const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, odb-forms, odb-reports, pdf-inspect, from-package";
+const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, odb-forms, odb-reports, pdf-inspect, from-package, fonts, docx-extras, metadata, set-metadata";
 function registerFormatsCommand(program) {
 	program.command("formats").description("list every source -> target conversion this CLI supports via a <source>-to-<target> command").option("--json", "emit the conversion list as a JSON array instead of a human-readable table", false).action((options) => {
 		const { conversions } = createLocalDocumentConverter();
@@ -626,6 +776,78 @@ function registerFromPackageCommand(program) {
 	});
 }
 //#endregion
+//#region src/runtime/metadata-format.ts
+const METADATA_KEYS = [
+	"title",
+	"author",
+	"subject",
+	"keywords",
+	"creator",
+	"producer",
+	"createdIso",
+	"modifiedIso"
+];
+function isPresent(entry) {
+	return entry[1] !== void 0;
+}
+function formatMetadataValue(value) {
+	return typeof value === "string" ? value : value.join(", ");
+}
+function presentMetadataEntries(metadata) {
+	return METADATA_KEYS.map((key) => [key, metadata[key]]).filter(isPresent);
+}
+function formatMetadataLines(metadata) {
+	return presentMetadataEntries(metadata).map(([key, value]) => `${key}: ${formatMetadataValue(value)}`);
+}
+//#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);
+	if (source === void 0) {
+		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 { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const metadata = readMetadataForFormat(source, new Uint8Array(inputBytes), signal);
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(metadata)}\n`);
+			return 0;
+		}
+		const lines = formatMetadataLines(metadata);
+		if (lines.length === 0) {
+			process.stdout.write("This document carries no metadata.\n");
+			return 0;
+		}
+		for (const line of lines) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		process.stderr.write(`[${command}] ${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerMetadataCommand(program) {
+	program.command("metadata <input>").description(`print a document's own title/author/subject/keywords/creator/producer/created/modified metadata (${KNOWN_DOCUMENT_FORMATS})`).option("--json", "emit the metadata as a JSON object instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runMetadata(input, options);
+	});
+}
+//#endregion
 //#region src/odb-structure.ts
 const INDENT = "  ";
 function indent(depth) {
@@ -867,7 +1089,7 @@ async function runOdbTables(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const pkg = decodePackage$1(new Uint8Array(inputBytes));
 		const tables = readOdbTables(pkg);
 		if (options.json) {
 			const summary = tables.map((table) => ({
@@ -912,7 +1134,7 @@ async function runOdbQuery(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const pkg = decodePackage$1(new Uint8Array(inputBytes));
 		const resolved = resolveQuerySql(pkg, options);
 		if ("errorMessage" in resolved) {
 			process.stderr.write(`[${command}] ${resolved.errorMessage}\n`);
@@ -934,7 +1156,7 @@ async function runOdbForms(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const forms = readOdbForms(decodePackage(new Uint8Array(inputBytes)));
+		const forms = readOdbForms(decodePackage$1(new Uint8Array(inputBytes)));
 		if (options.json) {
 			process.stdout.write(`${JSON.stringify(forms.map((form) => odbFormSummary(form)))}\n`);
 			return 0;
@@ -957,7 +1179,7 @@ async function runOdbReports(input, options) {
 	const { signal, getAbortReason } = createRuntimeSignal({});
 	try {
 		const inputBytes = await readInput(input, { signal });
-		const reports = readOdbReports(decodePackage(new Uint8Array(inputBytes)));
+		const reports = readOdbReports(decodePackage$1(new Uint8Array(inputBytes)));
 		if (options.json) {
 			process.stdout.write(`${JSON.stringify(reports)}\n`);
 			return 0;
@@ -1041,7 +1263,7 @@ async function runOdbRenderReport(input, output, options) {
 	try {
 		const inputBytes = await readInput(input, { signal });
 		const fonts = await loadProvidedFonts(options.fontFile ?? [], { signal });
-		const pkg = decodePackage(new Uint8Array(inputBytes));
+		const pkg = decodePackage$1(new Uint8Array(inputBytes));
 		const bytes = renderOdbReportBytes(readOdbReportContent(pkg, { report: options.report }), targetFormat, {
 			fonts,
 			signal,
@@ -1229,12 +1451,6 @@ function countImagesByFormat(images) {
 	for (const asset of Object.values(images)) counts.set(asset.format, (counts.get(asset.format) ?? 0) + 1);
 	return counts;
 }
-function isPresent(entry) {
-	return entry[1] !== void 0;
-}
-function formatMetadataValue(value) {
-	return typeof value === "string" ? value : value.join(", ");
-}
 async function runPdfInspect(input, options) {
 	const command = "pdf-inspect";
 	const { signal, getAbortReason } = createRuntimeSignal({});
@@ -1252,7 +1468,7 @@ async function runPdfInspect(input, options) {
 			}
 		});
 		if (options.full) {
-			process.stdout.write(`${JSON.stringify(layout, void 0, 2)}\n`);
+			process.stdout.write(`${JSON.stringify(layoutDocumentWithSchema(layout), void 0, 2)}\n`);
 			return 0;
 		}
 		const imagesByFormat = countImagesByFormat(layout.images);
@@ -1276,19 +1492,9 @@ async function runPdfInspect(input, options) {
 			const histogramText = Array.from(histogram.entries()).map(([kind, count]) => `${kind}=${count}`).join(", ");
 			process.stdout.write(`  page ${index + 1}: ${page.widthPt}pt x ${page.heightPt}pt${histogramText === "" ? "" : ` (${histogramText})`}\n`);
 		});
-		const presentMetadata = [
-			["title", layout.metadata.title],
-			["author", layout.metadata.author],
-			["subject", layout.metadata.subject],
-			["keywords", layout.metadata.keywords],
-			["creator", layout.metadata.creator],
-			["producer", layout.metadata.producer],
-			["createdIso", layout.metadata.createdIso],
-			["modifiedIso", layout.metadata.modifiedIso]
-		].filter(isPresent);
-		if (presentMetadata.length > 0) {
+		if (presentMetadataEntries(layout.metadata).length > 0) {
 			process.stdout.write("metadata:\n");
-			for (const [key, value] of presentMetadata) process.stdout.write(`  ${key}: ${formatMetadataValue(value)}\n`);
+			for (const line of formatMetadataLines(layout.metadata)) process.stdout.write(`  ${line}\n`);
 		}
 		if (imagesByFormat.size > 0) {
 			process.stdout.write("images:\n");
@@ -1306,8 +1512,155 @@ 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) {
+		process.stderr.write(`[${command}] conflicting output destinations: positional '${output}' and --out '${options.out}'\n`);
+		return 2;
+	}
+	const target = resolveTargetFormat(output, options.out, options.to);
+	if ("errorMessage" in target) {
+		process.stderr.write(`[${command}] ${target.errorMessage}\n`);
+		return 2;
+	}
+	const source = inferFormatFromExtension(input);
+	if (source === void 0) {
+		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,
+		subject: options.setSubject,
+		keywords: options.setKeywords === void 0 ? void 0 : parseKeywords(options.setKeywords)
+	};
+	const resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, target.format));
+	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);
+		})();
+		await writeOutput(resolvedOutput, bytes);
+		createDiagnosticReporter({
+			json: options.json,
+			quiet: options.quiet,
+			command
+		}).summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount: 0
+		});
+		return 0;
+	} catch (error) {
+		process.stderr.write(`${formatError(error, options.verbose)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerSetMetadataCommand(program) {
+	const command = program.command("set-metadata <input> [output]").description("patch a document's own title/author/subject/keywords, leaving every other field and every other flag as-is").addHelpText("after", [
+		"",
+		"Two write paths: a pdf source/target patches the metadata directly on the parsed PDF (writePdf), with no layout engine",
+		"involved at all -- genuinely lossless for everything else on the page. Every other supported format (docx, pptx, odt,",
+		"odp, ods, odg, markdown) rebuilds a fresh package from that format's own ContentDocument -- for docx specifically,",
+		"this is LOSSY: it drops anything docx-extras covers (comments, footnotes, headers/footers, numbering definitions),",
+		"since buildDocxPackage builds a fresh package from the ContentDocument alone, with no way to carry that data through.",
+		"",
+		"set-metadata does not convert format -- source and target must match. Run convert/from-package first, then",
+		"set-metadata on the result, if you need a different target format."
+	].join("\n"));
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	command.option("--to <format>", `target format when it cannot be inferred from the output path (${KNOWN_DOCUMENT_FORMATS})`);
+	command.option("--set-title <text>", "set the title field");
+	command.option("--set-author <text>", "set the author field");
+	command.option("--set-subject <text>", "set the subject field");
+	command.option("--set-keywords <csv>", "set the keywords field, comma-separated (trimmed, empty entries dropped)");
+	command.action(async (input, output, options) => {
+		process.exitCode = await runSetMetadata(input, output, options);
+	});
+}
+//#endregion
 //#region package.json
-var version = "1.3.0";
+var version = "1.5.0";
 //#endregion
 //#region src/program.ts
 function createProgram() {
@@ -1324,6 +1677,10 @@ function createProgram() {
 	registerOdmCommand(program);
 	registerOdbCommands(program);
 	registerPdfInspectCommand(program);
+	registerFontsCommand(program);
+	registerDocxExtrasCommand(program);
+	registerMetadataCommand(program);
+	registerSetMetadataCommand(program);
 	return program;
 }
 //#endregion

package/dist/{odb-structure-CX_0zL8_.js → odb-structure-Du1w_hOU.js}

@@ -247,6 +247,88 @@ function resolveDefaultOutputPath(inputPath, targetFormat) {
 	return join(directory, `${stem}.${formatToExtension(targetFormat)}`);
 }
 //#endregion
+//#region src/docx-extras-format.ts
+const INDENT$1 = "  ";
+function indent$1(depth) {
+	return INDENT$1.repeat(depth);
+}
+function commentLine(comment, position) {
+	const author = comment.author ?? "(no author)";
+	return `${indent$1(1)}[${position}] ${author}: ${comment.text}`;
+}
+function footnoteLine(footnote, position) {
+	const typeSuffix = footnote.type === void 0 ? "" : ` (${footnote.type})`;
+	return `${indent$1(1)}[${position}]${typeSuffix} ${footnote.text}`;
+}
+function commentsSection(comments) {
+	if (comments.length === 0) return [];
+	return ["comments", ...comments.map((comment, index) => commentLine(comment, index + 1))];
+}
+function footnotesSection(footnotes) {
+	if (footnotes.length === 0) return [];
+	return ["footnotes", ...footnotes.map((footnote, index) => footnoteLine(footnote, index + 1))];
+}
+function headerOrFooterSection(label, values) {
+	if (values.length === 0) return [];
+	return [label, ...values.map((text, index) => `${indent$1(1)}[${index + 1}] ${text}`)];
+}
+function numberingLevelLine(ilvl, level) {
+	const restartSuffix = level.restart === void 0 ? "" : `, restarts at level ${level.restart}`;
+	return `${indent$1(2)}level ${ilvl}: ${level.format} ${JSON.stringify(level.text)} starting at ${level.startAt}${restartSuffix}`;
+}
+function numberingSection(numbering) {
+	const numIds = Object.keys(numbering);
+	if (numIds.length === 0) return [];
+	const lines = ["numbering"];
+	for (const numId of numIds) {
+		const definition = numbering[numId];
+		if (definition === void 0) continue;
+		lines.push(`${indent$1(1)}numId ${numId}`);
+		const ilvls = Object.keys(definition.levels).sort((a, b) => Number(a) - Number(b));
+		for (const ilvl of ilvls) {
+			const level = definition.levels[ilvl];
+			if (level === void 0) continue;
+			lines.push(numberingLevelLine(ilvl, level));
+		}
+	}
+	return lines;
+}
+function formatDocxExtrasLines(extras) {
+	const nonEmptySections = [
+		commentsSection(extras.comments),
+		footnotesSection(extras.footnotes),
+		headerOrFooterSection("headers", extras.headers),
+		headerOrFooterSection("footers", extras.footers),
+		numberingSection(extras.numbering)
+	].filter((section) => section.length > 0);
+	if (nonEmptySections.length === 0) return ["This document carries no comments, footnotes, headers, footers, or numbering definitions."];
+	return nonEmptySections.flatMap((section, index) => index === 0 ? section : ["", ...section]);
+}
+//#endregion
+//#region src/runtime/metadata-format.ts
+const METADATA_KEYS = [
+	"title",
+	"author",
+	"subject",
+	"keywords",
+	"creator",
+	"producer",
+	"createdIso",
+	"modifiedIso"
+];
+function isPresent(entry) {
+	return entry[1] !== void 0;
+}
+function formatMetadataValue(value) {
+	return typeof value === "string" ? value : value.join(", ");
+}
+function presentMetadataEntries(metadata) {
+	return METADATA_KEYS.map((key) => [key, metadata[key]]).filter(isPresent);
+}
+function formatMetadataLines(metadata) {
+	return presentMetadataEntries(metadata).map(([key, value]) => `${key}: ${formatMetadataValue(value)}`);
+}
+//#endregion
 //#region src/odb-structure.ts
 const INDENT = "  ";
 function indent(depth) {
@@ -379,4 +461,4 @@ function formatOdbReportLines(report) {
 	return lines;
 }
 //#endregion
-export { odbFormSummary as a, writeOutput as c, inferFormatFromExtension as d, isDocumentFormat as f, formatOdbReportLines as i, loadProvidedFonts as l, describeOdbReport as n, readInput as o, formatOdbFormLines as r, resolveDefaultOutputPath as s, describeOdbForm as t, formatToExtension as u };
+export { odbFormSummary as a, formatDocxExtrasLines as c, writeOutput as d, loadProvidedFonts as f, isDocumentFormat as h, formatOdbReportLines as i, readInput as l, inferFormatFromExtension as m, describeOdbReport as n, formatMetadataLines as o, formatToExtension as p, formatOdbFormLines as r, presentMetadataEntries as s, describeOdbForm as t, resolveDefaultOutputPath as u };