@pptx-studio/cli 0.1.0

package/dist/main-DLx2onii.js

@@ -0,0 +1,1570 @@
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { PartStore, isOpcError, readZip } from "@pptx-studio/opc";
+import { formatReport, isValidateError, validatePackage } from "@pptx-studio/validate";
+import { spawnSync } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { firstDifference } from "@pptx-studio/xml";
+import { bisectPackages, describeChange, flattenChanges, roundTripPackage, summarizeBisect, summarizeRoundTrip } from "@pptx-studio/writer";
+import { censusPackage, formatCensus } from "@pptx-studio/census";
+import { loadDocument } from "@pptx-studio/model";
+import { renderSlide } from "@pptx-studio/render-svg";
+import { LAST_RESORT_FAMILIES, kerningEnabled, substituteFor } from "@pptx-studio/text";
+//#region src/bisect.ts
+const BISECT_DEFAULTS = {
+	oracle: "validate",
+	command: null,
+	maxRuns: 2e3,
+	timeout: 12e4,
+	write: null,
+	json: false,
+	quiet: false,
+	out: null,
+	progress: false
+};
+/** Where `powerpoint-oracle.ps1` lives, from `src/` and from `dist/` alike. */
+function oracleScriptPath() {
+	return fileURLToPath(new URL("../scripts/powerpoint-oracle.ps1", import.meta.url));
+}
+/**
+* The twenty-nine rules, asked of one candidate.
+*
+* No baseline is supplied and none could be: a candidate is a package that
+* never existed until this run, and it has no history. That makes every fatal
+* finding count as ours, which is the safe direction here for the same reason
+* it is in `validate` - the question is "is this package broken", not "who
+* broke it".
+*/
+function validateOracle() {
+	return (bytes) => {
+		try {
+			return validatePackage({ bytes }).ok ? "passes" : "fails";
+		} catch {
+			return "unresolved";
+		}
+	};
+}
+/** Write the candidate somewhere, run something over it, read the exit code. */
+function spawningOracle(run, options) {
+	const path = join(options.directory, "candidate.pptx");
+	return (bytes) => {
+		writeFileSync(path, bytes);
+		const result = run(path);
+		if (result.signal !== null || result.status === null) {
+			options.onSpawn?.("unresolved", result.signal ?? "no exit status");
+			return "unresolved";
+		}
+		const verdict = result.status === 0 ? "passes" : result.status === 1 ? "fails" : "unresolved";
+		options.onSpawn?.(verdict, "exit " + String(result.status));
+		return verdict;
+	};
+}
+function powerPointOracle(options) {
+	const script = oracleScriptPath();
+	return spawningOracle((path) => {
+		const result = spawnSync("powershell.exe", [
+			"-NoProfile",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-File",
+			script,
+			"-File",
+			path
+		], {
+			timeout: options.timeout,
+			encoding: "utf8",
+			windowsHide: true
+		});
+		return {
+			status: result.status,
+			signal: result.signal,
+			stderr: result.stderr ?? ""
+		};
+	}, options);
+}
+function commandOracle(command, options) {
+	return spawningOracle((path) => {
+		const filled = command.includes("{}") ? command.replaceAll("{}", path) : command + " " + path;
+		const result = spawnSync(filled, {
+			shell: true,
+			timeout: options.timeout,
+			encoding: "utf8",
+			windowsHide: true
+		});
+		return {
+			status: result.status,
+			signal: result.signal,
+			stderr: result.stderr ?? ""
+		};
+	}, options);
+}
+/** Shut down a PowerPoint this run started, so a bisection leaves nothing behind. */
+function quitPowerPoint(timeout) {
+	spawnSync("powershell.exe", [
+		"-NoProfile",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-File",
+		oracleScriptPath(),
+		"-QuitOnly"
+	], {
+		timeout,
+		encoding: "utf8",
+		windowsHide: true
+	});
+}
+/**
+* A change's two sides, short enough to read and showing where they part.
+*
+* Truncating both from the front is the obvious thing and it is useless: two
+* versions of a 4 kB element that differ at character 3 000 come out as the
+* same sixty-eight characters twice, which reads as a bug in the bisector. So
+* the window is centred on the first character where they actually differ.
+*/
+function sides(change, width = 66) {
+	const flatten = (text) => text.replaceAll("\r", "").replaceAll("\n", "⏎");
+	const was = change.was === null ? null : flatten(change.was);
+	const text = change.text === null ? null : flatten(change.text);
+	let from = 0;
+	if (was !== null && text !== null && (was.length > width || text.length > width)) {
+		const at = firstDifference(was, text);
+		if (at > width / 2) from = Math.floor(at - width / 2);
+	}
+	const show = (value, mark) => {
+		if (value === null) return "    " + mark + "  (absent)";
+		if (value === "") return "    " + mark + "  (nothing)";
+		const head = from > 0 ? "…" : "";
+		const body = value.slice(from, from + width);
+		const tail = from + width < value.length ? "…" : "";
+		return "    " + mark + "  " + head + body + tail;
+	};
+	return [show(was, "-"), show(text, "+")];
+}
+/**
+* Render a result.
+*
+* Exported for the same reason `formatRoundTrip` is: the branches worth reading
+* are the ones a green corpus cannot produce, and they need a test of their own.
+*/
+function formatBisect(stats, result, quiet) {
+	const lines = [];
+	if (!quiet) lines.push("bisect " + stats.original, "   vs. " + stats.broken, "", "  original  " + String(stats.bytesOriginal) + " bytes, " + String(stats.entriesOriginal) + " entries", "  broken    " + String(stats.bytesBroken) + " bytes, " + String(stats.entriesBroken) + " entries", "  delta     " + String(flattenChanges(result.changes).length) + " change(s) in " + String(result.changes.length) + " entry(s)", "  oracle    " + stats.oracle + ", " + String(result.runs) + " run(s)" + (result.cached > 0 ? ", " + String(result.cached) + " from cache" : "") + (result.unresolved > 0 ? ", " + String(result.unresolved) + " unresolved" : ""), "");
+	switch (result.outcome) {
+		case "identical":
+			lines.push("  the two packages hold the same entries, byte for byte");
+			break;
+		case "broken-passes":
+			lines.push("  the second package passes the oracle, so there is nothing to look for", "  (" + String(flattenChanges(result.changes).length) + " change(s) between them, none fatal)");
+			break;
+		case "original-fails":
+			lines.push("  the *original* fails the oracle, so the cause is not in the difference", "  nothing was narrowed down; look at the original package first");
+			break;
+		case "localized":
+			lines.push("  " + summarizeBisect(result), "");
+			for (const change of result.minimal) lines.push("  " + describeChange(change), ...sides(change), "");
+	}
+	if (result.exhausted) lines.push("", "  stopped at the ceiling of " + String(result.runs) + " oracle run(s).", "  the answer above still fails, but it is not minimal - raise --max-runs.");
+	if (result.truncated) lines.push("", "  the delta was too large to decompose completely, so some changes are", "  whole entries rather than elements - raise --max-changes.");
+	return lines.join("\n") + "\n";
+}
+function bisectFiles(originalPath, brokenPath, options = BISECT_DEFAULTS, note = () => {}) {
+	const original = new Uint8Array(readFileSync(originalPath));
+	const broken = brokenPath === null ? roundTripPackage(original).exported.bytes : new Uint8Array(readFileSync(brokenPath));
+	const directory = mkdtempSync(join(tmpdir(), "pptx-bisect-"));
+	try {
+		const spawnOptions = {
+			timeout: options.timeout,
+			directory
+		};
+		const oracle = options.oracle === "validate" ? validateOracle() : options.oracle === "powerpoint" ? powerPointOracle(spawnOptions) : commandOracle(options.command ?? "", spawnOptions);
+		const result = bisectPackages(original, broken, {
+			oracle,
+			maxRuns: options.maxRuns,
+			...options.progress ? { onRun: (run) => {
+				note("  run " + String(run.run).padStart(4) + "  " + run.label + "\n");
+			} } : {}
+		});
+		const stats = {
+			original: originalPath,
+			broken: brokenPath ?? "(our own export of it)",
+			bytesOriginal: original.length,
+			bytesBroken: broken.length,
+			entriesOriginal: readZip(original).entries.length,
+			entriesBroken: readZip(broken).entries.length,
+			oracle: options.oracle
+		};
+		const output = options.json ? JSON.stringify({
+			original: originalPath,
+			broken: stats.broken,
+			oracle: options.oracle,
+			outcome: result.outcome,
+			runs: result.runs,
+			cached: result.cached,
+			unresolved: result.unresolved,
+			exhausted: result.exhausted,
+			truncated: result.truncated,
+			delta: flattenChanges(result.changes).length,
+			minimal: result.minimal.map((change) => ({
+				entry: change.entry,
+				kind: change.kind,
+				where: change.where,
+				was: change.was,
+				text: change.text
+			}))
+		}, null, 2) + "\n" : formatBisect(stats, result, options.quiet);
+		if (options.write !== null) writeFileSync(options.write, result.bytes);
+		return {
+			result,
+			output,
+			exitCode: result.outcome === "localized" || result.outcome === "original-fails" ? 1 : 0
+		};
+	} finally {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+		if (options.oracle === "powerpoint") quitPowerPoint(options.timeout);
+	}
+}
+function runBisect(originalPath, brokenPath, options, write) {
+	const result = bisectFiles(originalPath, brokenPath, options, write);
+	if (options.out === null) write(result.output);
+	else writeFileSync(options.out, result.output);
+	return result.exitCode;
+}
+//#endregion
+//#region src/inspect.ts
+const INSPECT_DEFAULTS = {
+	json: false,
+	parts: false,
+	namespaces: false,
+	top: 15,
+	out: null
+};
+/** Run a census over one file and render it. Does no I/O of its own beyond the read. */
+function inspectFile(path, options = INSPECT_DEFAULTS) {
+	const bytes = new Uint8Array(readFileSync(path));
+	const census = censusPackage(bytes);
+	return {
+		census,
+		output: options.json ? JSON.stringify(census, null, 2) + "\n" : formatCensus(census, {
+			parts: options.parts,
+			namespaces: options.namespaces,
+			top: options.top
+		}),
+		exitCode: census.problems.filter((problem) => problem.severity === "error").length > 0 ? 1 : 0
+	};
+}
+/** Run `inspectFile` and put the result where the options say. */
+function runInspect(path, options, write) {
+	const result = inspectFile(path, options);
+	if (options.out === null) write(result.output);
+	else writeFileSync(options.out, result.output);
+	return result.exitCode;
+}
+//#endregion
+//#region src/render/errors.ts
+const RENDER_ERROR_CODES = [
+	"CLI_FONT_UNREADABLE",
+	"CLI_FONT_DIR",
+	"CLI_NO_FACE",
+	"CLI_FONT_SIZE",
+	"CLI_NO_SLIDE",
+	"CLI_OUTPUT_PATH"
+];
+var RenderError = class extends Error {
+	name = "RenderError";
+	code;
+	/** The font file, deck path or typeface the failure is about. */
+	subject;
+	constructor(code, message, subject) {
+		super(message);
+		this.code = code;
+		this.subject = subject;
+	}
+};
+function isRenderError(error) {
+	return error instanceof RenderError;
+}
+//#endregion
+//#region src/render/sfnt.ts
+/**
+* The four tables a measurement needs, read out of a font file.
+*
+* Not a font library: nothing here decodes an outline, and a CFF font is read
+* as happily as a glyf one because advances live in `hmtx` either way. What it
+* answers is the question the browser answers with `measureText`, which is the
+* one thing `render-svg` cannot get in Node. Every reading below was measured
+* against Chromium in experiment T13 rather than taken from the specification.
+* ADR 0042.
+*/
+const OTTO = 1330926671;
+const TRUE_TYPE = 65536;
+const TTCF = 1953784678;
+/** `OS/2.fsSelection` bit 7: the typographic metrics are the ones to use. */
+const USE_TYPO_METRICS = 128;
+function readerOf(bytes) {
+	return {
+		bytes,
+		view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+	};
+}
+function u8(r, at) {
+	return r.view.getUint8(at);
+}
+function u16(r, at) {
+	return r.view.getUint16(at);
+}
+function i16(r, at) {
+	return r.view.getInt16(at);
+}
+function u32(r, at) {
+	return r.view.getUint32(at);
+}
+function unreadable(what, subject) {
+	throw new RenderError("CLI_FONT_UNREADABLE", what, subject);
+}
+function directoryAt(bytes, start, subject) {
+	const r = readerOf(bytes);
+	if (start + 12 > bytes.length) unreadable("font directory runs past the file", subject);
+	const count = u16(r, start + 4);
+	const out = /* @__PURE__ */ new Map();
+	for (let i = 0; i < count; i++) {
+		const at = start + 12 + i * 16;
+		if (at + 16 > bytes.length) unreadable("table directory runs past the file", subject);
+		const tag = String.fromCharCode(u8(r, at), u8(r, at + 1), u8(r, at + 2), u8(r, at + 3));
+		const offset = u32(r, at + 8);
+		const length = u32(r, at + 12);
+		if (offset < bytes.length) out.set(tag, bytes.subarray(offset, Math.min(offset + length, bytes.length)));
+	}
+	return out;
+}
+/** Every font in the file: one for a plain font, several for a collection. */
+function fontsIn(bytes, subject) {
+	if (bytes.length < 12) unreadable("too short to be a font", subject);
+	const r = readerOf(bytes);
+	const version = u32(r, 0);
+	if (version === TTCF) {
+		const count = u32(r, 8);
+		const out = [];
+		for (let i = 0; i < count; i++) out.push(directoryAt(bytes, u32(r, 12 + i * 4), subject));
+		return out;
+	}
+	if (version !== TRUE_TYPE && version !== OTTO) unreadable(`0x${version.toString(16).padStart(8, "0")} is not an SFNT signature`, subject);
+	return [directoryAt(bytes, 0, subject)];
+}
+function required(tables, tag, subject) {
+	const table = tables.get(tag);
+	if (table === void 0) unreadable(`no ${tag} table`, subject);
+	return table;
+}
+/**
+* The names a face is known by, decoded from the Windows platform records.
+*
+* Platform 3 encoding 1 is UTF-16BE and is what every font shipped for Windows
+* carries; platform 1 is Mac Roman and is read only where a face has no
+* Windows record at all, which is rare enough to be worth the four lines.
+*/
+function namesOf(tables, subject) {
+	const table = required(tables, "name", subject);
+	const r = readerOf(table);
+	if (table.length < 6) unreadable("name table is truncated", subject);
+	const count = u16(r, 2);
+	const storage = u16(r, 4);
+	const out = /* @__PURE__ */ new Map();
+	const seenWindows = /* @__PURE__ */ new Set();
+	for (let i = 0; i < count; i++) {
+		const at = 6 + i * 12;
+		if (at + 12 > table.length) break;
+		const platform = u16(r, at);
+		const encoding = u16(r, at + 2);
+		const nameId = u16(r, at + 6);
+		const length = u16(r, at + 8);
+		const offset = storage + u16(r, at + 10);
+		if (offset + length > table.length) continue;
+		const raw = table.subarray(offset, offset + length);
+		if (platform === 3 && (encoding === 1 || encoding === 0)) {
+			let text = "";
+			for (let j = 0; j + 1 < raw.length; j += 2) text += String.fromCharCode((raw[j] ?? 0) << 8 | (raw[j + 1] ?? 0));
+			out.set(nameId, text);
+			seenWindows.add(nameId);
+		} else if (platform === 1 && encoding === 0 && !seenWindows.has(nameId)) out.set(nameId, String.fromCharCode(...raw));
+	}
+	return out;
+}
+/**
+* The best Unicode subtable in the font.
+*
+* Preference order is the one every shaper uses: a format 12 full-repertoire
+* table beats a format 4 BMP one, because a face that has both maps astral
+* code points only in the first.
+*/
+function cmapOf(tables, subject) {
+	const table = required(tables, "cmap", subject);
+	const r = readerOf(table);
+	if (table.length < 4) unreadable("cmap table is truncated", subject);
+	const count = u16(r, 2);
+	let best;
+	for (let i = 0; i < count; i++) {
+		const at = 4 + i * 8;
+		if (at + 8 > table.length) break;
+		const platform = u16(r, at);
+		const encoding = u16(r, at + 2);
+		const offset = u32(r, at + 4);
+		if (offset + 2 > table.length) continue;
+		if (!(platform === 3 && (encoding === 10 || encoding === 1 || encoding === 0) || platform === 0)) continue;
+		const format = u16(readerOf(table.subarray(offset)), 0);
+		const score = format === 12 ? 3 : format === 4 ? 2 : format === 6 || format === 0 ? 1 : 0;
+		if (score > 0 && (best === void 0 || score > best.score)) best = {
+			offset,
+			score
+		};
+	}
+	if (best === void 0) unreadable("no Unicode cmap subtable", subject);
+	const sub = table.subarray(best.offset);
+	const s = readerOf(sub);
+	const format = u16(s, 0);
+	if (format === 4) {
+		const segCount = u16(s, 6) / 2;
+		const ends = 14;
+		const starts = ends + segCount * 2 + 2;
+		const deltas = starts + segCount * 2;
+		const ranges = deltas + segCount * 2;
+		return (codePoint) => {
+			if (codePoint > 65535) return 0;
+			for (let seg = 0; seg < segCount; seg++) {
+				if (u16(s, ends + seg * 2) < codePoint) continue;
+				if (u16(s, starts + seg * 2) > codePoint) return 0;
+				const rangeOffset = u16(s, ranges + seg * 2);
+				if (rangeOffset === 0) return codePoint + i16(s, deltas + seg * 2) & 65535;
+				const at = ranges + seg * 2 + rangeOffset + (codePoint - u16(s, starts + seg * 2)) * 2;
+				if (at + 2 > sub.length) return 0;
+				const glyph = u16(s, at);
+				return glyph === 0 ? 0 : glyph + i16(s, deltas + seg * 2) & 65535;
+			}
+			return 0;
+		};
+	}
+	if (format === 12) {
+		const groups = u32(s, 12);
+		return (codePoint) => {
+			let low = 0;
+			let high = groups - 1;
+			while (low <= high) {
+				const mid = low + high >> 1;
+				const at = 16 + mid * 12;
+				const start = u32(s, at);
+				const end = u32(s, at + 4);
+				if (codePoint < start) high = mid - 1;
+				else if (codePoint > end) low = mid + 1;
+				else return u32(s, at + 8) + (codePoint - start);
+			}
+			return 0;
+		};
+	}
+	if (format === 6) {
+		const first = u16(s, 6);
+		const entries = u16(s, 8);
+		return (codePoint) => {
+			const at = codePoint - first;
+			return at < 0 || at >= entries ? 0 : u16(s, 10 + at * 2);
+		};
+	}
+	return (codePoint) => codePoint > 255 ? 0 : u8(s, 6 + codePoint);
+}
+const NO_KERNING = () => 0;
+function coverageIndex(r, at, glyph) {
+	const format = u16(r, at);
+	if (format === 1) {
+		const count = u16(r, at + 2);
+		for (let i = 0; i < count; i++) if (u16(r, at + 4 + i * 2) === glyph) return i;
+		return -1;
+	}
+	if (format !== 2) return -1;
+	const ranges = u16(r, at + 2);
+	for (let i = 0; i < ranges; i++) {
+		const record = at + 4 + i * 6;
+		if (glyph >= u16(r, record) && glyph <= u16(r, record + 2)) return u16(r, record + 4) + (glyph - u16(r, record));
+	}
+	return -1;
+}
+function classOf(r, at, glyph) {
+	const format = u16(r, at);
+	if (format === 1) {
+		const start = u16(r, at + 2);
+		const count = u16(r, at + 4);
+		const index = glyph - start;
+		return index < 0 || index >= count ? 0 : u16(r, at + 6 + index * 2);
+	}
+	if (format !== 2) return 0;
+	const ranges = u16(r, at + 2);
+	for (let i = 0; i < ranges; i++) {
+		const record = at + 4 + i * 6;
+		if (glyph >= u16(r, record) && glyph <= u16(r, record + 2)) return u16(r, record + 4);
+	}
+	return 0;
+}
+/** The byte width of a GPOS value record, which is one 16-bit field per set bit. */
+function valueSize(format) {
+	let bits = 0;
+	for (let i = 0; i < 16; i++) if ((format & 1 << i) !== 0) bits += 1;
+	return bits * 2;
+}
+/** `XAdvance` is bit 2, and it is the only field a horizontal advance reads. */
+const X_ADVANCE = 4;
+function pairPosLookup(r, at) {
+	const format = u16(r, at);
+	const valueFormat1 = u16(r, at + 4);
+	const valueFormat2 = u16(r, at + 6);
+	if ((valueFormat1 & X_ADVANCE) === 0) return void 0;
+	const size1 = valueSize(valueFormat1);
+	const size2 = valueSize(valueFormat2);
+	const coverage = at + u16(r, at + 2);
+	if (format === 1) {
+		const setCount = u16(r, at + 8);
+		return (left, right) => {
+			const index = coverageIndex(r, coverage, left);
+			if (index < 0 || index >= setCount) return 0;
+			const set = at + u16(r, at + 10 + index * 2);
+			const pairs = u16(r, set);
+			for (let i = 0; i < pairs; i++) {
+				const record = set + 2 + i * (2 + size1 + size2);
+				if (u16(r, record) === right) return i16(r, record + 2);
+			}
+			return 0;
+		};
+	}
+	if (format !== 2) return void 0;
+	const classDef1 = at + u16(r, at + 8);
+	const classDef2 = at + u16(r, at + 10);
+	const class1Count = u16(r, at + 12);
+	const class2Count = u16(r, at + 14);
+	return (left, right) => {
+		if (coverageIndex(r, coverage, left) < 0) return 0;
+		const c1 = classOf(r, classDef1, left);
+		const c2 = classOf(r, classDef2, right);
+		if (c1 >= class1Count || c2 >= class2Count) return 0;
+		return i16(r, at + 16 + (c1 * class2Count + c2) * (size1 + size2));
+	};
+}
+/**
+* The `kern` feature's pair adjustments, if the font has GPOS.
+*
+* Only the `kern` feature: a font's GPOS also carries mark attachment and
+* cursive positioning, and neither changes an advance.
+*/
+function gposKerning(tables) {
+	const table = tables.get("GPOS");
+	if (table === void 0 || table.length < 10) return void 0;
+	const r = readerOf(table);
+	const featureList = u16(r, 6);
+	const lookupList = u16(r, 8);
+	if (featureList >= table.length || lookupList >= table.length) return void 0;
+	const wanted = /* @__PURE__ */ new Set();
+	const featureCount = u16(r, featureList);
+	for (let i = 0; i < featureCount; i++) {
+		const record = featureList + 2 + i * 6;
+		if (String.fromCharCode(u8(r, record), u8(r, record + 1), u8(r, record + 2), u8(r, record + 3)) !== "kern") continue;
+		const feature = featureList + u16(r, record + 4);
+		const lookups = u16(r, feature + 2);
+		for (let j = 0; j < lookups; j++) wanted.add(u16(r, feature + 4 + j * 2));
+	}
+	if (wanted.size === 0) return void 0;
+	const found = [];
+	const lookupCount = u16(r, lookupList);
+	for (const index of wanted) {
+		if (index >= lookupCount) continue;
+		const lookup = lookupList + u16(r, lookupList + 2 + index * 2);
+		if (u16(r, lookup) !== 2) continue;
+		const subtables = u16(r, lookup + 4);
+		for (let i = 0; i < subtables; i++) {
+			const pairs = pairPosLookup(r, lookup + u16(r, lookup + 6 + i * 2));
+			if (pairs !== void 0) found.push(pairs);
+		}
+	}
+	if (found.length === 0) return void 0;
+	return (left, right) => {
+		for (const lookup of found) {
+			const adjust = lookup(left, right);
+			if (adjust !== 0) return adjust;
+		}
+		return 0;
+	};
+}
+/** The pre-OpenType `kern` table, format 0, horizontal subtables only. */
+function legacyKerning(tables) {
+	const table = tables.get("kern");
+	if (table === void 0 || table.length < 4) return void 0;
+	const r = readerOf(table);
+	const subtables = u16(r, 2);
+	const pairs = /* @__PURE__ */ new Map();
+	let at = 4;
+	for (let i = 0; i < subtables && at + 14 <= table.length; i++) {
+		const length = u16(r, at + 2);
+		const coverage = u16(r, at + 4);
+		const horizontal = (coverage & 1) !== 0;
+		const format = coverage >> 8 & 255;
+		if (horizontal && format === 0) {
+			const count = u16(r, at + 6);
+			for (let j = 0; j < count; j++) {
+				const record = at + 14 + j * 6;
+				if (record + 6 > table.length) break;
+				pairs.set(u16(r, record) << 16 | u16(r, record + 2), i16(r, record + 4));
+			}
+		}
+		at += length === 0 ? 14 : length;
+	}
+	if (pairs.size === 0) return void 0;
+	return (left, right) => pairs.get(left << 16 | right) ?? 0;
+}
+/**
+* The vertical metrics a browser reports for the face.
+*
+* T13 built one font whose `hhea`, `usWin` and `sTypo` pairs are all different
+* and asked Chromium for `fontBoundingBoxAscent`: it answered `usWin`, and
+* answered `sTypo` from the same font with `fsSelection` bit 7 set. So `hhea`
+* is never the answer, and a reader that ignores bit 7 is wrong on every font
+* that sets it, which is most of the ones shipped since 2015.
+*/
+function metricsOf(tables, subject) {
+	const unitsPerEm = u16(readerOf(required(tables, "head", subject)), 18);
+	if (unitsPerEm <= 0) unreadable("head.unitsPerEm is zero", subject);
+	const os2 = tables.get("OS/2");
+	if (os2 === void 0 || os2.length < 78) {
+		const hhea = readerOf(required(tables, "hhea", subject));
+		return {
+			unitsPerEm,
+			ascent: i16(hhea, 4),
+			descent: -i16(hhea, 6),
+			source: "usWin"
+		};
+	}
+	const r = readerOf(os2);
+	if ((u16(r, 62) & USE_TYPO_METRICS) !== 0) return {
+		unitsPerEm,
+		ascent: i16(r, 68),
+		descent: -i16(r, 70),
+		source: "sTypo"
+	};
+	return {
+		unitsPerEm,
+		ascent: u16(r, 74),
+		descent: u16(r, 76),
+		source: "usWin"
+	};
+}
+function advancesOf(tables, subject) {
+	const metrics = u16(readerOf(required(tables, "hhea", subject)), 34);
+	const hmtx = required(tables, "hmtx", subject);
+	const r = readerOf(hmtx);
+	if (metrics === 0) unreadable("hhea.numberOfHMetrics is zero", subject);
+	return (glyph) => {
+		const at = Math.min(glyph, metrics - 1) * 4;
+		return at + 2 <= hmtx.length ? u16(r, at) : 0;
+	};
+}
+const BOLD_STYLE = /bold|black|heavy|semibold|extrabold|demibold/i;
+const ITALIC_STYLE = /italic|oblique/i;
+/** Read one font out of an already-located table directory. */
+function faceOf(tables, subject) {
+	const names = namesOf(tables, subject);
+	const family = names.get(1);
+	if (family === void 0 || family === "") unreadable("no family name", subject);
+	const subfamily = names.get(2) ?? "Regular";
+	const cmap = cmapOf(tables, subject);
+	const advance = advancesOf(tables, subject);
+	const kerning = gposKerning(tables) ?? legacyKerning(tables) ?? NO_KERNING;
+	const macStyle = u16(readerOf(required(tables, "head", subject)), 44);
+	return {
+		family,
+		subfamily,
+		typographicFamily: names.get(16),
+		metrics: metricsOf(tables, subject),
+		bold: BOLD_STYLE.test(subfamily) || (macStyle & 1) !== 0,
+		italic: ITALIC_STYLE.test(subfamily) || (macStyle & 2) !== 0,
+		advanceOf(codePoint) {
+			const glyph = cmap(codePoint);
+			return glyph === 0 ? void 0 : advance(glyph);
+		},
+		kernBetween(left, right) {
+			const a = cmap(left);
+			const b = cmap(right);
+			return a === 0 || b === 0 ? 0 : kerning(a, b);
+		}
+	};
+}
+/** Every face in a file, which is one unless the file is a collection. */
+function facesIn(bytes, subject) {
+	return fontsIn(bytes, subject).map((tables) => faceOf(tables, subject));
+}
+//#endregion
+//#region src/render/faces.ts
+/**
+* Which file on this machine is the typeface the deck asked for.
+*
+* The browser answers this with a font stack and never tells us what it chose;
+* here the choice is ours, so it is also reportable - `renderDeck` can say
+* "Aptos was drawn in Carlito" because this module knows it was. The
+* substitution table itself is `@pptx-studio/text`'s, so the two renderers
+* cannot fall back differently. ADR 0042.
+*/
+const FONT_FILE = /\.(ttf|ttc|otf|otc)$/i;
+/** Deep enough for `/usr/share/fonts/truetype/dejavu`, and no deeper. */
+const MAX_DEPTH = 4;
+/** Case and whitespace are not part of a typeface's identity for a lookup. */
+function key(family) {
+	return family.trim().replace(/\s+/g, " ").toLowerCase();
+}
+/** Where fonts live on this platform, whether or not the directories exist. */
+function systemFontDirectories(platform = process.platform) {
+	const home = homedir();
+	if (platform === "win32") {
+		const root = process.env["SystemRoot"] ?? "C:\\Windows";
+		const local = process.env["LOCALAPPDATA"];
+		return [join(root, "Fonts"), ...local === void 0 ? [] : [join(local, "Microsoft", "Windows", "Fonts")]];
+	}
+	if (platform === "darwin") return [
+		"/System/Library/Fonts",
+		"/Library/Fonts",
+		join(home, "Library", "Fonts")
+	];
+	return [
+		"/usr/share/fonts",
+		"/usr/local/share/fonts",
+		join(home, ".local", "share", "fonts"),
+		join(home, ".fonts")
+	];
+}
+function filesUnder(directory, depth, out) {
+	if (depth > MAX_DEPTH) return;
+	let entries;
+	try {
+		entries = readdirSync(directory, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const path = join(directory, entry.name);
+		if (entry.isDirectory()) filesUnder(path, depth + 1, out);
+		else if (FONT_FILE.test(entry.name)) out.push(path);
+	}
+}
+/**
+* The style slot a face fills.
+*
+* Two bits rather than a weight axis, because DrawingML has no weight axis:
+* `a:rPr/@b` is a boolean and "Roboto Light" is a typeface name, not a weight.
+*/
+function slot(bold, italic) {
+	return (bold ? 1 : 0) | (italic ? 2 : 0);
+}
+/**
+* Read every font file under the given directories, once.
+*
+* A file that will not parse is skipped rather than fatal: a font directory on
+* a real machine holds `.ttf` files that are bitmap-only, damaged, or not fonts
+* at all, and one of them must not stop a deck from rendering.
+*/
+function indexFonts(options = {}) {
+	for (const directory of options.extra ?? []) try {
+		if (!statSync(directory).isDirectory()) throw new RenderError("CLI_FONT_DIR", `${directory} is not a directory`, directory);
+	} catch (error) {
+		if (error instanceof RenderError) throw error;
+		throw new RenderError("CLI_FONT_DIR", `no such directory: ${directory}`, directory);
+	}
+	const directories = [...options.extra ?? [], ...options.system === false ? [] : systemFontDirectories(options.platform)];
+	const files = [];
+	for (const directory of directories) filesUnder(directory, 0, files);
+	const indexed = [];
+	const byFamily = /* @__PURE__ */ new Map();
+	const claim = (family, entry) => {
+		const slots = byFamily.get(key(family)) ?? [
+			void 0,
+			void 0,
+			void 0,
+			void 0
+		];
+		const at = slot(entry.face.bold, entry.face.italic);
+		slots[at] ??= entry;
+		byFamily.set(key(family), slots);
+	};
+	for (const file of files) {
+		let faces;
+		try {
+			faces = facesIn(new Uint8Array(readFileSync(file)), file);
+		} catch {
+			continue;
+		}
+		for (const face of faces) {
+			const entry = {
+				face,
+				file
+			};
+			indexed.push(entry);
+			claim(face.family, entry);
+			if (face.typographicFamily !== void 0) claim(face.typographicFamily, entry);
+		}
+	}
+	/** The nearest slot to the one asked for: exact, then drop italic, then bold. */
+	const pick = (family, bold, italic) => {
+		const slots = byFamily.get(key(family));
+		if (slots === void 0) return void 0;
+		const wanted = [
+			slot(bold, italic),
+			slot(bold, false),
+			slot(false, italic),
+			slot(false, false),
+			0,
+			1,
+			2,
+			3
+		];
+		for (const at of wanted) {
+			const found = slots[at];
+			if (found !== void 0) return found;
+		}
+	};
+	return {
+		indexed,
+		directories,
+		resolve(family, bold, italic) {
+			const direct = pick(family, bold, italic);
+			if (direct !== void 0) return {
+				face: direct.face,
+				asked: family,
+				drawn: family,
+				file: direct.file,
+				substituted: false
+			};
+			const chain = [substituteFor(family)?.use, ...LAST_RESORT_FAMILIES].filter((name) => name !== void 0);
+			for (const name of chain) {
+				const found = pick(name, bold, italic);
+				if (found !== void 0) return {
+					face: found.face,
+					asked: family,
+					drawn: name,
+					file: found.file,
+					substituted: true
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/render/measure.ts
+/**
+* `TextMeasurer` and `FaceBoxProbe` over font tables instead of a canvas.
+*
+* This is a second measurement engine, and `@pptx-studio/text` says in as many
+* words that nothing inside it may measure by a second route. That rule holds:
+* this is outside it, in the one package where Node exists, and it is here
+* because the browser's engine is not available to a server. What makes it safe
+* is that T13 measured Chromium's arithmetic rather than guessing it, so the two
+* engines agree exactly on a face they both have. ADR 0042.
+*/
+/**
+* The fixed-point step Chromium reports an advance in.
+*
+* T13 measured 252 widths across seven fonts, six strings and six sizes. Summing
+* exact floats fits 88 of them; quantising each glyph advance toward zero and
+* each kern adjustment to nearest, both at 1/65536 px, fits all 216. The
+* difference is never more than 1.6e-5 px and matters to nothing on a slide -
+* it is here because a rule that reproduces the browser exactly can be tested
+* exactly, and one that is merely close cannot.
+*/
+const FIXED = 65536;
+/**
+* Every advance in this font is positive, so truncation and flooring are the
+* same rule; T13 had no probe that could separate them and does not claim one.
+*/
+function quantiseAdvance(px) {
+	return Math.trunc(px * FIXED) / FIXED;
+}
+function quantiseKern(px) {
+	return Math.round(px * FIXED) / FIXED;
+}
+/**
+* A measurer bound to one library.
+*
+* Both probes cache by family, because a slide asks for the same handful of
+* typefaces thousands of times and nothing can change between two asks.
+*/
+function createFontMeasurer(library) {
+	const resolved = /* @__PURE__ */ new Map();
+	const missing = /* @__PURE__ */ new Set();
+	/** Which face draws a code point the asked-for face has no glyph for. */
+	const fallbacks = /* @__PURE__ */ new Map();
+	const faceFor = (family, bold, italic) => {
+		const cacheKey = `${family}${bold ? "b" : ""}${italic ? "i" : ""}`;
+		const cached = resolved.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const found = library.resolve(family, bold, italic);
+		if (found === void 0) throw new RenderError("CLI_NO_FACE", `no face on this machine can stand in for ${JSON.stringify(family)}; ${String(library.indexed.length)} face(s) were indexed from ${library.directories.join(", ")}`, family);
+		resolved.set(cacheKey, found);
+		return found;
+	};
+	/**
+	* The advance of one code point, in font units over its own em.
+	*
+	* A face that lacks the glyph does not draw a blank: the browser would fall
+	* back per character, so the whole index is searched once per code point and
+	* the answer cached. A code point nothing has is recorded and contributes the
+	* face's own `.notdef` width, which is what is drawn.
+	*/
+	const advanceOf = (face, codePoint) => {
+		const own = face.face.advanceOf(codePoint);
+		if (own !== void 0) return {
+			units: own,
+			em: face.face.metrics.unitsPerEm
+		};
+		const cacheKey = String(codePoint);
+		let stand = fallbacks.get(cacheKey);
+		if (stand === void 0) {
+			stand = null;
+			for (const entry of library.indexed) if (entry.face.advanceOf(codePoint) !== void 0) {
+				stand = {
+					...face,
+					face: entry.face,
+					drawn: entry.face.family,
+					file: entry.file
+				};
+				break;
+			}
+			fallbacks.set(cacheKey, stand);
+		}
+		if (stand === null) {
+			missing.add(codePoint);
+			return {
+				units: 0,
+				em: face.face.metrics.unitsPerEm
+			};
+		}
+		return {
+			units: stand.face.advanceOf(codePoint) ?? 0,
+			em: stand.face.metrics.unitsPerEm
+		};
+	};
+	const measurer = { measure(text, font) {
+		if (!Number.isFinite(font.sz) || font.sz <= 0) throw new RenderError("CLI_FONT_SIZE", `font size ${String(font.sz)} is not a positive size`, font.family);
+		const face = faceFor(font.family, font.bold === true, font.italic === true);
+		const px = font.sz / 100;
+		const kerns = kerningEnabled(font.kern, font.sz);
+		const spacing = (font.spc ?? 0) / 100;
+		const points = [...text];
+		let width = 0;
+		for (let i = 0; i < points.length; i++) {
+			const codePoint = points[i]?.codePointAt(0) ?? 0;
+			const { units, em } = advanceOf(face, codePoint);
+			width += quantiseAdvance(units * px / em);
+			width += spacing;
+			if (kerns && i + 1 < points.length) {
+				const next = points[i + 1]?.codePointAt(0) ?? 0;
+				const adjust = face.face.kernBetween(codePoint, next);
+				if (adjust !== 0) width += quantiseKern(adjust * px / face.face.metrics.unitsPerEm);
+			}
+		}
+		return { width };
+	} };
+	const boxes = /* @__PURE__ */ new Map();
+	return {
+		measurer,
+		faceBox: { box(family) {
+			const cached = boxes.get(family);
+			if (cached !== void 0) return cached;
+			const { metrics } = faceFor(family, false, false).face;
+			const box = {
+				ascent: metrics.ascent / metrics.unitsPerEm,
+				descent: metrics.descent / metrics.unitsPerEm,
+				ideographic: metrics.descent / metrics.unitsPerEm
+			};
+			boxes.set(family, box);
+			return box;
+		} },
+		used() {
+			const seen = /* @__PURE__ */ new Map();
+			for (const face of resolved.values()) seen.set(face.asked, {
+				asked: face.asked,
+				drawn: face.drawn,
+				file: face.file,
+				substituted: face.substituted
+			});
+			return [...seen.values()].sort((a, b) => a.asked < b.asked ? -1 : 1);
+		},
+		missing() {
+			return [...missing].sort((a, b) => a - b);
+		}
+	};
+}
+//#endregion
+//#region src/render/render.ts
+/**
+* `pptx-studio render` - slides to SVG, with no browser anywhere.
+*
+* Every part of the picture except text was already reachable from Node:
+* geometry, fills, strokes, effects and images are pure functions over the
+* model, and an image's size comes out of its own header rather than a decoder.
+* Text was the one thing that needed a canvas, and `measure.ts` is what replaces
+* it. ADR 0042.
+*/
+/** What a slide is drawn at when the caller says nothing. PowerPoint's own. */
+const DEFAULT_WIDTH = 1920;
+const RENDER_DEFAULTS = {
+	width: DEFAULT_WIDTH,
+	systemFonts: true,
+	text: true
+};
+/** The media resolver: an rId means the rels of the part the fill was written in. */
+function mediaFrom(store) {
+	return (embed, part) => {
+		const target = store.relationships(part).targetOf(embed);
+		if (target === void 0) return void 0;
+		const contentType = store.contentTypeOf(target);
+		if (contentType === void 0) return void 0;
+		return {
+			bytes: store.read(target),
+			contentType
+		};
+	};
+}
+/**
+* Render a deck that is already in memory.
+*
+* Separate from `runRender` so that the whole pipeline is exercised by the test
+* suite without a file system, a process or a captured stdout.
+*/
+function renderDeck(bytes, options) {
+	const store = PartStore.open(bytes);
+	const document = loadDocument(store);
+	const size = document.slideSize;
+	const height = Math.round(options.width * size.cy / size.cx);
+	if (options.slide !== null) {
+		const count = document.slides.length;
+		if (!Number.isInteger(options.slide) || options.slide < 1 || options.slide > count) throw new RenderError("CLI_NO_SLIDE", `--slide ${String(options.slide)}: the deck has ${String(count)} slide(s)`, String(options.slide));
+	}
+	let library = null;
+	const fonts = options.text ? createFontMeasurer(library = indexFonts({
+		extra: options.fontDirs,
+		system: options.systemFonts
+	})) : null;
+	const media = mediaFrom(store);
+	return {
+		slides: (options.slide === null ? document.slides.map((sheet, at) => ({
+			sheet,
+			number: at + 1
+		})) : [{
+			sheet: document.slides[options.slide - 1],
+			number: options.slide
+		}]).map(({ sheet, number }) => ({
+			number,
+			svg: renderSlide(sheet, size, {
+				width: options.width,
+				height,
+				idPrefix: `s${String(number)}`,
+				media,
+				text: fonts === null ? false : {
+					defaultTextStyle: document.defaultTextStyle,
+					measurer: fonts.measurer,
+					faceBox: fonts.faceBox
+				}
+			})
+		})),
+		width: options.width,
+		height,
+		fonts: fonts?.used() ?? [],
+		missing: fonts?.missing() ?? [],
+		fontDirectories: library?.directories ?? [],
+		facesIndexed: library?.indexed.length ?? 0
+	};
+}
+/** `slide-03.svg`, so a directory listing sorts the way the deck reads. */
+function fileNameFor(number, count) {
+	const width = Math.max(2, String(count).length);
+	return `slide-${String(number).padStart(width, "0")}.svg`;
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Where each slide's markup goes.
+*
+* One slide to a path that is not an existing directory writes that file;
+* anything else writes a file per slide into a directory, created if needed.
+* A path ending in `.svg` with more than one slide is a mistake worth naming
+* rather than silently turning into a directory.
+*/
+function write(result, out) {
+	if (result.slides.length === 1 && !isDirectory(out)) {
+		const first = result.slides[0];
+		mkdirSync(dirname(out), { recursive: true });
+		writeFileSync(out, first.svg, "utf8");
+		return [out];
+	}
+	if (out.toLowerCase().endsWith(".svg")) throw new RenderError("CLI_OUTPUT_PATH", `--out ${out} names one file but ${String(result.slides.length)} slides were rendered; name a directory, or pass --slide`, out);
+	mkdirSync(out, { recursive: true });
+	return result.slides.map((slide) => {
+		const path = join(out, fileNameFor(slide.number, result.slides.length));
+		writeFileSync(path, slide.svg, "utf8");
+		return path;
+	});
+}
+function report(result, written, options) {
+	const lines = [];
+	const slides = `${String(result.slides.length)} slide(s) at ${String(result.width)}x${String(result.height)}`;
+	lines.push(written.length === 0 ? slides : `${slides} -> ${written.length === 1 ? written[0] : `${String(written.length)} files`}`);
+	if (options.text) {
+		const substituted = result.fonts.filter((font) => font.substituted);
+		lines.push(`${String(result.fonts.length)} typeface(s) from ${String(result.facesIndexed)} indexed face(s)` + (substituted.length === 0 ? "" : `, ${String(substituted.length)} substituted`));
+		for (const font of substituted) lines.push(`  ${font.asked} -> ${font.drawn}`);
+		if (result.missing.length > 0) {
+			const shown = result.missing.slice(0, 8).map((code) => `U+${code.toString(16).toUpperCase().padStart(4, "0")}`);
+			lines.push(`  no face has ${String(result.missing.length)} code point(s): ${shown.join(" ")}` + (result.missing.length > shown.length ? " ..." : ""));
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}
+/** Read, render, write, and return an exit code. Never calls `process.exit`. */
+function runRender(file, options, out) {
+	const result = renderDeck(new Uint8Array(readFileSync(file)), options);
+	if (options.json) {
+		const written = options.out === null ? [] : write(result, options.out);
+		out(`${JSON.stringify({
+			slides: result.slides.map((slide) => ({
+				number: slide.number,
+				bytes: slide.svg.length
+			})),
+			width: result.width,
+			height: result.height,
+			fonts: result.fonts,
+			missing: result.missing.map((code) => `U+${code.toString(16).toUpperCase()}`),
+			fontDirectories: result.fontDirectories,
+			facesIndexed: result.facesIndexed,
+			written
+		}, null, 2)}\n`);
+		return 0;
+	}
+	if (options.out === null) {
+		for (const slide of result.slides) out(slide.svg);
+		return 0;
+	}
+	const written = write(result, options.out);
+	if (!options.quiet) out(report(result, written, options));
+	return 0;
+}
+//#endregion
+//#region src/roundtrip.ts
+const ROUNDTRIP_DEFAULTS = {
+	json: false,
+	quiet: false,
+	out: null,
+	write: null
+};
+function describeDifference(difference) {
+	const body = difference.detail.split("\n").map((line) => "    " + line.trimEnd()).join("\n");
+	return "  " + difference.kind.padEnd(13) + difference.part + "\n" + body;
+}
+/**
+* Render a comparison.
+*
+* Exported so that the branch that lists differences can be tested, which it
+* otherwise could not be: no deck in the corpus makes this writer produce one,
+* which is the point of the whole phase and leaves the most important output in
+* the file as the only output nothing exercises.
+*/
+function formatRoundTrip(path, stats, comparison, quiet) {
+	const lines = [];
+	if (!quiet) lines.push("roundtrip " + path, "", "  read      " + String(stats.bytesIn) + " bytes, " + String(stats.entriesIn) + " entries", "  written   " + String(stats.bytesOut) + " bytes, " + String(stats.entriesOut) + " entries", "  export    " + String(stats.rewritten) + " part(s) re-serialized, " + String(stats.streamed) + " streamed", "  compared  " + summarizeRoundTrip(comparison), "");
+	if (comparison.ok) lines.push("  no differences");
+	else {
+		lines.push("  " + String(comparison.differences.length) + " difference(s)", "");
+		for (const difference of comparison.differences) lines.push(describeDifference(difference), "");
+	}
+	if (!quiet && comparison.relabelled.length > 0) lines.push("", "  " + String(comparison.relabelled.length) + " relationship id(s) renamed:", ...comparison.relabelled.slice(0, 10).map((entry) => "    " + entry.source + "  " + entry.from + " -> " + entry.to));
+	return lines.join("\n") + "\n";
+}
+function roundTripFile(path, options = ROUNDTRIP_DEFAULTS) {
+	const original = new Uint8Array(readFileSync(path));
+	const result = roundTripPackage(original);
+	const { comparison } = result;
+	const stats = {
+		bytesIn: original.length,
+		bytesOut: result.exported.bytes.length,
+		entriesIn: readZip(original).entries.length,
+		entriesOut: readZip(result.exported.bytes).entries.length,
+		rewritten: result.exported.rewritten.length,
+		streamed: result.exported.streamed
+	};
+	return {
+		comparison,
+		output: options.json ? JSON.stringify({
+			file: path,
+			ok: comparison.ok,
+			bytesIn: stats.bytesIn,
+			bytesOut: stats.bytesOut,
+			rewritten: result.exported.rewritten,
+			counts: comparison.counts,
+			relabelled: comparison.relabelled,
+			differences: comparison.differences,
+			parts: comparison.parts
+		}, null, 2) + "\n" : formatRoundTrip(path, stats, comparison, options.quiet),
+		bytes: result.exported.bytes,
+		exitCode: comparison.ok ? 0 : 1
+	};
+}
+/** Run `roundTripFile` and put the results where the options say. */
+function runRoundTrip(path, options, write) {
+	const result = roundTripFile(path, options);
+	if (options.write !== null) writeFileSync(options.write, result.bytes);
+	if (options.out === null) write(result.output);
+	else writeFileSync(options.out, result.output);
+	return result.exitCode;
+}
+//#endregion
+//#region src/validate.ts
+const VALIDATE_DEFAULTS = {
+	json: false,
+	explain: false,
+	quiet: false,
+	out: null
+};
+function validateFile(path, options = VALIDATE_DEFAULTS) {
+	const bytes = new Uint8Array(readFileSync(path));
+	const report = validatePackage({ bytes });
+	return {
+		report,
+		output: options.json ? JSON.stringify(report, null, 2) + "\n" : formatReport(report, {
+			explain: options.explain,
+			warnings: !options.quiet
+		}) + "\n",
+		exitCode: report.findings.filter((finding) => finding.severity === "fatal").length > 0 ? 1 : 0
+	};
+}
+/** Run `validateFile` and put the result where the options say. */
+function runValidate(path, options, write) {
+	const result = validateFile(path, options);
+	if (options.out === null) write(result.output);
+	else writeFileSync(options.out, result.output);
+	return result.exitCode;
+}
+//#endregion
+//#region src/main.ts
+const PLANNED = [{
+	name: "resolve",
+	summary: "show where a resolved property came from",
+	phase: "7.x"
+}];
+function version() {
+	const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+	return typeof manifest === "object" && manifest !== null && "version" in manifest ? String(manifest.version) : "0.0.0";
+}
+function usage() {
+	const planned = PLANNED.map((verb) => "  " + verb.name.padEnd(12) + verb.summary + "  (sub-phase " + verb.phase + ")").join("\n");
+	return [
+		"pptx-studio " + version(),
+		"",
+		"Usage: pptx-studio <command> <deck.pptx> [options]",
+		"",
+		"Commands:",
+		"  inspect          what is inside a package: parts, relationships, features",
+		"  validate         the must-not-break rules, with the part and the XPath",
+		"  roundtrip        read a deck, write it back, and prove nothing moved",
+		"  render           draw slides as SVG, with no browser and no LibreOffice",
+		"  bisect           narrow a broken deck to the change that breaks it",
+		"",
+		"render options:",
+		"  --slide <n>      one slide, 1-based; every slide by default",
+		"  --width <px>     the SVG width attribute; the height follows the aspect",
+		"  --out <path>     a directory, or a file when rendering one slide",
+		"  --font-dir <d>   look for fonts here first; repeatable",
+		"  --no-system-fonts   do not look in this platform own font directories",
+		"  --no-text        draw geometry only, and ask no font questions",
+		"  --json           what was drawn, and which face drew each typeface",
+		"  --quiet          no summary after writing",
+		"",
+		"  With no --out the markup goes to stdout, which is one slide worth doing.",
+		"",
+		"inspect options:",
+		"  --json           the census as JSON, for a script or for committing as a fixture",
+		"  --parts          include the per-part table",
+		"  --namespaces     include the namespace histogram",
+		"  --top <n>        rows per histogram before truncating (default 15)",
+		"  --out <file>     write to a file instead of stdout",
+		"",
+		"validate options:",
+		"  --json           the report as JSON",
+		"  --explain        append the rationale for every rule that fired",
+		"  --quiet          fatal findings only",
+		"  --out <file>     write to a file instead of stdout",
+		"",
+		"roundtrip options:",
+		"  --json           the comparison as JSON, with a digest per part",
+		"  --quiet          the differences only, without the tally",
+		"  --write <file>   also save the package that was written, to open in PowerPoint",
+		"  --out <file>     write the report to a file instead of stdout",
+		"",
+		"bisect <deck.pptx> [broken.pptx]",
+		"  With one deck the broken package is our own export of it; with two they",
+		"  are the original and the broken package, in that order.",
+		"",
+		"  --oracle <name>  validate (default), powerpoint, or command",
+		"  --command <cmd>  for --oracle command; {} becomes the candidate path",
+		"  --max-runs <n>   ceiling on oracle runs (default 2000)",
+		"  --timeout <ms>   per run, for the oracles that spawn something",
+		"  --progress       a line per oracle run; a bisection is not quick",
+		"  --write <file>   save the smallest package that still fails",
+		"  --json           the result as JSON",
+		"  --quiet          the changes that matter, without the tally",
+		"  --out <file>     write the report to a file instead of stdout",
+		"",
+		"  -h, --help       this text",
+		"  -v, --version    print the version",
+		"",
+		"Exit status is 1 when inspect finds a structural error, when validate finds",
+		"anything fatal, when roundtrip finds a difference, when render cannot draw,",
+		"or when bisect localizes one. 0 otherwise. Warnings and notes never fail a",
+		"command.",
+		"",
+		"Not built yet:",
+		planned,
+		""
+	].join("\n");
+}
+const CONSOLE_STREAMS = {
+	out: (text) => process.stdout.write(text),
+	err: (text) => process.stderr.write(text)
+};
+/** Parse, dispatch, and return an exit code. Never calls `process.exit`. */
+function main(argv, streams = CONSOLE_STREAMS) {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: [...argv],
+			allowPositionals: true,
+			allowNegative: true,
+			options: {
+				json: {
+					type: "boolean",
+					default: false
+				},
+				explain: {
+					type: "boolean",
+					default: false
+				},
+				quiet: {
+					type: "boolean",
+					default: false
+				},
+				parts: {
+					type: "boolean",
+					default: false
+				},
+				namespaces: {
+					type: "boolean",
+					default: false
+				},
+				top: { type: "string" },
+				out: { type: "string" },
+				write: { type: "string" },
+				oracle: { type: "string" },
+				slide: { type: "string" },
+				width: { type: "string" },
+				"font-dir": {
+					type: "string",
+					multiple: true
+				},
+				"system-fonts": {
+					type: "boolean",
+					default: true
+				},
+				text: {
+					type: "boolean",
+					default: true
+				},
+				command: { type: "string" },
+				"max-runs": { type: "string" },
+				timeout: { type: "string" },
+				progress: {
+					type: "boolean",
+					default: false
+				},
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				},
+				version: {
+					type: "boolean",
+					short: "v",
+					default: false
+				}
+			}
+		});
+	} catch (error) {
+		streams.err(describe(error) + "\n\n" + usage());
+		return 2;
+	}
+	const { values, positionals } = parsed;
+	if (values.version === true) {
+		streams.out(version() + "\n");
+		return 0;
+	}
+	const command = positionals[0];
+	if (values.help === true || command === void 0) {
+		streams.out(usage());
+		return command === void 0 && values.help !== true ? 2 : 0;
+	}
+	const planned = PLANNED.find((verb) => verb.name === command);
+	if (planned !== void 0) {
+		streams.err("pptx-studio " + command + " is not built yet: it arrives with sub-phase " + planned.phase + ".\n  " + planned.summary + "\n");
+		return 2;
+	}
+	if (command !== "inspect" && command !== "validate" && command !== "roundtrip" && command !== "render" && command !== "bisect") {
+		streams.err("unknown command: " + command + "\n\n" + usage());
+		return 2;
+	}
+	const file = positionals[1];
+	if (file === void 0) {
+		streams.err(command + " needs a path to a .pptx\n\n" + usage());
+		return 2;
+	}
+	if (command === "bisect") {
+		const oracle = values.oracle ?? BISECT_DEFAULTS.oracle;
+		if (oracle !== "validate" && oracle !== "powerpoint" && oracle !== "command") {
+			streams.err("--oracle wants validate, powerpoint or command, got " + oracle + "\n");
+			return 2;
+		}
+		if (oracle === "command" && values.command === void 0) {
+			streams.err("--oracle command needs --command \"<what to run>\"\n");
+			return 2;
+		}
+		const maxRuns = positiveInteger(values["max-runs"], BISECT_DEFAULTS.maxRuns);
+		const timeout = positiveInteger(values.timeout, BISECT_DEFAULTS.timeout);
+		if (maxRuns === null || timeout === null) {
+			streams.err("--max-runs and --timeout want positive integers\n");
+			return 2;
+		}
+		const options = {
+			oracle,
+			command: values.command ?? null,
+			maxRuns,
+			timeout,
+			write: values.write ?? null,
+			json: values.json === true,
+			quiet: values.quiet === true,
+			out: values.out ?? null,
+			progress: values.progress === true
+		};
+		try {
+			return runBisect(file, positionals[2] ?? null, options, streams.out);
+		} catch (error) {
+			if (isValidateError(error)) streams.err("pptx-studio: the export was refused, so there was no broken package to compare.\n  " + error.message + "\n");
+			else if (isOpcError(error)) streams.err("pptx-studio: " + error.code + ": " + error.message + "\n");
+			else streams.err("pptx-studio: " + describe(error) + "\n");
+			return 1;
+		}
+	}
+	if (command === "render") {
+		const slide = values.slide === void 0 ? null : Number.parseInt(values.slide, 10);
+		if (slide !== null && (!Number.isFinite(slide) || slide < 1)) {
+			streams.err("--slide wants a positive integer, got " + String(values.slide) + "\n");
+			return 2;
+		}
+		const width = positiveInteger(values.width, RENDER_DEFAULTS.width);
+		if (width === null) {
+			streams.err("--width wants a positive integer, got " + String(values.width) + "\n");
+			return 2;
+		}
+		const options = {
+			slide,
+			width,
+			out: values.out ?? null,
+			fontDirs: values["font-dir"] ?? [],
+			systemFonts: values["system-fonts"] !== false,
+			text: values.text !== false,
+			json: values.json === true,
+			quiet: values.quiet === true
+		};
+		try {
+			return runRender(file, options, streams.out);
+		} catch (error) {
+			if (isRenderError(error)) streams.err("pptx-studio: " + error.code + ": " + error.message + "\n");
+			else if (isOpcError(error)) streams.err("pptx-studio: " + error.code + ": " + error.message + "\n");
+			else streams.err("pptx-studio: " + describe(error) + "\n");
+			return 1;
+		}
+	}
+	if (command === "roundtrip") {
+		const options = {
+			json: values.json === true,
+			quiet: values.quiet === true,
+			out: values.out ?? null,
+			write: values.write ?? null
+		};
+		try {
+			return runRoundTrip(file, options, streams.out);
+		} catch (error) {
+			if (isValidateError(error)) streams.err("pptx-studio: the export was refused, so there was nothing to compare.\n  " + error.message + "\n");
+			else if (isOpcError(error)) streams.err("pptx-studio: " + error.code + ": " + error.message + "\n");
+			else streams.err("pptx-studio: " + describe(error) + "\n");
+			return 1;
+		}
+	}
+	if (command === "validate") {
+		const options = {
+			json: values.json === true,
+			explain: values.explain === true,
+			quiet: values.quiet === true,
+			out: values.out ?? null
+		};
+		try {
+			return runValidate(file, options, streams.out);
+		} catch (error) {
+			if (isOpcError(error)) {
+				streams.err("pptx-studio: " + error.code + ": " + error.message + "\n");
+				return 1;
+			}
+			streams.err("pptx-studio: " + describe(error) + "\n");
+			return 1;
+		}
+	}
+	const top = values.top === void 0 ? INSPECT_DEFAULTS.top : Number.parseInt(values.top, 10);
+	if (!Number.isFinite(top) || top < 1) {
+		streams.err("--top wants a positive integer, got " + String(values.top) + "\n");
+		return 2;
+	}
+	const options = {
+		json: values.json === true,
+		parts: values.parts === true,
+		namespaces: values.namespaces === true,
+		top,
+		out: values.out ?? null
+	};
+	try {
+		return runInspect(file, options, streams.out);
+	} catch (error) {
+		if (isOpcError(error)) {
+			streams.err("pptx-studio: " + error.code + ": " + error.message + "\n");
+			return 1;
+		}
+		streams.err("pptx-studio: " + describe(error) + "\n");
+		return 1;
+	}
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** A numeric flag, or null when what was given is not one. */
+function positiveInteger(value, fallback) {
+	if (value === void 0) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+//#endregion
+export { runRender as a, systemFontDirectories as c, RenderError as d, isRenderError as f, runInspect as h, renderDeck as i, facesIn as l, inspectFile as m, DEFAULT_WIDTH as n, createFontMeasurer as o, INSPECT_DEFAULTS as p, RENDER_DEFAULTS as r, indexFonts as s, main as t, RENDER_ERROR_CODES as u };
+
+//# sourceMappingURL=main-DLx2onii.js.map