pptx-ts 0.0.1

package/dist/script.js

@@ -0,0 +1,3741 @@
+import { s as PERCENT_SCALE } from "./units-1kRzYShk.js";
+import { a as TsPptxError, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, t as InternalError } from "./errors-Bvln0H-7.js";
+import { O as DEFAULT_COLOR_MAP, t as OOXML_NS } from "./namespaces-BVnNu7sg.js";
+import { a as isConnector, c as isPicture, i as isAutoShape, o as isGraphicFrame, s as isGroupShape } from "./shapes-BemroU-z.js";
+//#region src/script/fidelity.ts
+/**
+* Accumulates notes while a deck is walked, so the walk itself stays a plain
+* read-model → IR mapping and does not thread a growing array through every function.
+*
+* Deduplicates on the full note identity. Without that, a construct that is lost on every
+* run of a 400-run text body would produce 400 identical notes and bury the one-off losses
+* that actually need reading.
+*/
+var NoteCollector = class {
+	#seen = /* @__PURE__ */ new Set();
+	#notes = [];
+	/** Record a loss. A repeat of an identical note is ignored. */
+	add(note) {
+		const key = `${note.slideNumber}\0${note.shapeName}\0${note.construct}\0${note.disposition}\0${note.cause}\0${note.detail}`;
+		if (this.#seen.has(key)) return;
+		this.#seen.add(key);
+		this.#notes.push(note);
+	}
+	/**
+	* The notes, in the order first recorded — which is deck order, since the walk is
+	* ordered, so a reader meets them the way they meet the slides.
+	*/
+	get notes() {
+		return this.#notes;
+	}
+};
+/**
+* Namespace for a loss recorded against a shape on a **slide layout** rather than on a slide,
+* prepended to the construct by {@link layoutShapeScope}.
+*
+* The chrome mapper reuses the slide shape mapper wholesale — a rectangle on a layout is
+* transcribed by the same code that transcribes one on a slide, which is what keeps the two
+* from drifting. That sharing brings the slide vocabulary with it: a themed outline on a
+* layout records `line.width` exactly as a slide's would. Left unmarked, those notes would be
+* wrong twice over. A template-anchored script would report them, though it never rebuilds a
+* layout and loses nothing; and the round trip would let one excuse a *slide* difference,
+* because a layout note carries no slide number and a name like "Rectangle 7" repeats between
+* the tiers. The prefix keeps the shared vocabulary and states which tier it is about.
+*
+* `layout.` rather than `master.`, which is how the other chrome constructs are spelled: those
+* are named after the `defineSlideMaster` call that authors them, while these name the source
+* tier the loss is on — and a master's own decoration is not re-authored at all, so a note
+* under this prefix is always about a layout.
+*/
+const LAYOUT_NOTE_PREFIX = "layout.";
+/** Bind a collector to a slide (and optionally a shape). */
+function scopeNotes(collector, slideNumber, shapeName = null) {
+	return {
+		note(construct, disposition, cause, detail) {
+			collector.add({
+				slideNumber,
+				shapeName,
+				construct,
+				disposition,
+				cause,
+				detail
+			});
+		},
+		forShape(name) {
+			return scopeNotes(collector, slideNumber, name);
+		}
+	};
+}
+/**
+* Wrap a scope so every construct recorded through it is namespaced under
+* {@link LAYOUT_NOTE_PREFIX} — see there for why.
+*
+* Constructs written at a call site inside the layout walk are therefore *relative*: the
+* decoration mapper records `decoration`, and what lands in the note list is
+* `layout.decoration`. The wrapper survives `forShape`, since a layout loss is scoped to a
+* shape name the same way a slide loss is.
+*/
+function layoutShapeScope(notes) {
+	return {
+		note(construct, disposition, cause, detail) {
+			notes.note(`${LAYOUT_NOTE_PREFIX}${construct}`, disposition, cause, detail);
+		},
+		forShape(name) {
+			return layoutShapeScope(notes.forShape(name));
+		}
+	};
+}
+//#endregion
+//#region src/script/ir.ts
+/** `true` when `value` is an {@link AssetRef} rather than a plain IR object. */
+function isAssetRef(value) {
+	return typeof value === "object" && value !== null && typeof value.$asset === "string";
+}
+/**
+* Widen one of the typed IR records below to {@link IrValue}, for the printer and the
+* canonicaliser, which walk the IR generically.
+*
+* A cast, and unavoidably so. An optional key on an interface types as `T | undefined`,
+* while `IrValue` deliberately excludes `undefined` so that "absent" has exactly one
+* spelling — which makes the two mutually unassignable even though every value a mapper
+* actually produces satisfies both. The invariant that closes the gap is enforced at the
+* source (`compact` and the conditional spreads in `from-read/`, pinned by the "no value is
+* `undefined`" corpus test) rather than by the type system, so it is stated once here
+* instead of re-argued at each call site.
+*/
+function asIrValue(value) {
+	return value;
+}
+//#endregion
+//#region src/script/from-read/values.ts
+/** EMU per inch (ECMA-376 §20.1.2.1). */
+const EMU_PER_INCH = 914400;
+/**
+* Decimal places used for the inch-typed options. See the module header: this is the
+* proven minimum for an EMU-exact round-trip, not a formatting preference.
+*/
+const INCH_DECIMALS = 6;
+/** Geometry as a `Coord` the write API takes verbatim, preserving the exact EMU. */
+function emu(value) {
+	return `${Math.round(value)}emu`;
+}
+/**
+* Geometry as inches, for the three options that reject a raw-EMU string. Rounded to
+* {@link INCH_DECIMALS}, which is EMU-exact on the way back.
+*/
+function inches(emuValue) {
+	return Number((emuValue / EMU_PER_INCH).toFixed(INCH_DECIMALS));
+}
+/**
+* Points → inches, at the same proven precision as {@link inches}. Needed because the read
+* model reports text-body insets in points while the write API's `margin` takes inches —
+* and warns on a value `>= 1`, on the assumption that it is a points value passed by
+* mistake, so handing it points would both mis-scale the text and produce a warning.
+*/
+function pointsToInches(pt) {
+	return Number((pt / 72).toFixed(INCH_DECIMALS));
+}
+/**
+* A colour for a write-API `color` field. The read model splits a colour into a raw
+* `schemeClr` token and a resolved literal hex; this prefers the token, because a token
+* re-resolves against the destination theme and so keeps the deck recolourable, which is
+* the whole reason a theme colour was authored.
+*
+* Only the ten tokens the write path's `clrMap` covers survive as tokens — the other
+* seven `ST_SchemeColorVal` values degrade to a hex literal there anyway, so passing them
+* through would produce a silently different colour. Callers hand those to
+* {@link literalColor} instead after recording a note.
+*/
+const WRITABLE_SCHEME_TOKENS = /* @__PURE__ */ new Set([
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"bg1",
+	"bg2",
+	"tx1",
+	"tx2"
+]);
+/** `true` when a `schemeClr` token survives as a token rather than degrading to hex. */
+function isWritableSchemeToken(token) {
+	return token !== null && WRITABLE_SCHEME_TOKENS.has(token);
+}
+/** Normalize a hex to the bare 6-digit uppercase form the write API expects. */
+function literalColor(hex) {
+	return hex.replace(/^#/, "").toUpperCase();
+}
+/**
+* Build an IR object from possibly-absent parts, dropping every `undefined`.
+*
+* Every mapper funnels through this. An IR must spell "absent" exactly one way — a
+* missing key — or two IRs describing the same deck compare unequal because one wrote
+* `{ bold: undefined }` and the other wrote `{}`. That would surface as phantom
+* round-trip failures, so the invariant is enforced in one place rather than trusted to
+* every call site.
+*
+* Returns `undefined` when nothing survived, so a caller can drop the whole option object
+* rather than emit an empty one.
+*/
+function compact(source) {
+	const out = {};
+	let any = false;
+	for (const key of Object.keys(source).sort()) {
+		const value = source[key];
+		if (value === void 0) continue;
+		out[key] = value;
+		any = true;
+	}
+	return any ? out : void 0;
+}
+/** {@link compact}, but always an object — for a required options argument. */
+function compactRequired(source) {
+	return compact(source) ?? {};
+}
+/** Drop a value that is `null`, so the read model's "unset" becomes an absent IR key. */
+function orUndefined(value) {
+	return value === null ? void 0 : value;
+}
+/**
+* A 0–1 opacity as the write API's 0–100 transparency; `undefined` when unset.
+*
+* Fully opaque is *not* `0` here — a caller that means "no transparency at all" passes
+* `undefined`, because emitting `transparency: 0` for an `a:alphaModFix amt="100000"`
+* would produce a key the output cannot have: the write path emits no `a:alphaModFix` for
+* a zero transparency, so the re-read deck reports no alpha and the round trip sees a
+* difference where there is no visible one.
+*/
+function alphaToTransparency(alpha) {
+	if (alpha === void 0 || alpha === null) return void 0;
+	return Math.round((1 - alpha) * 100);
+}
+/**
+* A graphic frame's position as write-API options. Identical to a shape's, minus rotation and
+* flip: a `p:graphicFrame` has neither, so `a:xfrm` carries only the offset and extent.
+*/
+function positionOfFrame(frame) {
+	const box = frame.absoluteFrame;
+	if (!box) return {};
+	return {
+		x: emu(box.left),
+		y: emu(box.top),
+		w: emu(box.width),
+		h: emu(box.height)
+	};
+}
+//#endregion
+//#region src/script/from-read/surface-fill.ts
+/**
+* A read gradient as `GradientFillProps`. Stop positions convert from the read model's
+* 0–1 fraction to the write API's 0–100 percentage; the angle needs no conversion, since
+* both sides use OOXML degrees (clockwise from 3 o'clock).
+*/
+function gradientStops(gradient, notes, where) {
+	const stops = gradient.stops.map((stop) => {
+		const color = isWritableSchemeToken(stop.schemeColor) ? stop.schemeColor : stop.effectiveHex === null ? null : literalColor(stop.effectiveHex);
+		if (color === null) return null;
+		return compact({
+			color,
+			position: Math.round((stop.position ?? 0) * 100),
+			transparency: alphaToTransparency(stop.alpha)
+		});
+	}).filter((stop) => stop !== null);
+	if (stops.length < 2) {
+		notes.note(`${where}.gradient`, "dropped", "unsupported", "a gradient with fewer than two resolvable stops cannot be expressed, so this falls back to no gradient");
+		return;
+	}
+	if (gradient.kind === "path") {
+		if (gradient.path !== null && gradient.path !== "circle") notes.note(`${where}.gradient.path`, "approximated", "unwritable", `a "${gradient.path}" path gradient is emitted as a radial one; the write API models no other path shape`);
+		return {
+			kind: "radial",
+			stops
+		};
+	}
+	return compact({
+		kind: "linear",
+		angle: gradient.angleDeg ?? 0,
+		stops
+	});
+}
+/**
+* A read hatch as `ShapeFillProps` with `type: 'pattern'`, or `undefined` when the pattern
+* names no preset — `a:pattFill/@prst` is what selects the hatch, so without it there is
+* nothing to reproduce.
+*
+* Both colours are emitted as literals rather than scheme tokens: `PatternFillProps` types
+* `fgColor`/`bgColor` as hex, so a token would not survive the write side anyway.
+*/
+function patternOption(pattern) {
+	if (!pattern?.preset) return void 0;
+	return {
+		type: "pattern",
+		pattern: compact({
+			preset: pattern.preset,
+			fgColor: pattern.foreground ? literalColor(pattern.foreground.effectiveHex) : void 0,
+			bgColor: pattern.background ? literalColor(pattern.background.effectiveHex) : void 0
+		}) ?? { preset: pattern.preset }
+	};
+}
+//#endregion
+//#region src/script/from-read/picture-fill.ts
+/**
+* A picture fill as `ShapeFillProps`, or `undefined` when its bytes cannot be carried —
+* in which case a `dropped` note has been recorded and the surface comes out unfilled.
+*/
+function pictureFillOption(picture, assets, notes, subject) {
+	const asset = pictureAsset(picture, assets, notes, subject);
+	if (!asset) return void 0;
+	noteUncarriedGeometry(picture, notes, subject);
+	return compactRequired({
+		type: "image",
+		image: { data: asset },
+		transparency: picture.alpha === 1 ? void 0 : alphaToTransparency(picture.alpha)
+	});
+}
+/** The fill's image as an asset, or `null` with a note saying why it could not be one. */
+function pictureAsset(picture, assets, notes, subject) {
+	const partName = picture.partName;
+	if (partName === null) {
+		notes.note(subject.construct, "dropped", "unsupported", `${subject.subject} is filled with an image (${subject.element}) that embeds no image part — an external or linked blip — so there are no bytes to carry and it comes out unfilled`);
+		return null;
+	}
+	if (assets.contentTypeOf(partName) === "image/svg+xml") {
+		notes.note(subject.construct, "dropped", "unwritable", `${subject.subject} is filled with an SVG image (${subject.element} → ${partName}); a picture fill accepts raster bytes only on the write side, so it comes out unfilled`);
+		return null;
+	}
+	const asset = assets.assetFor(partName);
+	if (!asset) {
+		notes.note(subject.construct, "dropped", "unsupported", `the image filling ${subject.subject} (${subject.element} → ${partName}) is not present in the package, so there are no bytes to carry`);
+		return null;
+	}
+	return asset;
+}
+/** `true` when a rect actually insets an edge; an explicit but empty rect reports zeros. */
+function isRectSet(rect) {
+	return rect !== null && (rect.left !== 0 || rect.top !== 0 || rect.right !== 0 || rect.bottom !== 0);
+}
+/**
+* Note the parts of the fill's geometry the write path's fixed stretch cannot express.
+*
+* Only the ones the source actually uses: a note on every picture fill would say nothing,
+* and the round-trip check reads an unmatched note as a candidate for review.
+*/
+function noteUncarriedGeometry(picture, notes, subject) {
+	const lost = [];
+	if (picture.mode === "tile" || picture.tile !== null) lost.push("tiling (a:tile)");
+	if (isRectSet(picture.srcRect)) lost.push("the source crop (a:srcRect)");
+	if (isRectSet(picture.fillRect)) lost.push("the destination inset (a:stretch/a:fillRect)");
+	if (picture.dpi !== null && picture.dpi !== 0) lost.push(`the render resolution (@dpi="${picture.dpi}")`);
+	if (picture.rotWithShape === false) lost.push("not rotating with the shape (@rotWithShape=\"0\")");
+	if (lost.length === 0) return;
+	notes.note(`${subject.construct}.geometry`, "approximated", "unwritable", `the image filling ${subject.subject} is re-embedded, but the write path emits every picture fill as a plain stretched blip (dpi="0" rotWithShape="1", <a:srcRect/><a:stretch><a:fillRect/></a:stretch>), so ${lost.join(", ")} ${lost.length === 1 ? "does" : "do"} not carry`);
+}
+//#endregion
+//#region src/script/from-read/detect.ts
+/**
+* Presence checks for constructs the read model has no accessor for.
+*
+* These reach through the documented raw hatch (`element_`) rather than through a typed
+* accessor, which needs justifying. The rule they follow: **detect, never decode.** Each
+* function answers only "is this here?", so the answer can become a {@link FidelityNote}.
+* Nothing here interprets a value or feeds one into a call — that would be building a
+* private read path alongside the public one, and it would rot the moment the element's
+* meaning changed.
+*
+* The alternative is worse than the coupling. Without these checks, a deck with an embedded
+* video converts to a static poster image and a deck with an equation converts to an empty
+* box, both silently and both with a clean round-trip, because a diff cannot see what
+* neither side read. A loss you can name is a bug report; a loss nothing observes is a
+* defect that ships.
+*
+* Each check here is a standing argument for a real accessor. When one lands, the
+* corresponding function should be deleted, not kept in sync.
+*/
+/** Office MathML namespace — the equation body itself, wrapped by `a14:m` in a text run. */
+const MATH_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+/** Shape-tree children that carry drawing content, as opposed to the tree's own properties. */
+const SHAPE_ELEMENTS = /* @__PURE__ */ new Set([
+	"sp",
+	"pic",
+	"graphicFrame",
+	"grpSp",
+	"cxnSp"
+]);
+const ELEMENT_NODE = 1;
+function has(element, namespaceURI, localName) {
+	const el = element;
+	if (!el || typeof el.getElementsByTagNameNS !== "function") return false;
+	return el.getElementsByTagNameNS(namespaceURI, localName).length > 0;
+}
+/**
+* The first *direct* child with this name.
+*
+* A subtree search is wrong for structural lookups, in two ways that both bite here.
+* `a:ext` names two unrelated elements — a shape extent (`@cx`/`@cy`) and an extension-list
+* entry (`@uri`) — so a subtree search finds whichever comes first in document order. And on
+* a group it descends into the group's own children, so a nested group's transform answers
+* for its parent's.
+*/
+function child(element, namespaceURI, localName) {
+	if (!element) return null;
+	for (let node = element.firstChild; node; node = node.nextSibling) {
+		if (node.nodeType !== ELEMENT_NODE) continue;
+		const el = node;
+		if (el.namespaceURI === namespaceURI && el.localName === localName) return el;
+	}
+	return null;
+}
+/** Every direct element child, as {@link ElementLike}s. */
+function children(element) {
+	if (!element) return [];
+	const out = [];
+	for (let node = element.firstChild; node; node = node.nextSibling) if (node.nodeType === ELEMENT_NODE) out.push(node);
+	return out;
+}
+/**
+* `true` when this shape is an embedded audio or video rather than a still picture.
+*
+* PowerPoint authors media as a `p:pic` whose `p:nvPr` carries an `a:videoFile` or
+* `a:audioFile`, with the poster frame as the picture's own blip. The read model reports
+* only the poster — `mediaKind` distinguishes raster from SVG, not still from moving — so
+* without this check a video converts to a static image that looks deliberate.
+*/
+function isAudioVideo(element) {
+	return has(element, OOXML_NS.a, "videoFile") || has(element, OOXML_NS.a, "audioFile");
+}
+/**
+* `true` when this shape's text body contains an OMML equation.
+*
+* An equation lives in `m:oMath` inside an `a14:m` run, which contributes nothing to
+* `TextFrame.text`, so an equation-only shape reads as an empty text frame. The write API
+* *can* author one (`TextProps.math`, plus the `ts-pptx/math` subpath for LaTeX/MathML
+* input), which makes this a read-side gap rather than a hard limit.
+*/
+function hasEquation(element) {
+	return has(element, MATH_NS, "oMath");
+}
+/**
+* `true` when this `p:sp` is a text box rather than an auto shape.
+*
+* The discriminator is one attribute, `p:cNvSpPr/@txBox`, and nothing reads it. The
+* tempting substitute — "it has no preset geometry" — is wrong for the common case:
+* PowerPoint gives every text box an explicit `<a:prstGeom prst="rect"/>`, so that test
+* calls every real text box an auto shape. The difference is not cosmetic. PowerPoint
+* autofits, wraps and resizes a text box by different rules, and offers a different
+* right-click menu for it.
+*
+* Direct child rather than a subtree search: `p:cNvSpPr` sits under `p:nvSpPr`, and a group
+* would otherwise answer for its first child.
+*/
+function isTextBox(element) {
+	return child(child(element, OOXML_NS.p, "nvSpPr"), OOXML_NS.p, "cNvSpPr")?.getAttribute("txBox") === "1";
+}
+/**
+* `true` when a group's child coordinate space equals its own frame, so its children are
+* already in slide-absolute units.
+*
+* `addGroup` always emits an identity child space; a source group whose `a:chOff`/`a:chExt`
+* differ scales or shifts its contents, and that behaviour cannot be reproduced. The read
+* model has no accessor for the child space — `absoluteFrame` deliberately composes it away,
+* which is right for locating a shape and wrong for spotting this difference.
+*
+* A group with no explicit transform inherits an identity one, so a missing `a:xfrm` is
+* `true` rather than unknown.
+*/
+function hasIdentityChildSpace(element) {
+	const xfrm = child(child(element, OOXML_NS.p, "grpSpPr"), OOXML_NS.a, "xfrm");
+	if (!xfrm) return true;
+	const off = child(xfrm, OOXML_NS.a, "off");
+	const ext = child(xfrm, OOXML_NS.a, "ext");
+	const chOff = child(xfrm, OOXML_NS.a, "chOff");
+	const chExt = child(xfrm, OOXML_NS.a, "chExt");
+	if (!off || !ext || !chOff || !chExt) return true;
+	return off.getAttribute("x") === chOff.getAttribute("x") && off.getAttribute("y") === chOff.getAttribute("y") && ext.getAttribute("cx") === chExt.getAttribute("cx") && ext.getAttribute("cy") === chExt.getAttribute("cy");
+}
+/**
+* `true` when this theme declares an `a:fmtScheme`.
+*
+* The format scheme holds the three fill, three line and three effect style lists a shape's
+* `p:style` indexes into. Neither half of the library touches it: nothing reads it, and the
+* write path emits a hardcoded Office one. So a deck whose theme carries a custom format
+* scheme is repainted with Office's, and this is the only way to notice.
+*/
+function hasFormatScheme(element) {
+	return has(element, OOXML_NS.a, "fmtScheme");
+}
+/**
+* `true` when this slide master declares per-level text styles (`p:txStyles`) with content.
+*
+* `SlideMasterProps.textStyles` can author them, so this is purely a read-side gap — the
+* default size, face, colour and bullet of every placeholder level is invisible to the
+* converter and comes back as PowerPoint's built-in default.
+*/
+function hasTextStyles(element) {
+	return children(child(element, OOXML_NS.p, "txStyles")).some((group) => children(group).length > 0);
+}
+/**
+* `true` when this shape is a placeholder — the tier that *reserves* a region for a slide to
+* fill, as opposed to the decoration that is drawn as-is.
+*
+* A DOM predicate rather than `shape.placeholder !== null`, and that is not an oversight: only
+* `AutoShape` reports a `p:ph` through the read model, so the model-based spelling would call
+* a *picture* placeholder (`p:nvPicPr/p:nvPr/p:ph`, which PowerPoint does author) decoration
+* and re-draw it as a fixed image on every slide bound to the layout.
+*
+* Not a direct-child lookup, unlike its neighbours: the `p:ph` sits two or three levels down
+* inside whichever `p:nv*Pr` the shape kind uses. That means a *group* containing a
+* placeholder answers `true` for its child, which is the wanted answer anyway — a group is
+* never itself a placeholder, and a layout that put one inside a group is one whose grouping
+* cannot survive being flattened into loose objects.
+*/
+function isPlaceholderShape(element) {
+	return has(element, OOXML_NS.p, "ph");
+}
+/**
+* `true` when this master or layout carries a shape that is not a placeholder — a logo, a
+* rule, a background image, a footer graphic.
+*
+* Only the **master** arm still needs this. A layout's decoration is now transcribed into its
+* `defineSlideMaster({ objects })` call, so what did not survive is reported per shape rather
+* than as a blanket count. A master's cannot be: `defineSlideMaster` authors a *layout* under
+* the one shared master, so a master's own shape tree has no write-side counterpart at all,
+* and a deck whose master carries none loses nothing — which is why this is a presence check
+* rather than an unconditional note.
+*/
+function hasDecorativeShapes(element) {
+	return children(child(child(element, OOXML_NS.p, "cSld"), OOXML_NS.p, "spTree")).some((shape) => shape.namespaceURI === OOXML_NS.p && SHAPE_ELEMENTS.has(shape.localName ?? "") && !isPlaceholderShape(shape));
+}
+//#endregion
+//#region src/script/from-read/text.ts
+/**
+* `a:pPr/@algn` → `HAlign`. `dist` and `thaiDist` (distributed justification) are
+* deliberately absent: the write API has no spelling for them, and mapping them onto
+* `justify` would be a silent visual change rather than a declared loss.
+*/
+const ALIGN = {
+	l: "left",
+	ctr: "center",
+	r: "right",
+	just: "justify"
+};
+/** `a:bodyPr/@anchor` → `VAlign`. */
+const ANCHOR$1 = {
+	t: "top",
+	ctr: "middle",
+	b: "bottom"
+};
+/** `AutofitMode` → the write API's `fit`. */
+const FIT = {
+	none: "none",
+	normAutofit: "shrink",
+	spAutoFit: "resize"
+};
+/** `a:bodyPr/@vert` values the write API's `vert` accepts (`TextVertType`). */
+const WRITABLE_VERT = /* @__PURE__ */ new Set([
+	"eaVert",
+	"horz",
+	"mongolianVert",
+	"vert",
+	"vert270",
+	"wordArtVert",
+	"wordArtVertRtl"
+]);
+/**
+* The `a:buAutoNum/@type` values the write API's `numberType` names.
+*
+* This used to be the *discriminator* between a numbered and a character bullet, back when
+* the read model reported both as one tagged string. `BulletDetail.kind` does that now, so
+* the set has one job left: telling a scheme the write path can spell from one it cannot.
+*/
+const AUTO_NUMBER_TYPES = /* @__PURE__ */ new Set([
+	"alphaLcParenBoth",
+	"alphaLcParenR",
+	"alphaLcPeriod",
+	"alphaUcParenBoth",
+	"alphaUcParenR",
+	"alphaUcPeriod",
+	"arabicParenBoth",
+	"arabicParenR",
+	"arabicPeriod",
+	"arabicPlain",
+	"romanLcParenBoth",
+	"romanLcParenR",
+	"romanLcPeriod",
+	"romanUcParenBoth",
+	"romanUcParenR",
+	"romanUcPeriod"
+]);
+/**
+* `Paragraph.bulletDetail` → the write API's `bullet` option.
+*
+* This function used to take a **tagged** string — `'none'`, `'char:<glyph>'` or
+* `'autoNum:<type>'` — and its first version read it as a bare glyph. The result was silent
+* and universal: a paragraph that explicitly suppressed its bullet (`a:buNone`, which is most
+* of them) came back with a literal `n` bullet, because `'none'.codePointAt(0)` is `n`; a real
+* character bullet came back as `c`, from the `char:` tag; and a numbered list came back as
+* `a`. Every converted deck was affected and nothing failed, which is why the round-trip check
+* exists — and why the accessor is now a discriminated union with no parsing left to get wrong.
+*/
+function bulletOption(bullet, notes) {
+	if (bullet.kind === "none") return false;
+	if (bullet.kind === "picture") {
+		notes.note("text.bullet.picture", "approximated", "unsupported", "this paragraph uses an image as its bullet glyph (a:buBlip); the text mapper has no asset resolver to re-embed it with, so the bullet falls back to the default character");
+		return true;
+	}
+	const style = bulletStyle(bullet, notes);
+	if (bullet.kind === "autoNum") {
+		if (!AUTO_NUMBER_TYPES.has(bullet.scheme)) {
+			notes.note("text.bullet.numberType", "approximated", "unwritable", `numbering scheme "${bullet.scheme}" is outside the set the write API names, so the list falls back to the default scheme`);
+			return compact({
+				type: "number",
+				...startAtOption(bullet.startAt),
+				...style
+			}) ?? { type: "number" };
+		}
+		return compact({
+			type: "number",
+			numberType: bullet.scheme,
+			...startAtOption(bullet.startAt),
+			...style
+		}) ?? { type: "number" };
+	}
+	const code = bullet.char.codePointAt(0) ?? 8226;
+	if (code > 65535) notes.note("text.bullet.glyph", "approximated", "unwritable", `bullet glyph U+${code.toString(16).toUpperCase()} is outside the Basic Multilingual Plane and characterCode takes a four-digit code, so the bullet falls back to the write path's default glyph`);
+	return compact({
+		characterCode: code.toString(16).toUpperCase().padStart(4, "0"),
+		...style
+	}) ?? {};
+}
+/**
+* `a:pPr/@marL` / `@indent` → `paraMarginLeft` / `paraIndent`.
+*
+* A stated margin carries as its number. An *absent* one is the interesting case, because
+* leaving the key out does not reproduce it: every `bullet` state except `'inherit'` makes the
+* write path put a margin on the element — its hanging default for a drawn bullet, zero for
+* `bullet: false` — so a paragraph that inherits its margin has to ask for silence explicitly.
+* Under `bullet: 'inherit'` nothing is written either way and the key would be noise, which is
+* why the bullet option decides rather than the paragraph being asked twice.
+* @param {number|null} valuePt - the paragraph's own margin in points, `null` when unset
+* @param {IrValue} bulletValue - the `bullet` option this paragraph maps onto
+* @return {IrValue|undefined} the option value, or `undefined` to leave the key out
+*/
+function paraMarginOption(valuePt, bulletValue) {
+	if (valuePt !== null) return valuePt;
+	return bulletValue === "inherit" ? void 0 : "inherit";
+}
+/**
+* `a:buAutoNum/@startAt` → `numberStartAt`.
+*
+* Numbering is content rather than styling: a list continuing "5. Deploy" that comes back as
+* "1. Deploy" is a different slide. `1` is the schema default, so emitting it would only add
+* noise to the printed script.
+*/
+function startAtOption(startAt) {
+	return startAt === null || startAt === 1 ? {} : { numberStartAt: startAt };
+}
+/**
+* The bullet's own font, size and colour (`a:buFont` / `a:buSzPct` / `a:buClr`) as the write
+* API's `fontFace` / `size` / `color`.
+*
+* `a:buSzPts` has no write-API counterpart — `bullet.size` is a percentage of the run size —
+* so an absolute bullet size is the one part of this that still cannot carry.
+*/
+function bulletStyle(bullet, notes) {
+	if (bullet.sizePt !== null) notes.note("text.bullet.sizePt", "dropped", "unwritable", "this bullet sets an absolute glyph size (a:buSzPts); bullet.size is a percentage of the run size, so the absolute value has no write-API expression and the glyph follows the text size");
+	const sizePct = bullet.sizePct;
+	if (sizePct !== null && (sizePct < 25 || sizePct > 400)) notes.note("text.bullet.sizePct", "approximated", "unwritable", `bullet glyph size ${sizePct}% is outside the 25–400% range the write API accepts, so no a:buSzPct is emitted and the glyph size is left to be inherited`);
+	return compact({
+		fontFace: orUndefined(bullet.font),
+		size: sizePct === null || sizePct < 25 || sizePct > 400 ? void 0 : sizePct,
+		color: bulletColor(bullet, notes)
+	}) ?? {};
+}
+/**
+* The bullet's colour, preferring the raw `schemeClr` token over the resolved literal for the
+* same reason {@link runColor} does: a token keeps tracking the destination theme.
+*/
+function bulletColor(bullet, notes) {
+	const scheme = bullet.schemeColor;
+	if (isWritableSchemeToken(scheme)) return scheme;
+	if (bullet.color !== null) return literalColor(bullet.color);
+	const resolved = bullet.resolvedColor;
+	if (!resolved) return void 0;
+	if (scheme !== null) notes.note("text.bullet.schemeToken", "approximated", "unwritable", `bullet scheme colour "${scheme}" is outside the ten tokens the write path maps, so it is baked to a literal hex and stops tracking the theme`);
+	return literalColor(resolved.effectiveHex);
+}
+/**
+* Per-run character formatting, shared by shape text and table-cell text.
+*
+* The three decoration tokens carry their **explicit off** — `u="none"`, `strike="noStrike"`,
+* `cap="none"` — rather than collapsing it into the unstated case. Stating one is a different
+* fact from stating nothing: run properties resolve down the `a:lstStyle` → placeholder →
+* layout → master chain, so a run that would take `u="sng"` from its list style and states
+* `u="none"` is *not* underlined, while the same run with the attribute dropped is. Only an
+* absent attribute (`null` here) means "state nothing"; each off token is a member of its
+* enumeration in its own right (ECMA-376 §20.1.10.81 / §20.1.10.78) and would be redundant
+* with omission otherwise.
+*/
+function runOptions(run, notes) {
+	const underline = run.underline;
+	return compact({
+		bold: orUndefined(run.bold),
+		italic: orUndefined(run.italic),
+		underline: underline === null ? void 0 : { style: underline },
+		strike: orUndefined(run.strike),
+		fontSize: orUndefined(run.fontSizePt),
+		fontFace: orUndefined(run.fontName),
+		color: runColor(run, notes),
+		highlight: run.highlight ? literalColor(run.highlight.effectiveHex) : void 0,
+		caps: orUndefined(run.caps),
+		baseline: orUndefined(run.baselinePct),
+		hyperlink: hyperlinkOption(run)
+	});
+}
+/**
+* A run's colour, preferring the raw `schemeClr` token over the resolved literal so the
+* text keeps tracking the destination theme. Only the ten tokens the write path's `clrMap`
+* covers survive as tokens; the other seven degrade to a literal hex there anyway, so
+* passing one through unchanged would produce a silently different colour.
+*/
+function runColor(run, notes) {
+	const scheme = run.schemeColor;
+	if (isWritableSchemeToken(scheme)) return scheme;
+	if (scheme !== null) {
+		notes.note("text.color.schemeToken", "approximated", "unwritable", `scheme colour "${scheme}" is outside the ten tokens the write path maps, so it is baked to a literal hex and stops tracking the theme`);
+		const resolved = run.resolvedColor;
+		return resolved ? literalColor(resolved.effectiveHex) : void 0;
+	}
+	if (run.color !== null) return literalColor(run.color);
+	const inherited = run.resolvedColor;
+	if (!inherited) {
+		notes.note("text.color.default", "approximated", "unread", "this run inherits its colour and nothing resolves what it inherits (a table style tier, or a list style the read model does not walk), so the write path paints it black — the one case where the output colour is not merely frozen but possibly wrong");
+		return;
+	}
+	notes.note("text.color.inherited", "flattened", "unsupported", "this run inherits its colour from the placeholder, master or theme; the write path paints an uncoloured run black instead of leaving it to inherit, so the inherited colour is resolved and baked in and no longer tracks a theme change");
+	return literalColor(inherited.effectiveHex);
+}
+/**
+* A run's hyperlink. Only external links map: the read model reports an internal jump as a
+* target part name, while the write API takes a slide *number*, which the deck-level walk
+* resolves — so a slide link is handled there, not here.
+*/
+function hyperlinkOption(run) {
+	const link = run.hyperlink;
+	if (!link?.url) return void 0;
+	return compact({
+		url: link.url,
+		tooltip: link.tooltip ?? void 0
+	});
+}
+/** Paragraph-level properties, replicated onto each of the paragraph's runs. */
+function paragraphOptions(paragraph, notes) {
+	const spacing = paragraph.lineSpacing;
+	const bullet = paragraph.bulletDetail;
+	const align = paragraph.align;
+	if (align !== null && !(align in ALIGN)) notes.note("text.align", "dropped", "unwritable", `distributed alignment "${align}" has no write-API spelling, so the paragraph falls back to its inherited alignment`);
+	if (paragraph.spaceBeforePt === 0 || paragraph.spaceAfterPt === 0) notes.note("text.paraSpaceZero", "dropped", "unwritable", "this paragraph explicitly sets zero space before or after (a:spcBef / a:spcAft of 0), which suppresses the spacing its list style would otherwise apply; the write path treats 0 as \"unset\" and emits nothing, so the inherited spacing comes back");
+	const bulletValue = bullet === null ? "inherit" : bulletOption(bullet, notes);
+	return compact({
+		align: align === null ? void 0 : ALIGN[align],
+		indentLevel: paragraph.level === 0 ? void 0 : paragraph.level,
+		paraMarginLeft: paraMarginOption(paragraph.marginLeftPt, bulletValue),
+		paraIndent: paraMarginOption(paragraph.indentPt, bulletValue),
+		paraSpaceBefore: orUndefined(paragraph.spaceBeforePt),
+		paraSpaceAfter: orUndefined(paragraph.spaceAfterPt),
+		lineSpacing: spacing?.type === "points" ? spacing.valuePt : void 0,
+		lineSpacingMultiple: spacing?.type === "percent" ? spacing.percent / 100 : void 0,
+		bullet: bulletValue
+	}) ?? {};
+}
+/**
+* Flatten a text frame into the `TextProps[]` first argument of `addText`.
+*
+* An empty paragraph becomes an item with empty text and a `breakLine`, which is how a
+* blank line survives — dropping it would silently close up vertical space the author put
+* there deliberately.
+*/
+function textRuns(frame, notes) {
+	const paragraphs = frame.paragraphs;
+	const items = [];
+	paragraphs.forEach((paragraph, paragraphIndex) => {
+		const paraOpts = paragraphOptions(paragraph, notes);
+		const runs = paragraph.runs;
+		const breaks = paragraphIndex < paragraphs.length - 1;
+		if (runs.length === 0) {
+			items.push({
+				text: "",
+				options: compact({
+					...paraOpts,
+					breakLine: breaks
+				}) ?? {}
+			});
+			return;
+		}
+		runs.forEach((run, runIndex) => {
+			const isLastRun = runIndex === runs.length - 1;
+			const continuation = { ...paraOpts };
+			delete continuation["bullet"];
+			const options = compact({
+				...runIndex === 0 ? paraOpts : continuation,
+				...runOptions(run, notes),
+				...isLastRun && breaks ? { breakLine: true } : {}
+			});
+			items.push(compact({
+				text: run.text,
+				options
+			}) ?? { text: run.text });
+		});
+	});
+	return items;
+}
+/**
+* Frame-level layout for the `TextPropsOptions` second argument — everything that belongs
+* to the body as a whole rather than to any paragraph.
+*
+* `resolvedAnchor` is the one place a *resolved* read is the right one: vertical anchoring
+* has no per-run fallback, so an unset `a:bodyPr/@anchor` genuinely means "whatever the
+* placeholder says", and an appended shape does not inherit that.
+*/
+function textFrameOptions(frame, notes) {
+	const body = frame.bodyProperties;
+	const anchor = frame.resolvedAnchor;
+	const vert = body?.vert ?? null;
+	if (vert !== null && !WRITABLE_VERT.has(vert)) notes.note("text.vert", "dropped", "unwritable", `text direction "${vert}" is outside TextVertType, so the body falls back to horizontal`);
+	return compact({
+		valign: anchor === null ? "top" : ANCHOR$1[anchor],
+		wrap: body?.wrap === null || body?.wrap === void 0 ? void 0 : body.wrap !== "none",
+		vert: vert !== null && WRITABLE_VERT.has(vert) ? vert : void 0,
+		fit: fitOption(frame, notes),
+		margin: marginOption(body)
+	}) ?? {};
+}
+/**
+* `a:bodyPr`'s autofit as the write API's `fit`.
+*
+* A `normAutofit` that bakes `fontScale` or `lnSpcReduction` is a *different state* from a
+* bare `<a:normAutofit/>`, so the two get different spellings. ECMA-376 §21.1.2.1.3 defaults
+* each attribute to 100%/0% only when it is **omitted**; PowerPoint recomputes an unbaked
+* scale on edit and draws the baked one exactly as written until then. Flattening both to
+* `'shrink'` therefore re-emits a frame that paints its text at full size — a deck baked at
+* `fontScale="40000"` comes back two and a half times too large — and the object form is
+* already what the write API accepts, so nothing has to be lost here.
+*
+* Out-of-range percentages are the one arm that still loses something. The write path rejects
+* anything outside 0–100 and drops the attribute with a warning, so passing one through would
+* turn a declared loss into a silent one; the frame falls back to bare `'shrink'` with a note.
+*/
+function fitOption(frame, notes) {
+	const autofit = frame.autofit;
+	if (autofit === null) return void 0;
+	if (autofit !== "normAutofit") return FIT[autofit];
+	const baked = compact({
+		fontScale: bakedPct(frame.autofitFontScale, "fontScale", notes),
+		lnSpcReduction: bakedPct(frame.autofitLineSpaceReduction, "lnSpcReduction", notes)
+	});
+	return baked ? {
+		type: "shrink",
+		...baked
+	} : FIT[autofit];
+}
+/** A baked `a:normAutofit` percentage, or `undefined` (with a note) when the write API would reject it. */
+function bakedPct(value, name, notes) {
+	if (value === null) return void 0;
+	if (value >= 0 && value <= 100) return value;
+	notes.note(`text.autofit.${name}`, "dropped", "unwritable", `baked a:normAutofit/@${name} of ${value}% is outside the 0-100 the write API accepts, so the frame re-emits a bare <a:normAutofit/>`);
+}
+/**
+* `a:bodyPr` insets as the write API's `margin`.
+*
+* A unit change, not just a copy: the read model reports insets in points, `margin` takes
+* **inches**, and it warns on any value `>= 1` on the assumption it is a stray points
+* value. Passing points straight through would therefore both inset the text by roughly
+* 72× too much and trip that warning.
+*
+* Emitted as the four-tuple whenever any inset is set, since a partial tuple is not
+* expressible; an unset side takes PowerPoint's own default rather than zero, so those are
+* spelled out — defaulting them to 0 would visibly reflow every body that sets one side.
+*/
+const DEFAULT_INSETS_PT = {
+	left: 7.2,
+	right: 7.2,
+	top: 3.6,
+	bottom: 3.6
+};
+function marginOption(body) {
+	const insets = body?.insetsPt;
+	if (!insets) return void 0;
+	const { left, right, top, bottom } = insets;
+	if (left === void 0 && right === void 0 && top === void 0 && bottom === void 0) return void 0;
+	return [
+		pointsToInches(top ?? DEFAULT_INSETS_PT.top),
+		pointsToInches(right ?? DEFAULT_INSETS_PT.right),
+		pointsToInches(bottom ?? DEFAULT_INSETS_PT.bottom),
+		pointsToInches(left ?? DEFAULT_INSETS_PT.left)
+	];
+}
+//#endregion
+//#region src/script/from-read/table.ts
+/** How {@link pictureFillOption}'s notes name a cell. */
+const CELL_PICTURE_FILL = {
+	construct: "table.cell.fill.picture",
+	subject: "this table cell",
+	element: "a:tcPr/a:blipFill"
+};
+/** How {@link pictureFillOption}'s notes name the table's own background. */
+const TABLE_PICTURE_FILL = {
+	construct: "table.fill.picture",
+	subject: "this table",
+	element: "a:tblPr/a:blipFill"
+};
+/** `a:tcPr/@anchor` → the write API's `valign`. */
+const ANCHOR = {
+	t: "top",
+	ctr: "middle",
+	b: "bottom"
+};
+function tableCall(frame, table, notes, assets) {
+	const styleId = table.styleId;
+	const hasStyle = table.resolvedStyle !== null;
+	const rows = [];
+	const rowHeights = [];
+	for (const row of table.rows) {
+		const cells = [];
+		for (const cell of row.cells) {
+			if (cell.isMergeContinuation) continue;
+			cells.push(cellIr(cell, hasStyle, notes, assets));
+		}
+		rows.push(cells);
+		rowHeights.push(row.heightEmu ?? 0);
+	}
+	const autoRows = rowHeights.filter((height) => height === 0).length;
+	if (autoRows === rowHeights.length && autoRows > 0) notes.note("table.rowAuto", "approximated", "unsupported", "every row is auto-height (a:tr/@h of 0), so no rowH is emitted and addTable divides the frame height evenly among the rows; the rows come back pinned to that even split rather than sized to their content");
+	else if (autoRows > 0) notes.note("table.rowAuto", "approximated", "unsupported", "at least one row is auto-height (a:tr/@h of 0) while others are not; rowH must be given for every row or none, so the auto rows are emitted as 0 and come back pinned to the height their content produced");
+	if (styleId === null) notes.note("table.style", "dropped", "unsupported", "this table names no a:tableStyleId, so it takes the generated deck's default table style");
+	const columnWidths = table.columnWidths;
+	return {
+		method: "addTable",
+		args: [rows, compact({
+			...positionOfFrame(frame),
+			objectName: frame.name || void 0,
+			tableStyle: orUndefined(styleId),
+			tableFill: tableFill(table, notes, assets),
+			hasHeader: table.firstRowHeader ? true : void 0,
+			hasBandedRows: table.bandedRows ? true : void 0,
+			colW: columnWidths.every((w) => w === null) ? void 0 : columnWidths.map((w) => inches(w ?? 0)),
+			rowH: rowHeights.every((h) => h === 0) ? void 0 : rowHeights.map(inches)
+		}) ?? {}],
+		...frame.name ? { sourceName: frame.name } : {}
+	};
+}
+/**
+* The table's own background (`a:tblPr` fill).
+*
+* Simpler than {@link cellFill}, and for one reason: a `a:tblPr` fill can only be the
+* table's own. There is no style graph feeding into it, so there is no
+* own-versus-inherited ambiguity to be careful about and the resolved colour can be used
+* directly. A scheme token still wins over the literal when there is one, so the replica
+* keeps tracking its theme.
+*/
+function tableFill(table, notes, assets) {
+	const gradient = table.gradientFill;
+	if (gradient) {
+		const stops = gradientStops(gradient, notes, "table.fill");
+		if (stops) return {
+			type: "gradient",
+			gradient: stops
+		};
+	}
+	const pattern = patternOption(table.patternFill);
+	if (pattern) return pattern;
+	const picture = table.pictureFill;
+	if (picture) return pictureFillOption(picture, assets, notes, TABLE_PICTURE_FILL);
+	const scheme = table.fillSchemeColor;
+	if (scheme !== null) return { color: scheme };
+	const resolved = table.resolvedFill;
+	return resolved ? { color: literalColor(resolved.effectiveHex) } : void 0;
+}
+/**
+* One cell as a `TableCell`.
+*
+* Cell text reuses the shape text mapper, so a per-run format inside a cell behaves
+* identically to one on a shape — the read model already shares `TextFrame` between the
+* two, and diverging here would be a difference with no cause.
+*/
+function cellIr(cell, hasStyle, notes, assets) {
+	const frame = cell.textFrame;
+	const anchor = cell.anchor;
+	const margins = cell.marginsEmu;
+	if (cell.id !== null || cell.headerIds.length > 0) notes.note("table.cell.headers", "dropped", "unwritable", "this cell carries a screen-reader header association (a:tc/@id / a:tcPr/a:headers); PowerPoint strips both on save, so there is no write option and the association is lost — hasHeader (a:tblPr/@firstRow) is the marker that survives");
+	const options = compact({
+		fill: cellFill(cell, hasStyle, notes, assets),
+		border: cellBorders(cell, notes),
+		diagonal: cellDiagonals(cell, notes),
+		anchorCtr: cell.anchorCtr ? true : void 0,
+		cell3D: cellThreeD(cell),
+		valign: anchor === null ? void 0 : ANCHOR[anchor],
+		textDirection: cellTextDirection(cell, notes),
+		horzOverflow: cell.horzOverflow === "clip" || cell.horzOverflow === "overflow" ? cell.horzOverflow : void 0,
+		colspan: cell.gridSpan > 1 ? cell.gridSpan : void 0,
+		rowspan: cell.rowSpan > 1 ? cell.rowSpan : void 0,
+		margin: margins ? [
+			inches(margins.top ?? 0),
+			inches(margins.right ?? 0),
+			inches(margins.bottom ?? 0),
+			inches(margins.left ?? 0)
+		] : void 0,
+		...frame?.paragraphs[0]?.runs[0] ? runOptions(frame.paragraphs[0].runs[0], notes) ?? {} : {}
+	});
+	return compact({
+		text: frame ? textRuns(frame, notes) : cell.text,
+		options
+	}) ?? { text: "" };
+}
+/**
+* The two corner-to-corner rules as `TableCellProps.diagonal`.
+*
+* Kept out of {@link cellBorders}' tuple for the same reason the write option is: they are
+* not edges. Every dash and colour a diagonal can carry is one an edge can, so they share
+* {@link borderIr} — including its out-of-enum dash note.
+*/
+function cellDiagonals(cell, notes) {
+	const borders = cell.borders;
+	if (!borders || !borders.tlToBr && !borders.blToTr) return void 0;
+	return compact({
+		tlToBr: borders.tlToBr ? borderIr(borders.tlToBr, notes) : void 0,
+		blToTr: borders.blToTr ? borderIr(borders.blToTr, notes) : void 0
+	});
+}
+/**
+* A cell's `a:cell3D` as `TableCellProps.cell3D`.
+*
+* Every field is passed through as read: the write path vets each against its `ST_` union
+* before emission, so a value from a source deck that somehow falls outside one is caught
+* there rather than being screened twice with two chances to disagree. Sizes are already in
+* points on both sides.
+*/
+function cellThreeD(cell) {
+	const cell3D = cell.cell3D;
+	if (!cell3D) return void 0;
+	const rig = cell3D.lightRig;
+	return compact({
+		preset: orUndefined(cell3D.bevel.preset),
+		width: orUndefined(cell3D.bevel.widthPt),
+		height: orUndefined(cell3D.bevel.heightPt),
+		material: orUndefined(cell3D.material),
+		lightRig: rig?.rig && rig.dir ? {
+			rig: rig.rig,
+			dir: rig.dir
+		} : void 0
+	}) ?? {};
+}
+/** The `ST_TextVerticalType` values `TextBaseProps.textDirection` accepts. */
+const WRITABLE_TEXT_DIRECTIONS = /* @__PURE__ */ new Set([
+	"horz",
+	"vert",
+	"vert270",
+	"wordArtVert"
+]);
+/**
+* A cell's `a:tcPr/@vert` as the write API's `textDirection`.
+*
+* `ST_TextVerticalType` has nine values and the write option covers four. The rest
+* (`eaVert`, `mongolianVert`, the WordArt right-to-left variants) are East-Asian layout
+* modes with no `TextBaseProps` spelling, so they are noted rather than written — passing
+* one straight through would put a value the option does not admit into the attribute.
+*/
+function cellTextDirection(cell, notes) {
+	const vert = cell.verticalText;
+	if (vert === null || vert === "horz") return void 0;
+	if (WRITABLE_TEXT_DIRECTIONS.has(vert)) return vert;
+	notes.note("table.cell.vert", "dropped", "unwritable", `this cell's a:tcPr/@vert is \`${vert}\`, which textDirection does not spell (it covers horz/vert/vert270/wordArtVert), so its text lands horizontal`);
+}
+/**
+* A cell's fill.
+*
+* The question here is not "what colour is this cell" but "what did the *source* say", and
+* the two differ for a styled table: `resolvedFill` answers the first, folding the cell's
+* own `a:solidFill` together with the colour it merely inherits from the style's
+* header/banding rules. Writing an inherited colour back would turn every banded cell into
+* an explicitly-filled one — the copy looks right until someone changes its table style, and
+* then nothing moves.
+*
+* {@link TableCell.hasOwnFill} separates them: an `a:tcPr` either carries an
+* `EG_FillProperties` child or it does not. So a cell's own fill is emitted (in whatever
+* form it took), and a cell with none is left to the style GUID, which reproduces the
+* banding exactly rather than approximately. Neither case loses anything, which is why
+* neither records a note.
+*/
+function cellFill(cell, hasStyle, notes, assets) {
+	if (cell.fillNoFill) return { type: "none" };
+	const gradient = cell.gradientFill;
+	if (gradient) {
+		const stops = gradientStops(gradient, notes, "table.cell.fill");
+		if (stops) return {
+			type: "gradient",
+			gradient: stops
+		};
+	}
+	const pattern = patternOption(cell.patternFill);
+	if (pattern) return pattern;
+	const picture = cell.pictureFill;
+	if (picture) return pictureFillOption(picture, assets, notes, CELL_PICTURE_FILL);
+	const scheme = cell.fillSchemeColor;
+	if (scheme !== null) return { color: scheme };
+	if (hasStyle && !cell.hasOwnFill) return void 0;
+	const resolved = cell.resolvedFill;
+	if (!resolved) return void 0;
+	return { color: literalColor(resolved.effectiveHex) };
+}
+/**
+* The four edge borders as the write API's `[top, right, bottom, left]` tuple.
+*
+* A suppressed edge (`a:noFill`) becomes `type: 'none'`, which is distinct from an absent
+* one — the first means "deliberately no rule here", the second means "inherit". The two
+* diagonals the read model also decodes are carried separately, by {@link cellDiagonals}.
+*/
+function cellBorders(cell, notes) {
+	const borders = cell.borders;
+	if (!borders) return void 0;
+	const edges = [
+		borders.top,
+		borders.right,
+		borders.bottom,
+		borders.left
+	];
+	if (edges.every((edge) => edge === null)) return void 0;
+	return edges.map((edge) => borderIr(edge, notes));
+}
+/** The `ST_PresetLineDashVal` tokens `BorderProps.dashType` accepts. */
+const WRITABLE_DASHES$1 = /* @__PURE__ */ new Set([
+	"solid",
+	"dot",
+	"dash",
+	"lgDash",
+	"dashDot",
+	"lgDashDot",
+	"lgDashDotDot",
+	"sysDash",
+	"sysDot",
+	"sysDashDot",
+	"sysDashDotDot"
+]);
+/**
+* One decoded edge (or diagonal) as `BorderProps`.
+*
+* `type` stays the coarse on/off switch and `dashType` carries the exact preset, so a
+* `lgDashDot` rule comes back as itself rather than as the generic `sysDash` every dash
+* used to collapse onto. A dash outside `ST_PresetLineDashVal` cannot have come from a
+* conformant deck, so it is dropped to a plain dashed rule and noted.
+*/
+function borderIr(edge, notes) {
+	if (!edge) return {};
+	if (edge.noFill) return { type: "none" };
+	const dash = edge.dash;
+	const known = dash === null || WRITABLE_DASHES$1.has(dash);
+	if (!known) notes.note("table.cell.borders.dash", "approximated", "unsupported", `a cell border's a:prstDash/@val is \`${dash}\`, which is outside ST_PresetLineDashVal; it is written as a plain dashed rule`);
+	return compact({
+		type: dash === null || dash === "solid" ? "solid" : "dash",
+		dashType: known && dash !== null && dash !== "solid" ? dash : void 0,
+		color: edge.schemeColor ?? (edge.color === null ? void 0 : literalColor(edge.color)),
+		width: orUndefined(edge.widthPt)
+	}) ?? {};
+}
+//#endregion
+//#region src/script/from-read/chart.ts
+/**
+* Read chart-group token → `CHART_NAME`. The read model strips the `Chart` suffix from the
+* plot-area element name, so `c:barChart` arrives as `bar`. A 3-D group maps onto the
+* matching flat type where one exists; anything absent from this table has no write-API
+* chart type and is reported rather than guessed at.
+*/
+const CHART_TYPE = {
+	area: "area",
+	area3D: "area",
+	bar: "bar",
+	bar3D: "bar3D",
+	bubble: "bubble",
+	bubble3D: "bubble3D",
+	doughnut: "doughnut",
+	line: "line",
+	line3D: "line",
+	pie: "pie",
+	pie3D: "pie",
+	radar: "radar",
+	scatter: "scatter",
+	stock: "stock",
+	surface: "surface",
+	surface3D: "surface"
+};
+/** `c:legendPos/@val` → the write API's `legendPos`. */
+const LEGEND_POS = {
+	r: "r",
+	l: "l",
+	t: "t",
+	b: "b",
+	tr: "tr"
+};
+function chartCall(frame, chart, notes) {
+	const sourceType = chart.chartType;
+	const type = sourceType === null ? void 0 : CHART_TYPE[sourceType];
+	if (!type) {
+		notes.note("chart.type", "dropped", "unwritable", `chart type "${sourceType ?? "none"}" has no write-API counterpart, so the chart is omitted`);
+		return null;
+	}
+	if (chart.chartTypes.length > 1) notes.note("chart.combo", "flattened", "unsupported", `a combo chart (${chart.chartTypes.join(" + ")}) is emitted as a single ${type} chart; addChart's multi-type form needs a per-series type the read model does not report`);
+	notes.note("chart.workbook", "approximated", "unsupported", "the chart is rebuilt from its cached plot values, so its embedded workbook is regenerated: the plotted numbers match, but the source sheet's formulas, extra columns and formatting are gone");
+	const data = seriesData(chart, notes);
+	if (data.length === 0) {
+		notes.note("chart.data", "dropped", "unsupported", "this chart caches no plottable series values");
+		return null;
+	}
+	return {
+		method: "addChart",
+		args: [data, compact({
+			type,
+			...positionOfFrame(frame),
+			objectName: frame.name || void 0,
+			...titleOptions(chart),
+			...legendOptions(chart),
+			...labelOptions(chart),
+			...axisOptions(chart),
+			chartColors: seriesColors(chart)
+		}) ?? { type }],
+		...frame.name ? { sourceName: frame.name } : {}
+	};
+}
+/**
+* Series as `OptsChartData[]`. Category labels ride on the first series, which is the shape
+* `addChart` expects; the read model reports them per-series but they are shared in
+* practice.
+*/
+function seriesData(chart, notes) {
+	const categories = chart.categories.map((label) => label ?? "");
+	let sawBlank = false;
+	const data = chart.series.map((series, index) => {
+		const values = series.values.map((value) => {
+			if (value === null) sawBlank = true;
+			return value ?? 0;
+		});
+		return compact({
+			name: orUndefined(series.name),
+			values,
+			labels: index === 0 && categories.length > 0 ? categories : void 0
+		}) ?? { values };
+	});
+	if (sawBlank) notes.note("chart.blanks", "approximated", "unwritable", "a blank cached data point becomes 0, because OptsChartData.values is number[] and has no spelling for a gap; on a line chart this draws a dip to the axis where the source showed a break");
+	return data;
+}
+function titleOptions(chart) {
+	const title = chart.title;
+	return title === null ? {} : {
+		showTitle: true,
+		title
+	};
+}
+function legendOptions(chart) {
+	const legend = chart.legend;
+	if (!legend) return { showLegend: false };
+	return {
+		showLegend: true,
+		legendPos: legend.position === null ? void 0 : LEGEND_POS[legend.position]
+	};
+}
+function labelOptions(chart) {
+	const labels = chart.dataLabels;
+	if (!labels) return {};
+	return {
+		showValue: labels.showValue ?? void 0,
+		showSerName: labels.showSeriesName ?? void 0,
+		showCatName: labels.showCategoryName ?? void 0,
+		showPercent: labels.showPercent ?? void 0,
+		showLegendKey: labels.showLegendKey ?? void 0,
+		showLeaderLines: labels.showLeaderLines ?? void 0,
+		dataLabelPosition: orUndefined(labels.position),
+		dataLabelFormatCode: labels.numberFormat?.formatCode ?? void 0
+	};
+}
+/**
+* Axis bounds, titles and gridlines. The write API spells these as a flat `catAxis*` /
+* `valAxis*` prefix set rather than an axis object, so each side is unpacked by hand.
+*/
+function axisOptions(chart) {
+	const cat = chart.categoryAxis;
+	const val = chart.valueAxis;
+	return {
+		catAxisHidden: cat?.hidden ? true : void 0,
+		catAxisTitle: cat?.title ?? void 0,
+		valAxisHidden: val?.hidden ? true : void 0,
+		valAxisTitle: val?.title ?? void 0,
+		valAxisMinVal: val?.min ?? void 0,
+		valAxisMaxVal: val?.max ?? void 0,
+		valAxisMajorUnit: val?.majorUnit ?? void 0,
+		valAxisLabelFormatCode: val?.numberFormat?.formatCode ?? void 0
+	};
+}
+/**
+* Per-series fill colours as `chartColors`, which is positional — entry `n` colours series
+* `n`. A series with no explicit fill takes the theme's accent for its position, which the
+* read model does not resolve, so the whole option is dropped unless every series names a
+* colour; a partial list would silently recolour the unnamed ones.
+*/
+function seriesColors(chart) {
+	const series = chart.series;
+	if (series.length === 0) return void 0;
+	const colors = [];
+	for (const one of series) {
+		const hex = one.fill?.color;
+		if (!hex) return void 0;
+		colors.push(literalColor(hex));
+	}
+	return colors;
+}
+//#endregion
+//#region src/script/from-read/shape.ts
+/**
+* `AnyShape` → one {@link CallIr}.
+*
+* The dispatch is on what the shape *is*, not on what it looks like: an `AutoShape` with a
+* text frame and no geometry is an `addText`, one with geometry is an `addShape` that may
+* also carry text, a `Picture` is an `addImage`, and a `GraphicFrame` delegates to the
+* table or chart mapper. A `GroupShape` recurses.
+*
+* The single most important thing this module does is record what it cannot carry.
+* Measurement against the fixture corpus found the binding constraint is the *read* side,
+* not the write side — several constructs the write API can express have no accessor at
+* all — so a converter that mapped only what it could see would produce clean-looking
+* output with silent visual losses. The clearest is theme-referenced line styling: a shape
+* whose outline comes from `p:style/a:lnRef` reports a colour through `resolvedLine` but
+* reports `null` for width and dash, because there is a resolved-colour path and no
+* resolved-width path. In the corpus that was every such shape, so a themed 2pt
+* border silently becomes a 1pt default. Each one is noted here rather than quietly thinned.
+*
+* The same dispatch serves the deck's *chrome*: {@link masterObject} re-tags a call as an
+* entry in a `defineSlideMaster({ objects })` array, so a rectangle on a layout is transcribed
+* by the code that transcribes one on a slide. Sharing it is the point — a second mapper would
+* be a second set of decisions about the same OOXML, drifting from this one silently.
+*/
+/** How {@link pictureFillOption}'s notes name a shape's surface. */
+const SHAPE_PICTURE_FILL = {
+	construct: "fill.picture",
+	subject: "this shape's surface",
+	element: "a:blipFill"
+};
+/** Arrowhead types `ShapeLineProps` accepts; `a:headEnd/@type` uses the same tokens. */
+const WRITABLE_ARROWS = /* @__PURE__ */ new Set([
+	"none",
+	"arrow",
+	"diamond",
+	"oval",
+	"stealth",
+	"triangle"
+]);
+/** Dash tokens `ShapeLineProps.dashType` accepts — the whole `ST_PresetLineDashVal` set. */
+const WRITABLE_DASHES = /* @__PURE__ */ new Set([
+	"solid",
+	"dot",
+	"dash",
+	"lgDash",
+	"dashDot",
+	"lgDashDot",
+	"lgDashDotDot",
+	"sysDash",
+	"sysDot",
+	"sysDashDot",
+	"sysDashDotDot"
+]);
+/**
+* `a:ln/@cap` tokens → the `ShapeLineProps.cap` spelling that authors them. The read side
+* reports the raw OOXML token (`AutoShape.lineCap`) and the write side takes a friendly
+* name, so this is the whole of the mapping between them. `ST_LineCap` has exactly these
+* three members, so nothing falls off the end.
+*/
+const CAP_TOKENS = {
+	flat: "flat",
+	sq: "square",
+	rnd: "round"
+};
+/**
+* Map one shape. Returns `null` when the shape produces no call at all — a note is always
+* recorded in that case, so a dropped shape is never silent.
+*/
+function shapeCall(shape, notes, assets) {
+	const scoped = notes.forShape(shape.name || null);
+	if (shape.hidden) {
+		noteHidden(scoped);
+		return null;
+	}
+	if (isGroupShape(shape)) return groupCall(shape, scoped, assets);
+	if (isPicture(shape)) return pictureCall(shape, scoped, assets);
+	if (isConnector(shape)) return connectorCall(shape, scoped);
+	if (isGraphicFrame(shape)) return graphicFrameCall(shape, scoped, assets);
+	if (isAutoShape(shape)) return autoShapeCall(shape, scoped, assets);
+	return null;
+}
+/**
+* `p:cNvPr/@hidden` has no write-API counterpart, so a hidden shape would come back visible.
+* Omitting it preserves what the deck looks like, which is the lesser loss. Shared with the
+* layout-decoration mapper below, whose connector arm does not pass through {@link shapeCall}.
+*/
+function noteHidden(notes) {
+	notes.note("shape.hidden", "dropped", "unwritable", "a hidden shape has no write-API expression; it is omitted rather than emitted visible");
+}
+/**
+* Position as `Coord`-typed EMU strings, so the source geometry survives exactly.
+*
+* `absoluteFrame` rather than the raw `left`/`top`: a shape inside a group is positioned in
+* its group's child coordinate space, which a flattened call list cannot express, so the
+* group transform has to be composed in here. For a top-level shape the two are identical.
+*/
+function positionOptions(shape, notes) {
+	const frame = shape.absoluteFrame;
+	if (frame) return {
+		x: emu(frame.left),
+		y: emu(frame.top),
+		w: emu(frame.width),
+		h: emu(frame.height)
+	};
+	const resolved = shape.resolvedFrame;
+	if (!resolved) return {};
+	notes?.note("shape.frameInherited", "flattened", "unsupported", `this shape has no transform of its own and takes its geometry from the ${resolved.source}; a regenerated slide inherits nothing, so the resolved position is baked in and stops tracking later edits to that ${resolved.source}`);
+	return {
+		x: emu(resolved.left),
+		y: emu(resolved.top),
+		w: emu(resolved.width),
+		h: emu(resolved.height)
+	};
+}
+/**
+* Rotation and flips. Taken from `absoluteFrame`, which composes enclosing group rotations
+* and XOR-composes group flips — the same reason position is absolute.
+*/
+function transformOptions(shape) {
+	const frame = shape.absoluteFrame;
+	const rotate = frame ? frame.rotation : shape.rotation ?? 0;
+	return {
+		rotate: rotate === 0 ? void 0 : rotate,
+		flipH: frame?.flipH ?? shape.flipH ? true : void 0,
+		flipV: frame?.flipV ?? shape.flipV ? true : void 0
+	};
+}
+/**
+* A shape's fill as `ShapeFillProps`.
+*
+* Prefers the raw scheme token over `resolvedFill` for the same reason run colour does: a
+* token keeps tracking the destination theme. `resolvedFill` is the fallback because it is
+* the only accessor that sees a `p:style/a:fillRef` — a shape styled entirely from the
+* theme has no `a:solidFill` of its own, so without it the shape would come out unfilled.
+*/
+function fillOption(shape, notes, assets) {
+	const gradient = shape.gradientFill;
+	if (gradient) {
+		const stops = gradientStops(gradient, notes, "fill");
+		if (stops) return {
+			type: "gradient",
+			gradient: stops
+		};
+	}
+	const pattern = patternOption(shape.patternFill);
+	if (pattern) return pattern;
+	const picture = shape.pictureFill;
+	if (picture) return pictureFillOption(picture, assets, notes, SHAPE_PICTURE_FILL);
+	const scheme = shape.fillSchemeColor;
+	if (isWritableSchemeToken(scheme)) return { color: scheme };
+	if (shape.fillColor !== null) return { color: literalColor(shape.fillColor) };
+	const resolved = shape.resolvedFill;
+	if (!resolved) return void 0;
+	if (scheme !== null) notes.note("fill.schemeToken", "approximated", "unwritable", `fill scheme colour "${scheme}" is outside the ten tokens the write path maps, so it is baked to a literal hex and stops tracking the theme`);
+	return compact({
+		color: literalColor(resolved.effectiveHex),
+		transparency: alphaToTransparency(resolved.alpha)
+	});
+}
+/**
+* A shape's outline as `ShapeLineProps`.
+*
+* This is where the measured silent loss lives. When a shape takes its outline from
+* `p:style/a:lnRef`, `resolvedLine` supplies the colour but `lineWidthPt` and `lineDash`
+* both report `null` — the theme's `a:lnStyleLst` entry, where the width and dash actually
+* live, has no accessor. Emitting the colour and noting the rest is the honest outcome;
+* inventing a width would be worse, because it would look deliberate.
+*/
+function lineOption(shape, notes) {
+	if (shape.lineNoFill) return { type: "none" };
+	const gradient = shape.lineGradient;
+	if (gradient) {
+		const stops = gradientStops(gradient, notes, "line");
+		if (stops) return {
+			type: "gradient",
+			gradient: stops
+		};
+	}
+	const widthPt = shape.lineWidthPt;
+	const dash = shape.lineDash;
+	const cap = shape.lineCap;
+	const scheme = shape.lineSchemeColor;
+	const resolved = shape.resolvedLine;
+	let color;
+	if (isWritableSchemeToken(scheme)) color = scheme;
+	else if (shape.lineColor !== null) color = literalColor(shape.lineColor);
+	else if (resolved) color = literalColor(resolved.effectiveHex);
+	if (resolved !== null && shape.lineColor === null && scheme === null && widthPt === null) notes.note("line.width", "dropped", "unread", "this outline comes from the theme style list (p:style/a:lnRef); its width and dash live in the theme fmtScheme a:lnStyleLst, which has no accessor, so only the colour carries");
+	if (dash !== null && !WRITABLE_DASHES.has(dash)) notes.note("line.dash", "approximated", "unwritable", `dash style "${dash}" is outside the eight the write API accepts, so the outline falls back to solid`);
+	if (shape.lineAlign === "in") notes.note("line.align", "dropped", "unwritable", "this outline is inset (a:ln/@algn=\"in\", drawn wholly inside the shape); ShapeLineProps has no alignment option, so it comes back centred on the edge and sits half its width further out");
+	return compact({
+		color,
+		width: orUndefined(widthPt),
+		dashType: dash !== null && WRITABLE_DASHES.has(dash) ? dash : void 0,
+		cap: cap === null ? void 0 : CAP_TOKENS[cap],
+		transparency: alphaToTransparency(resolved?.alpha),
+		...arrowOptions(shape, notes)
+	});
+}
+/** Arrowheads. Types map directly; the `sm`/`med`/`lg` size classes have no option. */
+function arrowOptions(shape, notes) {
+	const ends = shape.lineEnds;
+	if (!ends) return {};
+	if ([ends.head, ends.tail].some((end) => end && (end.width !== null || end.length !== null))) notes.note("line.arrowSize", "dropped", "unwritable", "arrowhead width and length classes (@w / @len) have no write-API option, so arrowheads render at the default size");
+	return {
+		beginArrowType: ends.head && WRITABLE_ARROWS.has(ends.head.type) ? ends.head.type : void 0,
+		endArrowType: ends.tail && WRITABLE_ARROWS.has(ends.tail.type) ? ends.tail.type : void 0
+	};
+}
+/** Outer shadow as `ShadowProps`; an inner shadow uses the same option with `type: 'inner'`. */
+function shadowOption(shape, notes) {
+	if (shape.reflection || shape.softEdge) notes.note("shape.effects", "dropped", "unwritable", "a:reflection and a:softEdge are read but have no write-API emitter, so those effects are lost");
+	const outer = shape.shadow;
+	const source = outer ?? shape.innerShadow;
+	if (!source) return void 0;
+	return compact({
+		type: outer ? "outer" : "inner",
+		color: source.color === null ? void 0 : literalColor(source.color),
+		blur: source.blurPt,
+		offset: source.offsetPt,
+		angle: source.angleDeg,
+		transparency: alphaToTransparency(source.alpha)
+	});
+}
+/** Glow. The read model reports opacity as a 0–1 alpha, which is the write API's unit too. */
+function glowOption(shape) {
+	const glow = shape.glow;
+	if (!glow) return void 0;
+	return compact({
+		size: glow.radiusPt,
+		color: glow.color === null ? void 0 : literalColor(glow.color),
+		opacity: glow.alpha
+	});
+}
+/** The style block every shape kind shares. */
+function styleOptions(shape, notes, assets) {
+	return {
+		fill: fillOption(shape, notes, assets),
+		line: lineOption(shape, notes),
+		shadow: shadowOption(shape, notes),
+		glow: glowOption(shape)
+	};
+}
+/**
+* An `AutoShape` becomes an `addShape` when it is bare geometry and an `addText` when it
+* carries text. A shape with both takes the `addText` form, because `addShape` has no text
+* argument while `addText` accepts a `shape` option — so only that form expresses both.
+*/
+function autoShapeCall(shape, notes, assets) {
+	const preset = shape.presetGeometry;
+	const custom = shape.customGeometry;
+	const frame = shape.hasTextFrame ? shape.textFrame : null;
+	const runText = frame === null ? "" : frame.paragraphs.flatMap((p) => p.runs.map((run) => run.text)).join("");
+	const hasText = runText.length > 0;
+	if (frame !== null && frame.text.replaceAll("\n", "").length > runText.length) notes.note("text.field", "dropped", "unread", "this shape holds an automatic field (a:fld — a slide number, date or footer), which has no accessor and no addText expression, so its text is not reproduced");
+	if (frame !== null && hasEquation(shape.element_)) notes.note("text.equation", "dropped", "unread", "this shape holds an OMML equation, which no accessor exposes, so the shape is emitted without it — even though TextProps.math (and the ts-pptx/math subpath) could author one");
+	if (shape.placeholder) notes.note("shape.placeholder", "flattened", "unsupported", "a placeholder is emitted as a plain shape with its inherited geometry and styling baked in, so it no longer follows its layout");
+	const common = {
+		...positionOptions(shape, notes),
+		...transformOptions(shape),
+		...styleOptions(shape, notes, assets),
+		objectName: shape.name || void 0
+	};
+	if (custom) {
+		notes.note("shape.custGeom.guides", "dropped", "unread", "custGeom guides, adjust handles and connection sites (a:gdLst / a:ahLst / a:cxnLst) have no accessor, so only the path outline carries");
+		return {
+			method: "addShape",
+			args: ["custGeom", compact({
+				...common,
+				points: customGeometryPoints(shape, custom)
+			}) ?? {}],
+			...nameOf(shape)
+		};
+	}
+	if (hasText && frame !== null) {
+		const options = compact({
+			...common,
+			...textFrameOptions(frame, notes),
+			...isTextBox(shape.element_) ? { isTextBox: true } : {},
+			...preset === null ? {} : {
+				shape: preset,
+				...adjustOptions(shape)
+			}
+		});
+		return {
+			method: "addText",
+			args: [textRuns(frame, notes), options ?? {}],
+			...nameOf(shape)
+		};
+	}
+	if (preset === null) {
+		notes.note("shape.empty", "dropped", "unsupported", "this shape carries no text and no geometry of its own (an unfilled placeholder drawing its outline from the layout), so there is no addShape preset to name and it is omitted");
+		return null;
+	}
+	return {
+		method: "addShape",
+		args: [preset, compact({
+			...common,
+			...adjustOptions(shape)
+		}) ?? {}],
+		...nameOf(shape)
+	};
+}
+/**
+* Preset-geometry adjust handles (`a:avLst`) as `shapeAdjust`.
+*
+* The read model reports each guide's raw formula string; a preset's adjust values are
+* `val <n>` where `<n>` is in 1000ths of a percent, and the write API takes the same handle
+* as a `0.0–1.0` fraction. Anything that is not a plain `val` is a computed guide, which
+* has no write-API expression, so it is skipped rather than mis-scaled.
+*/
+function adjustOptions(shape) {
+	const values = shape.adjustValues;
+	const guides = [];
+	for (const name of Object.keys(values).sort()) {
+		const match = /^val\s+(-?\d+)$/.exec((values[name] ?? "").trim());
+		if (!match?.[1]) continue;
+		guides.push({
+			name,
+			value: Number(match[1]) / PERCENT_SCALE
+		});
+	}
+	return guides.length ? { shapeAdjust: guides } : {};
+}
+/**
+* `custGeom` path commands as the write API's `points` array.
+*
+* Path coordinates are integers in the path's own `0..w`/`0..h` viewport, not EMU, so each
+* is scaled onto the shape's box before being printed as EMU. A path that declares no
+* viewport (`@w`/`@h` of 0) is already in the shape's own space and passes through.
+*/
+function customGeometryPoints(shape, custom) {
+	const frame = shape.absoluteFrame;
+	const points = [];
+	for (const path of custom.paths) {
+		const sx = path.w > 0 && frame ? frame.width / path.w : 1;
+		const sy = path.h > 0 && frame ? frame.height / path.h : 1;
+		const px = (v) => emu(v * sx);
+		const py = (v) => emu(v * sy);
+		for (const command of path.commands) switch (command.cmd) {
+			case "moveTo":
+				points.push({
+					x: px(command.x),
+					y: py(command.y),
+					moveTo: true
+				});
+				break;
+			case "lnTo":
+				points.push({
+					x: px(command.x),
+					y: py(command.y)
+				});
+				break;
+			case "cubicBezTo":
+				points.push({
+					x: px(command.x),
+					y: py(command.y),
+					curve: {
+						type: "cubic",
+						x1: px(command.x1),
+						y1: py(command.y1),
+						x2: px(command.x2),
+						y2: py(command.y2)
+					}
+				});
+				break;
+			case "quadBezTo":
+				points.push({
+					x: px(command.x),
+					y: py(command.y),
+					curve: {
+						type: "quadratic",
+						x1: px(command.x1),
+						y1: py(command.y1)
+					}
+				});
+				break;
+			case "arcTo":
+				points.push({ curve: {
+					type: "arc",
+					wR: px(command.wR),
+					hR: py(command.hR),
+					stAng: command.stAng,
+					swAng: command.swAng
+				} });
+				break;
+			case "close": points.push({ close: true });
+		}
+	}
+	return points;
+}
+/**
+* A `Picture` becomes `addImage`, with its bytes carried as an asset.
+*
+* PowerPoint authors embedded audio and video as a picture too — the poster frame is the
+* blip, and the media itself hangs off `p:nvPr` as `a:videoFile`/`a:audioFile`. The read
+* model surfaces only the poster (`mediaKind` separates raster from SVG, not still from
+* moving), so a video would otherwise convert to a static image with nothing to show it had
+* ever moved. The write API has `addMedia`, so this is a read-side gap, and it is declared
+* rather than silently flattened.
+*/
+function pictureCall(shape, notes, assets) {
+	if (isAudioVideo(shape.element_)) notes.note("media.audioVideo", "flattened", "unread", "this is embedded audio or video: no accessor reports the media part or its kind, only the poster frame, so it is emitted as a still image even though addMedia could author it");
+	const partName = shape.svgPartName ?? shape.imagePartName;
+	if (!partName) {
+		notes.note("image.data", "dropped", "unsupported", "this picture references no embedded image part (an external or linked image), so there are no bytes to carry");
+		return null;
+	}
+	const asset = assets.assetFor(partName);
+	if (!asset) {
+		notes.note("image.data", "dropped", "unsupported", `image part ${partName} is not present in the package`);
+		return null;
+	}
+	if (shape.svgPartName && shape.imagePartName) notes.note("image.svg", "approximated", "unsupported", "the vector part of this SVG picture is carried and the source's own raster fallback is not; the write path generates a fresh fallback, so a renderer that cannot draw SVG shows a different image from the one the source deck shipped");
+	if (shape.recolor) notes.note("image.recolor", "dropped", "unwritable", "a picture recolour (a:duotone / a:clrChange / a:grayscl) is read but has no write-API option");
+	const crop = shape.crop;
+	return {
+		method: "addImage",
+		args: [{
+			...compact({
+				...positionOptions(shape, notes),
+				...transformOptions(shape),
+				objectName: shape.name || void 0,
+				crop: crop === null ? void 0 : {
+					l: crop.left * 100,
+					t: crop.top * 100,
+					r: crop.right * 100,
+					b: crop.bottom * 100
+				}
+			}),
+			data: asset
+		}],
+		...nameOf(shape)
+	};
+}
+/**
+* `ConnectorProps` keys that {@link lineOption} can produce. A connector styles its stroke
+* with *flat* options rather than the nested `line` object every other shape takes, and it
+* accepts a strict subset: no `transparency`, no gradient stroke, and its own `type` names
+* the routing (`straight`/`elbow`/`curved`), not a fill kind — so spreading a line option
+* object into it wholesale would both drop silently and collide.
+*/
+const CONNECTOR_LINE_KEYS = [
+	"color",
+	"width",
+	"dashType",
+	"beginArrowType",
+	"endArrowType"
+];
+/**
+* A `Connector` becomes `addConnector`.
+*
+* The endpoints are the one real translation here. OOXML gives a connector a bounding box
+* plus flip flags; `addConnector` takes two points. `a:flipH`/`a:flipV` are what say which
+* diagonal of the box the line runs along, so dropping them would silently mirror every
+* connector that runs up or leftward.
+*
+* The *bindings* (`a:stCxn`/`a:endCxn`) reference source shape ids that have no counterpart
+* in the output, so a connector lands unbound and stops following its shapes when they move.
+*/
+function connectorCall(shape, notes) {
+	const frame = shape.absoluteFrame;
+	if (!frame) return null;
+	if (shape.startConnection || shape.endConnection) notes.note("connector.binding", "dropped", "unsupported", "connector endpoint bindings reference source shape ids with no counterpart in the output, so the connector lands unbound and no longer follows its shapes");
+	if (shape.rotation) notes.note("connector.rotation", "dropped", "unwritable", "addConnector takes two endpoints and no rotation, so a rotated connector lands along the unrotated diagonal of its box");
+	const line = lineOption(shape, notes) ?? {};
+	const stroke = {};
+	for (const key of CONNECTOR_LINE_KEYS) {
+		const value = line[key];
+		if (value !== void 0) stroke[key] = value;
+	}
+	if (line["type"] === "gradient" || line["transparency"] !== void 0) notes.note("connector.line", "flattened", "unwritable", "a connector styles its stroke with flat colour/width options, which cannot express a gradient stroke or a stroke transparency, so those fall back to a plain line");
+	const right = frame.left + frame.width;
+	const bottom = frame.top + frame.height;
+	return {
+		method: "addConnector",
+		args: [compact({
+			type: "straight",
+			x1: emu(shape.flipH ? right : frame.left),
+			y1: emu(shape.flipV ? bottom : frame.top),
+			x2: emu(shape.flipH ? frame.left : right),
+			y2: emu(shape.flipV ? frame.top : bottom),
+			objectName: shape.name || void 0,
+			...stroke
+		}) ?? {}],
+		...nameOf(shape)
+	};
+}
+/**
+* Why a graphic frame cannot be authored from a script, or `null` when it can.
+*
+* The single enumeration of the payloads with no write-API emitter, and the reason it is a
+* function rather than a condition spelled at each site: `graphicFrameCall` needs it to pick
+* a fidelity note, and `hasUnwritableContent` in `from-read/deck.ts` needs it to decide
+* whether the printer must copy the slide instead of transcribing it. Those were two
+* hand-maintained lists, they disagreed — the deck-level one named extended charts only — and
+* a SmartArt slide was therefore transcribed with a hole where the graphic had been. The two
+* consequences are the same for every member, so the membership has to be too.
+*/
+function unwritableFramePayload(shape) {
+	if (shape.table || shape.chart) return null;
+	if (shape.hasChartEx) return "chartEx";
+	if (shape.hasDiagram) return "diagram";
+	return "unknown";
+}
+/** A `GraphicFrame` hosts a table or a chart; both have their own mapper. */
+function graphicFrameCall(shape, notes, assets) {
+	const table = shape.table;
+	if (table) return tableCall(shape, table, notes, assets);
+	const chart = shape.chart;
+	if (chart) return chartCall(shape, chart, notes);
+	switch (unwritableFramePayload(shape)) {
+		case "chartEx":
+			notes.note("chartEx.all", "dropped", "unwritable", "an extended chart (waterfall, funnel, box-and-whisker, …) has a full reader but no write-API counterpart");
+			return null;
+		case "diagram":
+			notes.note("diagram.all", "dropped", "unwritable", "a SmartArt diagram has a full reader and its text can be edited in place through it (DiagramPoint.text), but no write API authors one from a script, so a converted script cannot describe this frame");
+			return null;
+		default:
+			notes.note("graphicFrame.unknown", "dropped", "unread", "this graphic frame hosts none of a table, a chart or a SmartArt diagram (an OLE object or an ink annotation), which the read model does not decode");
+			return null;
+	}
+}
+/**
+* A `GroupShape` becomes `addGroup`, with each child mapped and re-tagged into the
+* key-tagged `GroupChildProps` shape the write API expects.
+*
+* Children keep slide-absolute coordinates, which is not a compromise here: `addGroup`
+* holds an identity child coordinate space (`chOff/chExt == off/ext`) at every depth
+* precisely so they can. Nested groups therefore nest rather than flatten. What does not
+* survive is a source group with a *non*-identity child space — that group scales its
+* contents when resized and the emitted one will not — so that case, and only that case,
+* is noted.
+*
+* Charts, tables, media and placeholders are excluded from groups by the write API, so a
+* group holding one loses that child.
+*/
+function groupCall(shape, notes, assets) {
+	const children = [];
+	for (const child of shape.shapes) {
+		const call = shapeCall(child, notes, assets);
+		if (!call) continue;
+		const tagged = asGroupChild(call);
+		if (!tagged) {
+			notes.note("group.child", "dropped", "unsupported", `addGroup accepts no ${call.method.replace(/^add/, "").toLowerCase()} child (charts, tables and media are excluded by design), so this child is omitted from the group`);
+			continue;
+		}
+		children.push(tagged);
+	}
+	if (children.length === 0) {
+		notes.note("group.empty", "dropped", "unsupported", "no child of this group produced a call, and addGroup rejects an empty child list, so the group itself is omitted too");
+		return null;
+	}
+	if (!hasIdentityChildSpace(shape.element_)) notes.note("group.childSpace", "flattened", "unsupported", "this group scales its contents (its a:chOff/a:chExt differ from its a:off/a:ext); addGroup's child space is always identity, so the children are emitted pre-scaled and resizing the group no longer rescales them");
+	if (shape.rotation !== 0 || shape.flipH || shape.flipV) notes.note("group.transform", "flattened", "unsupported", "the group's own rotation and flips are baked into its children's coordinates rather than kept on the group, because addGroup would otherwise apply them twice; the shapes render identically but rotating or resetting the group no longer moves them together");
+	return {
+		method: "addGroup",
+		args: [children, compact({
+			...positionOptions(shape, notes),
+			objectName: shape.name || void 0
+		}) ?? {}],
+		...nameOf(shape)
+	};
+}
+/**
+* Re-tag a call as a `GroupChildProps` entry, or `null` when the content type is one
+* `addGroup` excludes. The tagged form is a single-key object, not a `{ type, args }` pair.
+*/
+function asGroupChild(call) {
+	const shared = commonShapeVariant(call);
+	if (shared) return shared;
+	const [first, second] = call.args;
+	switch (call.method) {
+		case "addGroup": return { group: compact({
+			children: first,
+			options: second
+		}) ?? {} };
+		default: return null;
+	}
+}
+/**
+* The three key-tagged variants both union-shaped call sites emit identically: a text box, an
+* auto shape, and an image. `null` when `call.method` is not one of them, which is the signal
+* for the caller to try its own extra arms.
+*
+* Shared rather than duplicated because this is exactly where a fourth common variant would be
+* added to one site and forgotten in the other. What is deliberately *not* shared is either
+* caller's `default`: a group child silently declines a chart, while a layout object reports it
+* as a fidelity loss, and that difference is the point of having two functions.
+*/
+function commonShapeVariant(call) {
+	const [first, second] = call.args;
+	switch (call.method) {
+		case "addText": return { text: compact({
+			text: first,
+			options: second
+		}) ?? {} };
+		case "addShape": return { shape: compact({
+			type: first,
+			options: second
+		}) ?? {} };
+		case "addImage": return { image: first ?? {} };
+		default: return null;
+	}
+}
+/** Attach the source name to a call, when the shape had one. */
+function nameOf(shape) {
+	return shape.name ? { sourceName: shape.name } : {};
+}
+/**
+* One shape from a **layout's** shape tree as a `SlideMasterObject` — an entry in the
+* `objects` array of a `defineSlideMaster` call.
+*
+* Everything about the shape itself is decided by {@link shapeCall}, so a rectangle on a
+* layout is transcribed by the same code that transcribes one on a slide and cannot drift
+* from it. Only the *envelope* differs: `objects` is a key-tagged union rather than a method
+* name plus arguments — the same shape `GroupChildProps` takes — which is why this reads as a
+* sibling of {@link asGroupChild}.
+*
+* `notes` must already be a `layoutShapeScope`, so the slide vocabulary this borrows lands
+* under `layout.` and cannot be mistaken for a loss on a slide.
+*
+* Two methods have no variant in the union. `addGroup` never reaches here — the layout walk
+* flattens a group into its children first, since children already carry slide-absolute
+* coordinates. `addTable` genuinely has nowhere to go, and is the one kind this reports as
+* lost.
+*/
+function masterObject(shape, notes, assets) {
+	if (isConnector(shape)) {
+		const scoped = notes.forShape(shape.name || null);
+		if (shape.hidden) {
+			noteHidden(scoped);
+			return null;
+		}
+		return connectorObject(shape, scoped);
+	}
+	const call = shapeCall(shape, notes, assets);
+	if (!call) return null;
+	const shared = commonShapeVariant(call);
+	if (shared) return shared;
+	const [first, second] = call.args;
+	switch (call.method) {
+		case "addChart": {
+			const options = second !== null && typeof second === "object" && !Array.isArray(second) && !isAssetRef(second) ? second : null;
+			const type = options?.["type"];
+			if (type === void 0 || first === void 0) return null;
+			return { chart: compact({
+				type,
+				data: first,
+				opts: options
+			}) ?? {} };
+		}
+		default:
+			notes.forShape(shape.name || null).note("decoration", "dropped", "unwritable", `a ${call.method.replace(/^add/, "").toLowerCase()} on a slide layout has no defineSlideMaster({ objects }) variant — the union covers a chart, an image, a shape and a text box — so it is dropped from the layout the output rebuilds`);
+			return null;
+	}
+}
+/**
+* A `Connector` as a `line` shape descriptor, which is the only way one reaches a layout.
+*
+* The alternative to this arm is dropping every connector a layout carries, and in the fixture
+* corpus that is 18 of the 45 shapes every layout actually draws — because PowerPoint's
+* line tool authors a `p:cxnSp`, so a plain horizontal rule under a title is usually a
+* connector rather than a shape. Drawing it as a `line` preset paints the identical stroke.
+*
+* What that costs is the endpoint binding, and on a layout it costs nothing that was working:
+* `a:stCxn`/`a:endCxn` reference shapes in the *layout's* tree, and nothing a slide later puts
+* on top is one of them. The slide-side `addConnector` mapping loses the binding too.
+*
+* It is also better than that mapping in one respect. `addConnector` takes two endpoints and
+* no rotation, so a rotated connector lands along the unrotated diagonal of its box; a shape
+* carries `rotate`, so this keeps it.
+*/
+function connectorObject(shape, notes) {
+	if (!shape.absoluteFrame) return null;
+	if (shape.startConnection || shape.endConnection) notes.note("connector.binding", "dropped", "unsupported", "this connector is bound to shapes on the layout; it is re-authored as a line shape, which paints the same stroke but no longer follows them");
+	return { shape: compact({
+		type: "line",
+		options: compact({
+			...positionOptions(shape, notes),
+			...transformOptions(shape),
+			line: lineOption(shape, notes),
+			shadow: shadowOption(shape, notes),
+			glow: glowOption(shape),
+			objectName: shape.name || void 0
+		}) ?? {}
+	}) ?? {} };
+}
+//#endregion
+//#region src/script/from-read/chrome.ts
+/** Build the chrome IR for a deck. */
+function chromeToIr(pres, notes, assets) {
+	const masters = pres.masters();
+	if (masters.length > 1) notes.note("master.multiple", "flattened", "unsupported", `this deck has ${masters.length} slide masters; the write API models a deck as one shared master with many layouts, so every layout is rebuilt under a single master and only the first master's theme and colour map survive`);
+	const theme = masters[0]?.theme ?? null;
+	recordMasterLosses(masters, theme, notes);
+	return {
+		theme: themeToIr(theme),
+		masters: layoutsToIr(masters, notes, assets)
+	};
+}
+/** The theme's colour scheme and font faces, in `ThemeProps` spelling. */
+function themeToIr(theme) {
+	if (!theme) return {};
+	const scheme = theme.colorScheme;
+	const colors = {};
+	for (const [slot, hex] of Object.entries(scheme)) if (hex !== null) colors[slot] = literalColor(hex);
+	const fonts = theme.fontScheme;
+	return compact({
+		headFontFace: orUndefined(fonts?.major.latin ?? null),
+		bodyFontFace: orUndefined(fonts?.minor.latin ?? null),
+		headFontFaceEA: orUndefined(fonts?.major.ea ?? null),
+		bodyFontFaceEA: orUndefined(fonts?.minor.ea ?? null),
+		headFontFaceCS: orUndefined(fonts?.major.cs ?? null),
+		bodyFontFaceCS: orUndefined(fonts?.minor.cs ?? null),
+		colorScheme: Object.keys(colors).length > 0 ? colors : void 0
+	});
+}
+/** The losses that belong to the master/theme tier as a whole rather than to one layout. */
+function recordMasterLosses(masters, theme, notes) {
+	if (theme && hasFormatScheme(theme.element_)) notes.note("theme.fmtScheme", "approximated", "unread", "the theme's format scheme (a:fmtScheme — the three fill, line and effect style lists a shape's p:style indexes into) has no read accessor and no write-API option, so the output carries Office's default; a shape whose fill or outline came from the theme rather than from its own a:ln keeps its colour but not its width, dash or effect");
+	for (const master of masters) {
+		const root = master.part.dom.documentElement;
+		if (hasTextStyles(root)) notes.note("master.txStyles", "dropped", "unread", "the master's per-level text styles (p:txStyles — the default size, face, colour, indent and bullet of each of the nine list levels) have no read accessor, so placeholder text falls back to PowerPoint's built-in defaults; SlideMasterProps.textStyles could author them if they could be seen");
+		if (hasDecorativeShapes(root)) notes.note("master.decoration", "dropped", "unwritable", "this slide master carries shapes that are not placeholders (a logo, a rule, a background graphic); the read model decodes them (SlideMaster.shapes) and a layout's are re-authored, but a master's cannot be — defineSlideMaster creates a layout under the one shared master, so the master's own shape tree has no write-side counterpart to receive them");
+		const map = master.colorMap;
+		const remapped = Object.entries(DEFAULT_COLOR_MAP).filter(([token, slot]) => map[token] !== slot);
+		if (remapped.length > 0) notes.note("master.colorMap", "dropped", "unwritable", `this master remaps ${remapped.map(([token]) => token).join(", ")} to a different theme slot and the write path always emits the identity map, so every scheme colour that passes through as a token resolves to a different hex than it did in the source`);
+	}
+}
+/**
+* One `defineSlideMaster` descriptor per source layout, in the same gallery order
+* `Presentation.layouts()` reports — which is what lets a slide bind by index.
+*
+* Titles are made unique because they are the lookup key `addSlide({ masterTitle })` matches
+* on, and `p:cSld@name` is not unique: a multi-master deck routinely carries several layouts
+* called "Title and Content", and two `defineSlideMaster` calls sharing a title would make
+* every slide bind to whichever won.
+*/
+function layoutsToIr(masters, notes, assets) {
+	const out = [];
+	const used = /* @__PURE__ */ new Set();
+	let placeholderCount = 0;
+	let placeholderLayouts = 0;
+	const renamed = [];
+	const collided = [];
+	for (const master of masters) for (const layout of master.layouts) {
+		const index = out.length;
+		const flattened = flattenAttributeValue(layout.name);
+		if (flattened !== layout.name) renamed.push(`${JSON.stringify(layout.name)} → ${JSON.stringify(flattened)}`);
+		const base = flattened || `Layout ${index + 1}`;
+		let title = base;
+		for (let suffix = 2; used.has(title); suffix++) title = `${base} (${suffix})`;
+		if (title !== base) collided.push(`${JSON.stringify(base)} → ${JSON.stringify(title)}`);
+		used.add(title);
+		const placeholders = layout.placeholders.length;
+		if (placeholders > 0) {
+			placeholderCount += placeholders;
+			placeholderLayouts++;
+		}
+		const background = backgroundProps(layout.background ?? master.background, notes, assets);
+		const objects = layoutObjects(layout, notes, assets);
+		out.push({
+			layoutIndex: index,
+			props: compact({
+				title,
+				background,
+				objects: objects.length > 0 ? objects : void 0
+			})
+		});
+	}
+	if (collided.length > 0) notes.note("master.nameCollision", "approximated", "unsupported", `${collided.length} layout name(s) are not unique in the source — normally because the deck has several masters, each with its own "Title and Content" — and a layout title here is also the key addSlide({ masterTitle }) binds on, so duplicates cannot both exist. The later ones are suffixed and the slides bound to them follow: ${collided.join("; ")}`);
+	if (renamed.length > 0) notes.note("master.name", "flattened", "unwritable", `${renamed.length} layout name(s) contain a line break or tab, which cannot survive as a layout title: the write path emits the name as a literal XML attribute value rather than a character reference, and XML normalises whitespace in an attribute to spaces. Collapsed here so the emitted script says what the output will contain — ${renamed.join("; ")}`);
+	if (placeholderCount > 0) notes.note("master.placeholders", "dropped", "unsupported", `the ${placeholderCount} placeholder definition(s) across ${placeholderLayouts} slide layout(s) are not reproduced: the write path seeds every slide with each layout placeholder the slide did not populate, and since every source shape is authored here as concrete content rather than into a placeholder, re-declaring them would add an empty shape to every slide rather than a prompt`);
+	return out;
+}
+/**
+* A layout's own shapes as the `objects` of its `defineSlideMaster` call — the bands, rules,
+* wordmarks and footer graphics that make a deck recognisable as somebody's template.
+*
+* **Placeholders are filtered out, not mapped.** They are the other half of a layout's tree and
+* the write path already reproduces them from the far side: `addPlaceholdersToSlideLayouts`
+* seeds every slide with each layout placeholder it did not populate, so re-declaring one here
+* would put an empty ghost shape on every slide bound to the layout (see the module header).
+* The test is a DOM predicate rather than `shape.placeholder`, because only `AutoShape` reports
+* one — see {@link isPlaceholderShape}.
+*
+* **A group is flattened into its children rather than dropped.** `SlideMasterObject` has no
+* `group` variant, and unlike the slide-side `addGroup` mapping this loses nothing visual:
+* `absoluteFrame` already composes an enclosing group's offset, rotation, flips *and* its
+* child-space scaling, so each child lands exactly where the group put it. What goes is the
+* grouping itself — one selectable object in PowerPoint becomes several.
+*
+* Notes are recorded through a {@link layoutShapeScope}, so the slide vocabulary the shared
+* mapper speaks lands under `layout.` and stays attributable to the layout tier. Constructs
+* written below are therefore relative to that prefix.
+*/
+function layoutObjects(layout, notes, assets) {
+	const out = [];
+	collectObjects(layout.shapes, out, layoutShapeScope(notes), assets);
+	return out;
+}
+/** {@link layoutObjects}'s walk, recursing through groups. */
+function collectObjects(shapes, out, notes, assets) {
+	for (const shape of shapes) {
+		if (isPlaceholderShape(shape.element_)) continue;
+		if (isGroupShape(shape)) {
+			notes.forShape(shape.name || null).note("group", "flattened", "unwritable", "defineSlideMaster({ objects }) has no group variant, so this group's children are emitted as loose objects; they land in the same places — the group's offset, rotation, flips and child-space scaling are composed into each child's coordinates — but the layout no longer offers them as one selectable object");
+			collectObjects(shape.shapes, out, notes, assets);
+			continue;
+		}
+		const object = masterObject(shape, notes, assets);
+		if (object !== null) out.push(object);
+	}
+}
+/**
+* Collapse the whitespace an XML attribute value cannot carry.
+*
+* Not a style choice: XML normalises a literal tab, carriage return or line feed inside an
+* attribute value to a space (XML 1.0 §3.3.3), and the write path emits a layout title as a
+* literal rather than as a `&#10;` character reference. So a PowerPoint layout named across
+* two lines — "Abschnitts-⏎überschrift" is a real one, in the German built-in set — comes back
+* with a space either way. Doing it here rather than leaving it to the serializer means the
+* emitted script states the title the output will actually have, and the round trip compares
+* two decks that agree instead of reporting a rename it cannot act on.
+*/
+function flattenAttributeValue(value) {
+	return value.replace(/[\t\r\n]+/g, " ");
+}
+/** A master/layout background reduced to what `BackgroundProps` accepts. */
+function backgroundProps(background, notes, assets) {
+	if (!background || background.type === "none") return void 0;
+	switch (background.type) {
+		case "solid": return background.color ? { color: literalColor(background.color.effectiveHex) } : void 0;
+		case "image": {
+			const asset = background.partName === null ? null : assets.assetFor(background.partName);
+			return asset ? { data: asset } : void 0;
+		}
+		case "themeRef": {
+			const fill = background.resolvedFill;
+			if (fill?.type === "solid" && fill.color) {
+				notes.note("master.background", "flattened", "unwritable", "this layout's background is a theme reference (p:bgRef into the theme's background fill list), which has no write-API option; the colour it currently resolves to is baked in and stops following the theme");
+				return { color: literalColor(fill.color.effectiveHex) };
+			}
+			notes.note("master.background", "dropped", "unwritable", "this layout's background is a theme reference to a non-solid fill, which has no write-API option; the layout is emitted with no background");
+			return;
+		}
+		default:
+			notes.note("master.background", "dropped", "unsupported", `a ${background.type} layout background is not expressible through the write API's background option, so the layout is emitted with no background`);
+			return;
+	}
+}
+//#endregion
+//#region src/script/from-read/transition.ts
+/**
+* The transitions the write API can author, as a lookup.
+*
+* Spelled as a `Record` keyed by `TransitionType` rather than as an array of strings so the
+* compiler polices it in *both* directions: a name the union does not have is rejected here,
+* and a name the union gains without being added here fails to satisfy the record. A plain
+* `Set<string>` would silently drift out of date, and the symptom would be a printed script
+* that does not compile — found by whoever runs it, not by this repository's test suite.
+*/
+const WRITABLE_TYPES = {
+	blinds: true,
+	checker: true,
+	circle: true,
+	comb: true,
+	cover: true,
+	cut: true,
+	diamond: true,
+	dissolve: true,
+	fade: true,
+	newsflash: true,
+	plus: true,
+	pull: true,
+	push: true,
+	random: true,
+	randomBar: true,
+	split: true,
+	strips: true,
+	wedge: true,
+	wheel: true,
+	wipe: true,
+	zoom: true
+};
+/**
+* `true` when the write API has a name for this transition.
+*
+* The namespace check does no work on PowerPoint's own output and is kept anyway. Every one
+* of the 21 modern effect names in the probed table (`conveyor`, `morph`, `vortex`, …) is
+* distinct from every base name, so today the name lookup alone would reach the same verdict
+* — measured, not assumed. But "is this a base ECMA-376 transition" is a question about the
+* *namespace*, and answering it by name would be relying on that disjointness holding for
+* every namespace Microsoft ever adds. The write path emits `p:${type}` unconditionally, so
+* the cost of being wrong is a modern effect silently rewritten as a base one with the same
+* name and no note — a conversion that reports itself as faithful. `script-ir.test.js`
+* authors a `p14:fade` to keep this branch honest, since no fixture can.
+*/
+function isWritable(info) {
+	return info.namespace === "p" && Object.hasOwn(WRITABLE_TYPES, info.type);
+}
+/**
+* Map a slide's transition, recording a note for anything that does not survive.
+*
+* Returns `undefined` both when the slide has no transition and when it has one this
+* library cannot author — the difference between those two is what the note carries.
+*/
+function transitionToIr(slide, notes, assets) {
+	const info = slide.transition;
+	if (!info) return void 0;
+	if (!isWritable(info)) {
+		notes.note("slide.transition", "dropped", "unwritable", `this slide's ${info.namespace === "p" ? "" : `${info.namespace} `}${info.type} transition is not one of the 21 base ECMA-376 transitions the write API can author${info.namespace === "p" ? "" : " — it is one of PowerPoint's modern effects, which have no write-API vocabulary"}, so the regenerated slide advances with no effect`);
+		return;
+	}
+	const sound = soundToIr(slide, info, notes, assets);
+	return {
+		type: info.type,
+		speed: info.speed,
+		...info.durationMs === null ? {} : { durationMs: info.durationMs },
+		...info.advanceOnClick ? {} : { advanceOnClick: false },
+		...info.advanceAfterMs === null ? {} : { advanceAfterMs: info.advanceAfterMs },
+		...Object.keys(info.variant).length > 0 ? { variant: { ...info.variant } } : {},
+		...sound ? { sound } : {}
+	};
+}
+/**
+* The transition's sound (`p:sndAc`), in the two forms OOXML gives it.
+*
+* The stop-previous form is pure structure — no relationship, no media part — so it maps
+* unconditionally. A start sound is an embedded WAV reached through the slide's own
+* relationships, which is the only place in this converter that resolves an `r:embed` by
+* hand: every other media reference arrives already resolved to a partname by the read
+* model's shape accessors, and a transition sound has no shape to hang off.
+*/
+function soundToIr(slide, info, notes, assets) {
+	const sound = info.sound;
+	if (!sound) return void 0;
+	if (sound.form === "stop") return { stopPrevious: true };
+	const partName = soundPartName(slide, sound.embedRid);
+	const asset = partName === null ? null : assets.assetFor(partName);
+	if (!asset) {
+		notes.note("slide.transitionSound", "dropped", "unsupported", `this transition's start sound (${sound.embedRid ?? "no r:embed"}) does not resolve to an audio part in the package, so the regenerated transition is silent`);
+		return;
+	}
+	return {
+		data: asset,
+		...sound.name === null ? {} : { name: sound.name },
+		...sound.loop ? { loop: true } : {}
+	};
+}
+/** Resolve `p:snd@r:embed` to the audio part it names, or `null` when it does not resolve. */
+function soundPartName(slide, embedRid) {
+	if (!embedRid) return null;
+	const relationship = slide.relationships.get(embedRid);
+	if (!relationship || relationship.targetMode === "External") return null;
+	return slide.relationships.resolveTarget(embedRid);
+}
+//#endregion
+//#region src/script/from-read/deck.ts
+/** Default slide size (10" × 7.5") for a deck whose `presentation.xml` declares none. */
+const DEFAULT_SLIDE_SIZE = {
+	widthEmu: 9144e3,
+	heightEmu: 6858e3
+};
+/** Extensions by content type, so an emitted asset filename is one a viewer recognises. */
+const ASSET_EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/bmp": "bmp",
+	"image/webp": "webp",
+	"image/tiff": "tif",
+	"image/x-emf": "emf",
+	"image/x-wmf": "wmf",
+	"image/svg+xml": "svg",
+	"audio/x-wav": "wav",
+	"audio/wav": "wav",
+	"audio/mpeg": "mp3"
+};
+/**
+* Collects media as shapes reference it, assigning each part a stable sequential name.
+*
+* Names are assigned in first-reference order rather than derived from the source part
+* name, so the output is deterministic for a given deck and does not leak whatever the
+* source package happened to call its files. A part referenced twice resolves to one asset.
+*
+* Numbering runs per *kind* (`image1.png`, `image2.png`, `audio1.wav`) rather than over one
+* shared counter. Not cosmetics: the asset name becomes a `const` identifier in the emitted
+* script and a filename in its asset directory, and a transition sound bound to `image7`
+* reads as a bug in the generated source every time anyone opens it.
+*/
+var Assets = class {
+	pres;
+	#byPartName = /* @__PURE__ */ new Map();
+	#assets = [];
+	#counts = /* @__PURE__ */ new Map();
+	constructor(pres) {
+		this.pres = pres;
+	}
+	assetFor(partName) {
+		const existing = this.#byPartName.get(partName);
+		if (existing) return existing;
+		const part = this.pres.opc.part(partName);
+		if (!part) return null;
+		const extension = ASSET_EXTENSIONS[part.contentType] ?? partName.split(".").pop() ?? "bin";
+		const kind = part.contentType.startsWith("audio/") ? "audio" : "image";
+		const index = (this.#counts.get(kind) ?? 0) + 1;
+		this.#counts.set(kind, index);
+		const name = `${kind}${index}.${extension}`;
+		const ref = { $asset: name };
+		this.#byPartName.set(partName, ref);
+		this.#assets.push({
+			name,
+			contentType: part.contentType,
+			bytes: part.bytes
+		});
+		return ref;
+	}
+	contentTypeOf(partName) {
+		return this.pres.opc.part(partName)?.contentType ?? null;
+	}
+	get assets() {
+		return this.#assets;
+	}
+};
+/** Convert a loaded deck into its IR. */
+function readModelToIr(pres) {
+	const collector = new NoteCollector();
+	const assets = new Assets(pres);
+	const size = pres.slideSize;
+	const deckScope = scopeNotes(collector, null);
+	if (!size) deckScope.note("deck.slideSize", "approximated", "unsupported", `this deck declares no slide size, so the output uses the ${DEFAULT_SLIDE_SIZE.widthEmu / 914400}in × ${DEFAULT_SLIDE_SIZE.heightEmu / 914400}in default`);
+	const layouts = layoutGallery(pres);
+	const chrome = chromeToIr(pres, deckScope, assets);
+	const slides = pres.slides.map((slide, index) => slideToIr(slide, index + 1, collector, assets, layouts));
+	return {
+		slideSize: size ? {
+			widthEmu: size.widthEmu,
+			heightEmu: size.heightEmu
+		} : DEFAULT_SLIDE_SIZE,
+		props: deckProps(pres, deckScope),
+		chrome,
+		slides,
+		assets: assets.assets,
+		fidelity: collector.notes
+	};
+}
+/**
+* Deck properties, reduced to the five `docProps` fields the write API sets. The other
+* seven the read model exposes have no setter — they survive anyway in a template-anchored
+* output, since the source deck itself becomes the template, so this is only a loss for a
+* standalone one.
+*/
+function deckProps(pres, notes) {
+	const core = pres.coreProperties;
+	if ([
+		"keywords",
+		"description",
+		"category",
+		"contentStatus",
+		"lastModifiedBy"
+	].some((key) => core[key] !== void 0)) notes.note("deck.docProps", "dropped", "unwritable", "only title, author, company, subject and revision have write-API setters; keywords, description, category, content status and last-modified-by have none");
+	return compact({
+		title: core.title,
+		author: core.creator,
+		subject: core.subject,
+		revision: core.revision
+	}) ?? {};
+}
+/**
+* The deck's layouts keyed by partname, each resolved to what a printer needs to bind to
+* it: its gallery position and whether its name identifies it on its own.
+*
+* Built once per deck rather than per slide — `layouts()` walks every master's layout list,
+* and the uniqueness question is about the gallery as a whole, so asking it per slide would
+* be both quadratic and unable to see layouts no slide happens to use.
+*/
+function layoutGallery(pres) {
+	const handles = pres.layouts();
+	const nameCounts = /* @__PURE__ */ new Map();
+	for (const handle of handles) nameCounts.set(handle.name, (nameCounts.get(handle.name) ?? 0) + 1);
+	return new Map(handles.map((handle, index) => [handle.partName, {
+		name: handle.name,
+		index,
+		nameIsUnique: (nameCounts.get(handle.name) ?? 0) === 1
+	}]));
+}
+function slideToIr(slide, number, collector, assets, layouts) {
+	const notes = scopeNotes(collector, number);
+	const layoutPartName = slide.layout?.partName;
+	const base = {
+		number,
+		layout: (layoutPartName === void 0 ? void 0 : layouts.get(layoutPartName)) ?? null,
+		hidden: slide.hidden,
+		...slide.name ? { name: slide.name } : {},
+		...backgroundOf(slide, notes),
+		...notesOf(slide, notes)
+	};
+	const transition = transitionToIr(slide, notes, assets);
+	const carried = hasUnwritableContent(slide);
+	if (carried) notes.note("slide.carried", "flattened", "unwritable", "this slide holds a graphic frame the write API cannot author (an extended chart, a SmartArt diagram, an OLE object or ink); a printer that can copy the source slide does so instead of transcribing it, so it renders correctly but the emitted script does not describe its contents. The per-shape note beside this one says which construct forced the copy");
+	const calls = [];
+	for (const shape of slide.shapes) {
+		const call = shapeCall(shape, notes, assets);
+		if (call) calls.push(call);
+	}
+	recordAnimationLoss(slide, notes);
+	return {
+		...base,
+		...transition ? { transition } : {},
+		source: carried ? "carried" : "authored",
+		calls
+	};
+}
+/**
+* `true` when the slide holds something with no write-API expression at all, forcing a
+* carried slide. Descends into groups, since a group can host a graphic frame.
+*
+* Membership comes from {@link unwritableFramePayload}, which `graphicFrameCall` also uses to
+* pick its note — one enumeration, so the two cannot drift apart again. This test named
+* extended charts alone until then, which is why a slide holding SmartArt (or an OLE object,
+* or ink) was transcribed as `authored` and rendered with a hole where the graphic had been.
+*/
+function hasUnwritableContent(slide) {
+	const check = (shapes) => shapes.some((shape) => {
+		if (isGroupShape(shape)) return check(shape.shapes);
+		return isGraphicFrame(shape) && unwritableFramePayload(shape) !== null;
+	});
+	return check(slide.shapes);
+}
+function backgroundOf(slide, notes) {
+	const background = slide.background;
+	if (!background || background.source !== "slide") return {};
+	switch (background.type) {
+		case "solid": return background.color ? { background: compact({ color: background.color.effectiveHex.replace(/^#/, "").toUpperCase() }) } : {};
+		case "none": return {};
+		default:
+			notes.note("slide.background", "dropped", "unsupported", `a ${background.type} slide background is not expressible through the write API's background option, so the slide takes its layout's background`);
+			return {};
+	}
+}
+function notesOf(slide, notes) {
+	const text = slide.notesText;
+	if (!text) return {};
+	const frame = slide.notesTextFrame;
+	if (frame && frame.paragraphs.some((paragraph) => paragraph.runs.some((run) => run.bold || run.italic))) notes.note("notes.formatting", "flattened", "unsupported", "speaker notes carry as plain text; per-run formatting and the notes slide's own placeholder geometry do not");
+	return { notesText: text };
+}
+/**
+* Build animations, which live in a slide-scoped `p:timing` element rather than in any
+* shape's subtree.
+*
+* The transition next door used to be recorded here for the same reason and is now mapped
+* instead (`from-read/transition.ts`), which leaves this the one genuinely slide-scoped
+* loss: there is no structural reader for `p:timing` at all, only spid manipulation for the
+* deck-to-deck import path, so a build sequence is invisible to this converter.
+*/
+function recordAnimationLoss(slide, notes) {
+	if (slide.hasAnimations) notes.note("slide.animation", "dropped", "unread", "build animations have no structural reader (p:timing is only manipulated by spid for the deck-to-deck import path), so every shape on this slide lands static");
+}
+//#endregion
+//#region src/script/print/literal.ts
+/**
+* {@link IrValue} → TypeScript source text.
+*
+* This module is deliberately the dumbest part of the subsystem. It knows nothing about
+* decks, shapes, or units — only how a value is spelled. Every semantic decision was made
+* upstream in the read half, which is what lets the printed text be checked by comparing
+* IRs rather than by reading source: if this file were allowed to interpret, the same
+* construct could mean two things depending on which half you asked.
+*
+* Two consequences worth stating, because they are easy to erode later:
+*
+* - **Numbers are printed, not reformatted.** The IR already holds geometry either as a
+*   `` `${n}emu` `` string (exact) or as a six-decimal inch number (the proven minimum for
+*   an EMU-exact round-trip). Rounding here to suppress `0.5000000001`-style noise would
+*   turn a cosmetic problem into a real geometry loss, so `printNumber` only refuses
+*   values JavaScript cannot spell back.
+* - **Layout is a function of the value alone.** Whether an object prints on one line or
+*   several depends only on its rendered width, never on where it came from, so the same
+*   deck prints byte-identical text every time.
+*/
+/** Matches `.oxfmtrc.jsonc`: `printWidth: 120`. */
+const MAX_WIDTH = 120;
+/**
+* Columns a tab is assumed to occupy when measuring against {@link MAX_WIDTH}. The
+* formatter's default `tabWidth`, since the repo sets `useTabs` but not `tabWidth`.
+*/
+const TAB_COLUMNS = 2;
+/** A bare object key needs no quotes only if it is a plain identifier. */
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* A string literal in the repo's style (`singleQuote: true`).
+*
+* Deck text is arbitrary user content, so every case below is reachable in practice: a
+* quote, a backslash, a hard line break inside a run. `JSON.stringify` would handle those
+* correctly — it is avoided here for the quote style, not for correctness.
+*/
+function printString(value) {
+	let out = "'";
+	for (const char of value) switch (char) {
+		case "\\":
+			out += "\\\\";
+			break;
+		case "'":
+			out += "\\'";
+			break;
+		case "\n":
+			out += "\\n";
+			break;
+		case "\r":
+			out += "\\r";
+			break;
+		case "	":
+			out += "\\t";
+			break;
+		default: {
+			const code = char.codePointAt(0) ?? 0;
+			out += code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233 ? "\\u" + code.toString(16).padStart(4, "0") : char;
+		}
+	}
+	return `${out}'`;
+}
+/**
+* A number literal. `String` gives the shortest text that reads back as the same double,
+* which is exactly the guarantee needed: the printed script must produce the same value the
+* IR held. Non-finite values cannot satisfy that (`NaN` and `Infinity` are identifiers, not
+* literals) and never reach here from a well-formed IR, so they throw rather than emit
+* source that would not run.
+*/
+function printNumber(value) {
+	if (!Number.isFinite(value)) throw new InvalidOptionError("script/non-finite-literal", `Cannot print a non-finite number: ${value}`);
+	return String(value);
+}
+/** An object key, bare when it is a plain identifier and quoted when it is not. */
+function printKey(key) {
+	return IDENTIFIER.test(key) ? key : printString(key);
+}
+/** The value on a single line, however long that line comes out. */
+function inline(value, asset) {
+	if (value === null) return "null";
+	if (typeof value === "boolean") return String(value);
+	if (typeof value === "number") return printNumber(value);
+	if (typeof value === "string") return printString(value);
+	if (isAssetRef(value)) return asset(value);
+	if (Array.isArray(value)) return `[${value.map((item) => inline(item, asset)).join(", ")}]`;
+	const keys = Object.keys(value);
+	if (keys.length === 0) return "{}";
+	return `{ ${keys.map((key) => `${printKey(key)}: ${inline(value[key], asset)}`).join(", ")} }`;
+}
+/**
+* The value as source text, broken across lines only where it would otherwise overflow
+* {@link MAX_WIDTH}.
+*
+* `indentLevel` is the depth the value *starts* at, so a caller that has already written a
+* prefix (`slide1.addText(`) passes the level its closing brace should line up with.
+*/
+function printValue(value, indentLevel, asset) {
+	const flat = inline(value, asset);
+	if (indentLevel * TAB_COLUMNS + flat.length <= MAX_WIDTH) return flat;
+	const pad = "	".repeat(indentLevel);
+	const inner = "	".repeat(indentLevel + 1);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		return `[\n${value.map((item) => `${inner}${printValue(item, indentLevel + 1, asset)},`).join("\n")}\n${pad}]`;
+	}
+	if (typeof value === "object" && value !== null && !isAssetRef(value)) {
+		const keys = Object.keys(value);
+		if (keys.length === 0) return "{}";
+		return `{\n${keys.map((key) => `${inner}${printKey(key)}: ${printValue(value[key], indentLevel + 1, asset)},`).join("\n")}\n${pad}}`;
+	}
+	return flat;
+}
+/**
+* A call's argument list, either inline after `prefix` or one argument per line.
+*
+* The decision is made on the *whole* call rather than per argument, so a call either reads
+* as one line or as a list — never as a short first argument followed by a hanging brace,
+* which is what a per-argument rule produces.
+*/
+function printArguments(prefix, args, indentLevel, asset) {
+	const pad = "	".repeat(indentLevel);
+	const flat = `${pad}${prefix}(${args.map((arg) => inline(arg, asset)).join(", ")})`;
+	if (indentLevel * TAB_COLUMNS + flat.length - pad.length <= MAX_WIDTH) return flat;
+	const inner = "	".repeat(indentLevel + 1);
+	return `${pad}${prefix}(\n${args.map((arg) => `${inner}${printValue(arg, indentLevel + 1, asset)}`).join(",\n")}\n${pad})`;
+}
+/**
+* Apply the defaults both printers share.
+*
+* `templatePath` is deliberately not here: only the template-anchored tier has one, and that
+* difference is the whole reason there are two printers.
+* @param options - the caller's options, any of which may be absent
+*/
+function resolvePrintOptions(options) {
+	return {
+		outputPath: options.outputPath ?? "./output.pptx",
+		assetDir: (options.assetDir ?? "./assets").replace(/\/$/, ""),
+		assetMode: options.assets ?? "file",
+		packageName: options.packageName ?? "@shbernal/ts-pptx"
+	};
+}
+/** Width the header comment's prose wraps at, leaving room for the ` * ` prefix. */
+const COMMENT_WIDTH = 110;
+/**
+* A stable JavaScript identifier per asset.
+*
+* Derived from the asset's own name rather than its index, so a reader can match a `const`
+* in the script against a file in the asset directory. The dedupe suffix is defensive: the
+* read half currently names assets `image1.png`, `image2.jpg`, … which cannot collide after
+* the extension is stripped, but nothing in the IR contract promises that.
+*/
+function assetIdentifiers(ir) {
+	const out = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	for (const asset of ir.assets) {
+		const base = asset.name.replace(/\.[^.]*$/, "").replace(/[^A-Za-z0-9_$]/g, "_");
+		let identifier = /^[A-Za-z_$]/.test(base) ? base : `_${base}`;
+		let suffix = 2;
+		while (used.has(identifier)) identifier = `${base}_${suffix++}`;
+		used.add(identifier);
+		out.set(asset.name, identifier);
+	}
+	return out;
+}
+/** Resolve an {@link AssetRef} to the `const` identifier standing for its bytes. */
+function assetPrinter(identifiers) {
+	return (ref) => {
+		const identifier = identifiers.get(ref.$asset);
+		if (!identifier) throw new InvalidOptionError("script/unresolved-asset-reference", `Asset reference ${ref.$asset} has no entry in DeckIr.assets`);
+		return identifier;
+	};
+}
+/**
+* One `const` per asset, each holding a complete `data:` URI.
+*
+* Both modes bind the same *kind* of value — a data URI string — so the call sites are
+* identical and `addImage`'s `data` option is used either way. Only where the bytes come
+* from changes. Rewriting the option key to `path` in file mode would have the printer
+* reshaping an argument, which is precisely the thing that keeps the IR checkable.
+*/
+function printAssetBindings(ir, identifiers, assetDir, mode, inlineComment = "// Media bytes, inlined so this script needs no files but its template.") {
+	if (ir.assets.length === 0) return [];
+	const lines = mode === "file" ? ["// Media bytes, loaded from the asset directory beside this script."] : [inlineComment];
+	for (const asset of ir.assets) {
+		const identifier = identifiers.get(asset.name);
+		if (!identifier) continue;
+		if (mode === "file") {
+			const path = printString(`${assetDir}/${asset.name}`);
+			lines.push(`const ${identifier} = \`data:${asset.contentType};base64,\${(await readFile(here(${path}))).toString('base64')}\``);
+		} else lines.push(`const ${identifier} = ${printString(`data:${asset.contentType};base64,${toBase64(asset.bytes)}`)}`);
+	}
+	return lines;
+}
+/** Base64 without `Buffer`, matching the rest of the library's isomorphic media handling. */
+function toBase64(bytes) {
+	let binary = "";
+	const CHUNK = 32768;
+	for (let i = 0; i < bytes.length; i += CHUNK) binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+	return btoa(binary);
+}
+/**
+* One slide: a comment, the statement that creates it, then its slide-level properties and
+* its calls in z-order.
+*
+* `comment` and `construction` are the tier's business — one binds a layout by name at append
+* time, the other names a master up front — and everything after them is not.
+*/
+function printSlide(slide, parts, collector, printAsset) {
+	const notes = scopeNotes(collector, slide.number);
+	const identifier = `slide${slide.number}`;
+	const lines = [
+		"",
+		`// ${parts.comment}`,
+		`const ${identifier} = ${parts.construction}`
+	];
+	if (slide.name !== void 0) notes.note("slide.name", "dropped", "unwritable", `the slide's own name (p:cSld@name, here ${JSON.stringify(slide.name)}) has no public write-API setter, so the generated slide is unnamed`);
+	if (slide.hidden) lines.push(`${identifier}.hidden = true`);
+	if (slide.background) lines.push(`${identifier}.background = ${printValue(slide.background, 0, printAsset)}`);
+	if (slide.transition) lines.push(`${identifier}.transition = ${printValue(asIrValue(slide.transition), 0, printAsset)}`);
+	if (slide.notesText !== void 0) lines.push(printArguments(`${identifier}.addNotes`, [slide.notesText], 0, printAsset));
+	for (const call of slide.calls) {
+		if (call.sourceName) lines.push(`// ${call.sourceName.replace(/\s+/g, " ")}`);
+		lines.push(printArguments(`${identifier}.${call.method}`, call.args, 0, printAsset));
+	}
+	return lines;
+}
+/** The banner comment: `prose` as written, then every loss that applies to this output. */
+function header(prose, notes) {
+	const lines = [...prose, ""];
+	if (notes.length === 0) lines.push("FIDELITY: nothing was lost that this converter can detect.");
+	else {
+		lines.push(`FIDELITY: ${notes.length} declared loss(es). Everything not listed here is expected to`, "survive unchanged; a difference that is not in this list is a defect, not a caveat.", "");
+		for (const [scope, group] of groupNotes(notes)) {
+			lines.push(`${scope}:`);
+			for (const note of group) {
+				const where = note.shapeName ? ` (${note.shapeName})` : "";
+				lines.push(...wrap(`- ${note.construct}${where} [${note.disposition}, ${note.cause}] — ${note.detail}`, COMMENT_WIDTH, "  "));
+			}
+		}
+	}
+	return [
+		"/*",
+		...lines.map((line) => line ? ` * ${line}` : " *"),
+		" */"
+	].join("\n");
+}
+/** Notes bucketed by slide, in deck order, so a reader meets them the way they meet the deck. */
+function groupNotes(notes) {
+	const deckLevel = notes.filter((note) => note.slideNumber === null);
+	const bySlide = /* @__PURE__ */ new Map();
+	for (const note of notes) {
+		if (note.slideNumber === null) continue;
+		const existing = bySlide.get(note.slideNumber);
+		if (existing) existing.push(note);
+		else bySlide.set(note.slideNumber, [note]);
+	}
+	const out = [];
+	if (deckLevel.length > 0) out.push(["Deck", deckLevel]);
+	for (const number of [...bySlide.keys()].sort((a, b) => a - b)) out.push([`Slide ${number}`, bySlide.get(number) ?? []]);
+	return out;
+}
+/** Wrap prose to `width`, indenting every line after the first by `continuation`. */
+function wrap(text, width, continuation) {
+	const words = text.split(/\s+/).filter(Boolean);
+	const lines = [];
+	let current = "";
+	for (const word of words) {
+		const candidate = current ? `${current} ${word}` : `${continuation}${word}`;
+		if (current && candidate.length > width) {
+			lines.push(current);
+			current = `${continuation}${word}`;
+		} else current = current ? candidate : word;
+	}
+	if (current) lines.push(current);
+	return lines;
+}
+/**
+* Close out a printed script: the accumulated lines as one module source, plus the
+* asset side-car the caller has to write beside it.
+*
+* Both tiers end this way, and the `assetMode` test is the whole reason it is worth
+* naming. In `'inline'` mode the bytes are already in {@link PrintedScript.code} as
+* `data:` literals, so the map must come back **empty** — a tier that returned them
+* anyway would have its caller write every image to disk as well, and the script would
+* ignore the files it was handed.
+* @param {string[]} lines - the script's lines, in order
+* @param {DeckIr} ir - the IR being printed, for its assets
+* @param {AssetMode} assetMode - how image bytes reach the script
+* @param {FidelityNote[]} notes - the losses that apply to this output
+* @returns {PrintedScript} the finished script
+*/
+function printedScript(lines, ir, assetMode, notes) {
+	return {
+		code: lines.join("\n"),
+		assets: new Map(assetMode === "file" ? ir.assets.map((asset) => [asset.name, asset.bytes]) : []),
+		notes
+	};
+}
+//#endregion
+//#region src/script/print/script.ts
+/**
+* Constructs the IR declares lost that a template-anchored output keeps anyway.
+*
+* Document properties are the obvious case: the read half notes that only five of the twelve
+* have write-API setters, which is true and matters for a standalone output — but this tier
+* never authors them at all. They ride in the template, untouched, all twelve of them.
+*
+* The whole of the chrome is the same story on a larger scale. The theme's format scheme, the
+* master's text styles and colour map, the layouts' decoration and placeholder definitions —
+* every one of them is a genuine loss for a script that has to rebuild the deck's design, and
+* none of them is touched here, because the design *is* the template. A caveat that does not
+* apply to the output in front of you is worse than no caveat: it teaches the reader to skim
+* the ones that do.
+*
+* Alongside this list, {@link isTemplateCarried} drops every note under
+* {@link LAYOUT_NOTE_PREFIX}. Those are the per-shape losses of re-authoring a layout's
+* decoration, recorded in the slide vocabulary because the shape mapper is shared — and every
+* one of them is about a layout, which this tier does not rebuild.
+*/
+const TEMPLATE_CARRIED_CONSTRUCTS = /* @__PURE__ */ new Set([
+	"deck.docProps",
+	"master.background",
+	"master.colorMap",
+	"master.decoration",
+	"master.multiple",
+	"master.name",
+	"master.nameCollision",
+	"master.placeholders",
+	"master.txStyles",
+	"theme.fmtScheme"
+]);
+/** `true` when the source deck carries this loss through untouched, so this tier does not have it. */
+function isTemplateCarried(construct) {
+	return TEMPLATE_CARRIED_CONSTRUCTS.has(construct) || construct.startsWith("layout.");
+}
+/** Turn a deck IR into a runnable, template-anchored TypeScript module. */
+function printScript(ir, options = {}) {
+	const templatePath = options.templatePath ?? "./template.pptx";
+	const { outputPath, assetDir, assetMode, packageName } = resolvePrintOptions(options);
+	const collector = new NoteCollector();
+	const assetNames = assetIdentifiers(ir);
+	const body = printSlides$1(ir, collector, assetPrinter(assetNames));
+	const needsSource = ir.slides.some((slide) => slide.source === "carried");
+	const needsFallbackLayout = ir.slides.some((slide) => slide.source === "authored" && slide.layout === null);
+	const notes = [...ir.fidelity.filter((note) => !isTemplateCarried(note.construct)), ...collector.notes];
+	const lines = [
+		header([
+			"Generated from a .pptx by ts-pptx/script.",
+			"",
+			"Template-anchored: the source deck is reused as the template, so its slide masters,",
+			"layouts, theme and document properties are the originals, byte for byte. Only the",
+			"slide content below was rebuilt through the public write API.",
+			"",
+			`Expects ${templatePath} (the source deck, unmodified) beside this file${assetMode === "file" && ir.assets.length > 0 ? `, plus ${ir.assets.length} media file(s) in ${assetDir}` : ""}.`,
+			`Writes ${outputPath}. Needs an ESM context — it uses top-level await.`
+		], notes),
+		"",
+		"import { readFile, writeFile } from 'node:fs/promises'",
+		"import { fileURLToPath } from 'node:url'",
+		`import TsPptx from ${printString(packageName)}`,
+		`import { Presentation } from ${printString(`${packageName}/read`)}`,
+		"",
+		"/** Resolve a path against this script rather than against the working directory. */",
+		"const here = (name: string): string => fileURLToPath(new URL(name, import.meta.url))",
+		"",
+		"// The source deck is the template: fromTemplate strips its slides and leaves its masters,",
+		"// layouts, theme and document properties exactly as they were.",
+		`const deck = await Presentation.fromTemplate(here(${printString(templatePath)}))`
+	];
+	if (needsSource) lines.push("", "// A second, unstripped handle on the same file, for the slides copied verbatim.", `const source = await Presentation.load(here(${printString(templatePath)}))`);
+	if (needsFallbackLayout) lines.push("", "// Some source slides resolved no layout of their own; they bind to the first one.", "const fallbackLayout = deck.layouts()[0]", "if (!fallbackLayout) throw new Error('the template declares no slide layouts to bind to')");
+	const assetLines = printAssetBindings(ir, assetNames, assetDir, assetMode);
+	if (assetLines.length > 0) lines.push("", ...assetLines);
+	lines.push("", "/**", " * A generator sized to the template. appendSlides compares slide sizes exactly and", " * throws when they differ, so the inches here must round-trip to the source EMU.", " */", "function generator(): TsPptx {", "	const pptx = new TsPptx()", `\tpptx.defineLayout({ name: 'source', width: ${inches(ir.slideSize.widthEmu)}, height: ${inches(ir.slideSize.heightEmu)} })`, "	pptx.layout = 'source'", "	return pptx", "}", ...body, "", `await writeFile(here(${printString(outputPath)}), await deck.save())`, "");
+	return printedScript(lines, ir, assetMode, notes);
+}
+/**
+* The slide statements, batched into generators, preceded by the layout handles they bind to.
+*
+* A batch ends when the layout changes or a carried slide interrupts, because
+* `appendSlides` binds one layout per call and a carried slide is not authored at all.
+*
+* Every layout `const` is hoisted above the first statement rather than emitted where it is
+* first used. `deck.layouts()` is a snapshot of the gallery, and `importSlide` — the call a
+* carried slide prints — grows that gallery with the source slide's own layout and master.
+* Resolving a handle after one has run is therefore resolving against a deck that has already
+* moved; capturing every handle up front is the only ordering that cannot.
+*/
+function printSlides$1(ir, collector, printAsset) {
+	const declarations = [];
+	const lines = [];
+	let batch = [];
+	let generatorIndex = 0;
+	const declaredLayouts = /* @__PURE__ */ new Set();
+	const flush = () => {
+		if (batch.length === 0) return;
+		const first = batch[0];
+		if (!first) return;
+		const name = `gen${++generatorIndex}`;
+		lines.push("", `const ${name} = generator()`);
+		for (const slide of batch) lines.push(...printAuthoredSlide(slide, name, collector, printAsset));
+		lines.push("", printAppend(name, first, collector, declaredLayouts, declarations));
+		batch = [];
+	};
+	for (const slide of ir.slides) {
+		if (slide.source === "carried") {
+			flush();
+			lines.push("", `// Slide ${slide.number} — copied from the source deck rather than rebuilt; see the fidelity notes.`, `deck.importSlide(source, ${slide.number - 1})`);
+			continue;
+		}
+		const previous = batch[0];
+		if (previous && previous.layout?.index !== slide.layout?.index) flush();
+		batch.push(slide);
+	}
+	flush();
+	return declarations.length > 0 ? [
+		"",
+		...declarations,
+		...lines
+	] : lines;
+}
+/**
+* The `appendSlides` call closing a batch, binding by layout name where that is
+* unambiguous and by gallery position where it is not. Any handle it needs is appended to
+* `declarations`, which the caller hoists above every statement.
+*
+* Binding by name is preferred because it survives being re-pointed at a different
+* template and because it is legible. But `appendSlides` *throws* on an ambiguous name
+* rather than picking one, so the positional form resolves the case where the name does not
+* identify one layout: a multi-master deck that repeats layout names.
+*
+* A carried slide used to demote every binding in the script to a position too, because its
+* `importSlide` copied the source layout in under a second name-alike entry. `importSlide`
+* now binds to the chrome the template already holds (`read/api/ops/part-reuse.ts`), and
+* this deck's template *is* the source file, so the gallery no longer grows and the names
+* stay unambiguous.
+*/
+function printAppend(generatorName, first, collector, declared, declarations) {
+	const layout = first.layout;
+	if (!layout) return `await deck.appendSlides(${generatorName}, { layout: fallbackLayout })`;
+	if (layout.nameIsUnique) return `await deck.appendSlides(${generatorName}, { layout: ${printString(layout.name)} })`;
+	scopeNotes(collector, first.number).note("slide.layout", "approximated", "unsupported", `more than one layout in the source deck is named ${JSON.stringify(layout.name)}, so this slide binds to gallery position ${layout.index} instead; re-pointing the script at a different template will not track the name`);
+	const identifier = `layout${layout.index}`;
+	if (!declared.has(layout.index)) {
+		declared.add(layout.index);
+		declarations.push(`const ${identifier} = deck.layouts()[${layout.index}] // ${JSON.stringify(layout.name)}`, `if (!${identifier}) throw new Error('the template has no layout at position ${layout.index}')`);
+	}
+	return `await deck.appendSlides(${generatorName}, { layout: ${identifier} })`;
+}
+/** One authored slide, plus the layout-binding note this tier is responsible for. */
+function printAuthoredSlide(slide, generatorName, collector, printAsset) {
+	if (slide.layout === null) scopeNotes(collector, slide.number).note("slide.layout", "approximated", "unsupported", "this slide resolves no layout of its own, so it binds to the template's first layout; that governs theme and clrMap resolution, which may differ from the source");
+	if (slide.transition?.sound?.data !== void 0) scopeNotes(collector, slide.number).note("slide.transitionSound", "dropped", "unsupported", "this transition's start sound is dropped: the append path this tier rides does not register a transition's embedded audio part, so the sound does not reach the template. The assignment below still spells it out, and the WAV still ships beside the script, because both describe the source deck faithfully and would take effect the day the append path carries them — but this output is silent. Print the standalone variant to keep the sound");
+	const layout = slide.layout === null ? "no layout" : `layout ${JSON.stringify(slide.layout.name)}`;
+	return printSlide(slide, {
+		comment: `Slide ${slide.number} — ${layout}`,
+		construction: `${generatorName}.addSlide()`
+	}, collector, printAsset);
+}
+//#endregion
+//#region src/script/print/standalone.ts
+/**
+* Notes the IR declares that do not describe *this* output.
+*
+* Only one, and it is the mirror of the other tier's list. `slide.carried` says a slide will
+* be copied from the source package rather than transcribed; there is no source package here,
+* so the slide is transcribed and the construct that made it uncarryable has already recorded
+* its own note. Reporting both would double-count one loss and describe a behaviour this
+* script does not have.
+*/
+const NOT_APPLICABLE = /* @__PURE__ */ new Set(["slide.carried"]);
+/** Turn a deck IR into a runnable TypeScript module that needs no template. */
+function printStandaloneScript(ir, options = {}) {
+	const { outputPath, assetDir, assetMode, packageName } = resolvePrintOptions(options);
+	const collector = new NoteCollector();
+	const assetNames = assetIdentifiers(ir);
+	const printAsset = assetPrinter(assetNames);
+	const masters = printMasters(ir, collector, printAsset);
+	const body = printSlides(ir, collector, printAsset);
+	const notes = [...ir.fidelity.filter((note) => !NOT_APPLICABLE.has(note.construct)), ...collector.notes];
+	const needsReadFile = assetMode === "file" && ir.assets.length > 0;
+	const lines = [
+		header([
+			"Generated from a .pptx by ts-pptx/script.",
+			"",
+			`Standalone: this script needs nothing but ${packageName}${needsReadFile ? ` and ${ir.assets.length} media file(s) in ${assetDir}` : ""}.`,
+			"The deck's theme, layouts and slide content are all re-authored through the public write",
+			"API, so every one of them is editable here — and the parts of the original design the read",
+			"model cannot see are gone. They are listed below. For a byte-identical design at the cost",
+			"of shipping the source deck alongside the script, print the template-anchored variant",
+			"instead.",
+			"",
+			`Writes ${outputPath}. Needs an ESM context — it uses top-level await.`
+		], notes),
+		"",
+		...needsReadFile ? ["import { readFile } from 'node:fs/promises'"] : [],
+		"import { fileURLToPath } from 'node:url'",
+		`import TsPptx from ${printString(packageName)}`,
+		"",
+		"/** Resolve a path against this script rather than against the working directory. */",
+		"const here = (name: string): string => fileURLToPath(new URL(name, import.meta.url))",
+		"",
+		"const pptx = new TsPptx()",
+		`pptx.defineLayout({ name: 'source', width: ${inches(ir.slideSize.widthEmu)}, height: ${inches(ir.slideSize.heightEmu)} })`,
+		"pptx.layout = 'source'"
+	];
+	const theme = ir.chrome.theme;
+	if (Object.keys(ir.chrome.theme).length > 0) lines.push("", "// The theme's colour scheme and font faces. Its format scheme — the fill, line and effect", "// style lists a shape references through p:style — has no counterpart on either side of the", "// library, so the output carries Office's.", `pptx.theme = ${printValue(theme, 0, printAsset)}`);
+	const props = printDocProps(ir, collector);
+	if (props.length > 0) lines.push("", ...props);
+	const assetLines = printAssetBindings(ir, assetNames, assetDir, assetMode, "// Media bytes, inlined so this script is a single self-contained file.");
+	if (assetLines.length > 0) lines.push("", ...assetLines);
+	if (masters.length > 0) lines.push("", ...masters);
+	lines.push(...body, "", `await pptx.writeFile({ fileName: here(${printString(outputPath)}) })`, "");
+	return printedScript(lines, ir, assetMode, notes);
+}
+/**
+* The document properties the write API can set.
+*
+* Four of the twelve the read model exposes, which is the loss `deck.docProps` already
+* declares — and unlike the template-anchored tier, here it is a real one, because nothing
+* else carries them.
+*/
+function printDocProps(ir, collector) {
+	const entries = Object.entries(ir.props).filter(([, value]) => typeof value === "string");
+	const stamped = [
+		"title",
+		"author",
+		"company",
+		"subject",
+		"revision"
+	].filter((key) => !(key in ir.props));
+	if (stamped.length > 0) scopeNotes(collector, null).note("deck.docPropsDefault", "approximated", "unwritable", `the source deck declares no ${stamped.join(", ")}, and a deck built through the write API is stamped with the library's own value for each in its constructor with no way to unset it, so the output declares ${stamped.length === 1 ? "one" : "these"} the source did not`);
+	if (entries.length === 0) return [];
+	return ["// Document properties. Only these have write-API setters; see the fidelity notes.", ...entries.map(([key, value]) => `pptx.${key} = ${printString(value)}`)];
+}
+/**
+* One `defineSlideMaster` per source layout.
+*
+* The naming is the write API's rather than OOXML's: a `defineSlideMaster` call creates a
+* *layout* under the single shared master, which is the right granularity for a source layout.
+* It carries the layout's name, its background, and its decoration — the bands, rules and
+* wordmarks that make the gallery recognisable rather than a list of blank rectangles. What it
+* still cannot carry is the layout's *placeholder definitions*, and that is a write-path
+* consequence rather than a reading one (see `from-read/chrome.ts`). The name earns its place
+* twice over: it is also what `addSlide({ masterTitle })` binds on.
+*/
+function printMasters(ir, collector, printAsset) {
+	scopeNotes(collector, null, "DEFAULT").note("master.default", "approximated", "unsupported", "the write path seeds every presentation with a blank layout of its own named DEFAULT, and there is no way to remove it, so the output deck's layout gallery carries one extra entry ahead of the source's layouts; nothing binds to it, but it is visible in PowerPoint's layout picker");
+	if (ir.chrome.masters.length === 0) return [];
+	return [
+		"// One master per source layout, carrying its name, background and decoration. What a",
+		"// layout does not bring across is its placeholder definitions; see the fidelity notes.",
+		...ir.chrome.masters.map((master) => printArguments("pptx.defineSlideMaster", [master.props], 0, printAsset))
+	];
+}
+/** Every slide, in source order, each bound to the master its source layout became. */
+function printSlides(ir, collector, printAsset) {
+	const byLayout = /* @__PURE__ */ new Map();
+	for (const master of ir.chrome.masters) byLayout.set(master.layoutIndex, master);
+	const lines = [];
+	for (const slide of ir.slides) {
+		const master = slide.layout === null ? void 0 : byLayout.get(slide.layout.index);
+		const title = typeof master?.props["title"] === "string" ? master.props["title"] : null;
+		if (title === null) scopeNotes(collector, slide.number).note("slide.layout", "approximated", "unsupported", slide.layout === null ? "this slide resolves no layout of its own, so it binds to the write path's default blank layout" : `this slide's source layout (gallery position ${slide.layout.index}) produced no master to bind to, so it binds to the write path's default blank layout`);
+		lines.push(...printSlide(slide, {
+			comment: `Slide ${slide.number} — ${title === null ? "no master" : `master ${JSON.stringify(title)}`}`,
+			construction: title === null ? "pptx.addSlide()" : `pptx.addSlide({ masterTitle: ${printString(title)} })`
+		}, collector, printAsset));
+	}
+	return lines;
+}
+//#endregion
+//#region src/script/verify/canonical.ts
+/**
+* A {@link DeckIr} reduced to the form a round-trip diff can compare.
+*
+* The round trip is `source → IR₁ → script → deck → IR₂`. Comparing those two IRs raw
+* produces thousands of differences, almost none of which are losses: the write path
+* spells out defaults that OOXML leaves implicit, and PowerPoint spells out defaults the
+* write path leaves implicit. Both directions are noise, and drowning the real losses in
+* it is the same as not checking at all.
+*
+* **Every rule here must be an equivalence, not a convenience.** A rule that merely makes
+* the report shorter hides a defect permanently and silently — the exact failure mode this
+* subsystem exists to catch. So each one below cites the OOXML default that makes the
+* explicit and the absent spelling mean the same thing, and none of them drops a value that
+* a viewer could render differently. When in doubt the value stays in and the difference is
+* reported: a noisy report is recoverable, a quiet one is not.
+*
+* Canonicalising is deliberately *symmetric* — it runs over both IRs, so it cannot favour
+* the output. A rule that only made sense in one direction would be an exclusion dressed up
+* as a normalisation.
+*/
+/**
+* Option values that mean exactly what their absence means.
+*
+* Keyed by option name because the IR's argument objects are the write API's own option
+* objects, where a name identifies a construct uniquely — there is no `bold` that means
+* something other than `a:rPr/@b`.
+*
+* Each entry is an OOXML default:
+*
+* - `bold`, `italic` — `a:rPr/@b` / `@i` are `ST_OnOff`, default `false`.
+* - `baseline` — `a:rPr/@baseline` is a percentage, default `0` (no super/subscript).
+* - `breakLine` — not OOXML but the IR's own flat encoding: a run that does not end its
+*   paragraph. The final run of a text frame never carries one, so absent and `false` are
+*   the same statement.
+* - `wrap` — `a:bodyPr/@wrap` defaults to `square`, which the write API spells `true`.
+* - `rotate` — `a:xfrm/@rot` defaults to `0`.
+* - `flipH`, `flipV` — `a:xfrm/@flipH` / `@flipV` default to `false`.
+* - `transparency` — an alpha of 0% removed, i.e. fully opaque, which is also the default
+*   when no `a:alpha` transform is present.
+* - `indentLevel` — `a:p/@lvl` defaults to `0`.
+* - `dashType` — `a:ln`'s dash defaults to `solid` when no `a:prstDash` is present.
+* - `textDirection` — `a:bodyPr/@vert` and `a:tcPr/@vert` both default to `horz`.
+*
+* Line width is deliberately **absent**: `a:ln/@w` defaults to 0 (hairline) while the write
+* path defaults it to 1pt, so those two are not the same line and the difference is real.
+*/
+const IMPLIED_DEFAULTS = {
+	bold: false,
+	italic: false,
+	baseline: 0,
+	breakLine: false,
+	wrap: true,
+	rotate: 0,
+	flipH: false,
+	flipV: false,
+	transparency: 0,
+	indentLevel: 0,
+	dashType: "solid",
+	textDirection: "horz"
+};
+/**
+* `a:bodyPr`'s default insets in inches, in the write API's `[top, right, bottom, left]`
+* order: 45720 EMU (0.05in, 3.6pt) top and bottom, 91440 EMU (0.1in, 7.2pt) left and right.
+* A body that spells them out is inset exactly as one that omits them.
+*/
+const DEFAULT_MARGIN = [
+	.05,
+	.1,
+	.05,
+	.1
+];
+/** Reduce a deck IR to the comparable form. */
+function canonicalDeckIr(ir) {
+	const digests = assetDigests(ir.assets);
+	return {
+		slideSize: ir.slideSize,
+		props: canonicalValue(ir.props, digests),
+		chrome: {
+			theme: canonicalValue(ir.chrome.theme, digests),
+			masters: ir.chrome.masters.map((master) => canonicalValue(master.props, digests))
+		},
+		slides: ir.slides.map((slide) => canonicalSlide(slide, digests))
+	};
+}
+function canonicalSlide(slide, digests) {
+	return {
+		number: slide.number,
+		hidden: slide.hidden,
+		layoutName: slide.layout?.name ?? null,
+		background: slide.background === void 0 ? null : canonicalValue(slide.background, digests),
+		notesText: slide.notesText ?? null,
+		transition: slide.transition === void 0 ? null : canonicalValue(asIrValue(slide.transition), digests),
+		calls: slide.calls.map((call) => {
+			const args = call.args.map((arg) => canonicalValue(arg, digests));
+			return {
+				method: call.method,
+				shapeName: call.sourceName ?? null,
+				containedNames: [...collectObjectNames(args, /* @__PURE__ */ new Set())],
+				args
+			};
+		})
+	};
+}
+/**
+* Every `objectName` value reachable in `value`, at any depth.
+*
+* Exported for the chrome half of the diff, which needs the same list for the same reason: a
+* layout's decoration is an argument to one `defineSlideMaster` call, so a note scoped to one
+* of those shapes has no call of its own to be matched against.
+*/
+function collectObjectNames(value, out) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectObjectNames(item, out);
+		return out;
+	}
+	if (value === null || typeof value !== "object") return out;
+	for (const [key, item] of Object.entries(value)) if (key === "objectName" && typeof item === "string") out.add(item);
+	else collectObjectNames(item, out);
+	return out;
+}
+/**
+* Recursively drop implied defaults and resolve asset references to a content digest.
+*
+* The digest matters more than it looks: assets are named `image1.png`, `image2.png`, … in
+* the order the walk meets them, and the output deck can meet the same bytes in a different
+* order or under a different extension. Comparing names would report a swap that did not
+* happen and, worse, would *miss* one where two images traded places.
+*/
+function canonicalValue(value, digests) {
+	if (isAssetRef(value)) return { $asset: digests.get(value.$asset) ?? `unknown:${value.$asset}` };
+	if (Array.isArray(value)) return value.map((item) => canonicalValue(item, digests));
+	if (value === null || typeof value !== "object") return value;
+	const blankRun = value["text"] === "" && typeof value["options"] === "object" && value["options"] !== null;
+	const out = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (key in IMPLIED_DEFAULTS && item === IMPLIED_DEFAULTS[key]) continue;
+		if (key === "margin" && isDefaultMargin(item)) continue;
+		if (blankRun && key === "options") {
+			const visible = { ...item };
+			delete visible["color"];
+			out[key] = canonicalValue(visible, digests);
+			continue;
+		}
+		out[key] = canonicalValue(item, digests);
+	}
+	return out;
+}
+function isDefaultMargin(value) {
+	return Array.isArray(value) && value.length === DEFAULT_MARGIN.length && value.every((item, index) => item === DEFAULT_MARGIN[index]);
+}
+/**
+* Content digests keyed by asset name, so the same bytes compare equal under any name.
+*
+* FNV-1a rather than a real hash: this identifies bytes for a comparison both sides of
+* which are in hand, so collision resistance against an adversary is not a property it
+* needs, and the library stays free of `node:crypto` and of the isomorphism problem
+* importing it would create.
+*/
+function assetDigests(assets) {
+	const out = /* @__PURE__ */ new Map();
+	for (const asset of assets) {
+		let hash = 2166136261;
+		for (const byte of asset.bytes) {
+			hash ^= byte;
+			hash = Math.imul(hash, 16777619) >>> 0;
+		}
+		out.set(asset.name, `${asset.bytes.length}:${hash.toString(16)}`);
+	}
+	return out;
+}
+//#endregion
+//#region src/script/verify/diff.ts
+/**
+* The round-trip oracle: does the deck a printed script builds match the deck it was read
+* from, everywhere the fidelity notes did not say it would not?
+*
+* **Why a projection diff and not byte identity.** The output package is not the input
+* package and never will be — different rel ids, different shape ids, a regenerated shape
+* tree, `dirty="0"` on every run. Comparing bytes would report a total mismatch for every
+* deck and prove nothing. So the comparison happens one level up, on the IR: run the same
+* `readModelToIr` over the source deck and over the deck the script produced, and compare
+* those. Two decks that produce the same IR make the same write-API calls, which is exactly
+* the claim a generated script makes.
+*
+* **What a note is worth here.** A {@link FidelityNote} says a named construct will not
+* survive. That makes it an *exclusion with a signature*: the difference it predicts is
+* allowed, and every other difference is a defect. Without the notes there would be no way
+* to tell a known cost from a regression, and the check could only ever be a snapshot.
+*
+* **Two blind spots, both stated plainly, because a clean report is worth exactly what its
+* limits allow.**
+*
+* 1. *The reader is shared.* Both IRs come from `readModelToIr`, so a construct the read
+*    model cannot see is missing from both and compares equal. This check cannot certify
+*    anything the read path does not read; `pnpm run read:census` measures that surface, and
+*    the two are complementary rather than overlapping.
+* 2. *The converter need not be injective.* Two different source constructs can map to the
+*    same call, and then the round trip agrees while the deck has changed. Measured, not
+*    hypothetical: the mapper once read an explicit `a:buNone` as the glyph `n`, so a
+*    bulletless paragraph gained a bullet — and because the output's real `n` bullet read
+*    back through the same wrong mapping, the diff was clean. Mutation testing is what
+*    catches that class, and a mutation that survives here is a statement about this
+*    check's reach rather than a mistake in it.
+*
+* A clean report means "nothing the converter can distinguish was lost", never "nothing was
+* lost".
+*/
+/**
+* Options the write path materialises that the source deck left implicit, with the reason
+* each is not judgeable from here.
+*
+* This list exists because `added` differences cannot simply be waved through. Mutation
+* testing settled that: dropping the converter's explicit `valign` left the write path to
+* centre every text body, which showed up as an `added` and nothing failed. So `added` is
+* held to the same standard as the rest — a note must declare it, or its field must appear
+* here with a reason.
+*
+* Every entry names a write-path default whose *correctness* the round trip has no way to
+* assess, because the source's counterpart was inherited and the read model cannot resolve
+* what it was inheriting. That is an honest "unknown", not an "ignore" — each one names a
+* gap in the reader that could be closed later, and teaching the reader to resolve one turns
+* its entry here into a real comparison.
+*/
+const WRITER_DEFAULTS = {
+	fontSize: "runs inherit size from an unread list style; the write path copies the shape size onto each run",
+	options: "a run or cell that carried no options at all in the source now carries the ones below",
+	border: "table cell borders are resolved through the style graph, which the read model cannot separate from the cell’s own",
+	width: "an outline with no explicit width takes the write path’s 1pt default; the source’s came from the unread theme line style",
+	shape: "a shape that inherits its geometry from a layout is emitted as a plain rectangle",
+	type: "a fill or line with no explicit kind takes the write path’s solid default",
+	chartColors: "the write path assigns a series palette; the source’s came from the theme",
+	dataLabelFormatCode: "a data label with no explicit number format takes the write path’s default",
+	showLeaderLines: "leader lines are on by default in the write path",
+	title: "a deck that declares no title gets the write path’s own",
+	author: "a deck that declares no author gets the write path’s own",
+	subject: "a deck that declares no subject gets the write path’s own",
+	company: "a deck that declares no company gets the write path’s own",
+	revision: "a deck that declares no revision gets the write path’s own"
+};
+/**
+* Option names each note construct is a promise about.
+*
+* This table is the fidelity catalogue made mechanical. A note claims a construct will not
+* survive; without a mapping from that claim to the fields it covers, the claim cannot
+* exclude anything and the round trip degenerates into a snapshot.
+*
+* `'*'` covers every difference inside the call it is scoped to — correct only where the
+* note says the whole shape is gone or was copied wholesale, never as a shortcut for a
+* construct whose fields are merely tedious to enumerate.
+*
+* An empty list is meaningful and common: the construct is invisible to the IR on both
+* sides (a slide's build animations, a paragraph's `a:pPr/@marL`, a connector's shape
+* binding), so the note is a caveat for a human and there is nothing here to exclude. Saying
+* so explicitly is what keeps it from looking like an oversight. A construct can leave that
+* state — `slide.transition` was an empty entry until the converter learned to transcribe
+* transitions, and the IR gaining a field is exactly when its note gains a mapping.
+*/
+const NOTE_FIELDS = {
+	"chart.blanks": ["values"],
+	"chart.combo": ["type"],
+	"chart.type": ["type"],
+	"chart.workbook": ["*"],
+	"chartEx.all": ["*"],
+	"connector.binding": [],
+	"connector.line": [
+		"color",
+		"width",
+		"dashType",
+		"beginArrowType",
+		"endArrowType"
+	],
+	"connector.rotation": ["rotate"],
+	"deck.docProps": [],
+	"deck.docPropsDefault": [],
+	"deck.slideSize": ["widthEmu", "heightEmu"],
+	"diagram.all": ["*"],
+	"fill.gradient.path": ["gradient", "fill"],
+	"fill.picture": ["fill", "color"],
+	"fill.picture.geometry": [],
+	"fill.schemeToken": ["fill", "color"],
+	"graphicFrame.unknown": ["*"],
+	"group.child": ["*"],
+	"group.childSpace": [
+		"x",
+		"y",
+		"w",
+		"h",
+		"rotate",
+		"flipH",
+		"flipV"
+	],
+	"group.empty": ["*"],
+	"group.transform": [
+		"rotate",
+		"flipH",
+		"flipV"
+	],
+	"image.data": ["data", "$asset"],
+	"image.recolor": [
+		"duotone",
+		"grayscale",
+		"biLevel",
+		"clrChange"
+	],
+	"image.svg": [
+		"svg",
+		"data",
+		"$asset"
+	],
+	"line.arrowSize": ["beginArrowType", "endArrowType"],
+	"master.background": [
+		"background",
+		"color",
+		"data",
+		"master"
+	],
+	"master.colorMap": [],
+	"master.decoration": [],
+	"master.default": ["master"],
+	"master.multiple": [],
+	"master.name": ["title", "layoutName"],
+	"master.nameCollision": ["title", "layoutName"],
+	"master.placeholders": [],
+	"master.txStyles": [],
+	"theme.fmtScheme": [],
+	"layout.decoration": [],
+	"layout.group": [],
+	"line.dash": ["dashType"],
+	"line.width": ["width"],
+	"media.audioVideo": ["*"],
+	"notes.formatting": ["notesText"],
+	"shape.custGeom.guides": ["points"],
+	"shape.effects": ["shadow", "glow"],
+	"shape.empty": ["*"],
+	"shape.frameInherited": [
+		"x",
+		"y",
+		"w",
+		"h"
+	],
+	"shape.hidden": ["*"],
+	"shape.placeholder": ["placeholder"],
+	"slide.animation": [],
+	"slide.background": [
+		"background",
+		"color",
+		"transparency",
+		"image"
+	],
+	"slide.carried": ["*"],
+	"slide.layout": ["layoutName"],
+	"slide.name": [],
+	"slide.transition": ["transition"],
+	"slide.transitionSound": [
+		"sound",
+		"data",
+		"$asset"
+	],
+	"table.cell.borders.dash": ["border", "diagonal"],
+	"table.cell.headers": [],
+	"table.cell.fill.picture": ["fill"],
+	"table.cell.fill.picture.geometry": [],
+	"table.fill.picture": ["tableFill"],
+	"table.fill.picture.geometry": [],
+	"table.fill.gradient": ["tableFill"],
+	"table.fill.gradient.path": ["tableFill"],
+	"table.cell.fill.gradient": ["fill"],
+	"table.cell.fill.gradient.path": ["fill"],
+	"table.cell.vert": ["textDirection", "vert"],
+	"table.rowAuto": ["rowH"],
+	"table.style": ["tableStyle"],
+	"text.align": ["align"],
+	"text.bullet.numberType": ["bullet"],
+	"text.bullet.sizePt": ["bullet"],
+	"text.bullet.sizePct": ["bullet"],
+	"text.bullet.schemeToken": ["bullet"],
+	"text.bullet.picture": ["bullet"],
+	"text.color.default": ["color"],
+	"text.color.inherited": ["color"],
+	"text.color.schemeToken": ["color"],
+	"text.equation": ["*"],
+	"text.field": ["*"],
+	"text.bullet.glyph": ["bullet"],
+	"text.paraSpaceZero": ["paraSpaceBefore", "paraSpaceAfter"],
+	"text.vert": ["vert"]
+};
+/**
+* Every note construct this table knows how to match, for a test to check against. The
+* `layout.` spellings are not listed — they resolve through {@link isKnownNoteConstruct},
+* which is what a corpus check should use.
+*/
+function knownNoteConstructs() {
+	return Object.keys(NOTE_FIELDS).sort();
+}
+/**
+* Compare the deck a script was generated from against the deck it produced.
+*
+* `notes` must be the set that actually applies to the printed output — `printScript`'s
+* returned `notes`, not `DeckIr.fidelity`. The two differ in both directions: the printer
+* suppresses notes its tier rescues and adds ones its tier causes, so diffing against the
+* IR's own list would both over- and under-exclude.
+*/
+function diffDeckIr(expected, actual, notes) {
+	const differences = [];
+	if (expected.slideSize.widthEmu !== actual.slideSize.widthEmu) differences.push(scalarDifference(0, null, [], "slideSize.widthEmu", "widthEmu", expected.slideSize.widthEmu, actual.slideSize.widthEmu));
+	if (expected.slideSize.heightEmu !== actual.slideSize.heightEmu) differences.push(scalarDifference(0, null, [], "slideSize.heightEmu", "heightEmu", expected.slideSize.heightEmu, actual.slideSize.heightEmu));
+	diffValue(expected.props, actual.props, "props", "props", 0, null, [], differences);
+	diffChrome(expected.chrome, actual.chrome, differences);
+	const slideCount = Math.max(expected.slides.length, actual.slides.length);
+	for (let index = 0; index < slideCount; index++) {
+		const before = expected.slides[index];
+		const after = actual.slides[index];
+		const number = before?.number ?? after?.number ?? index + 1;
+		if (!before || !after) {
+			differences.push({
+				slideNumber: number,
+				shapeName: null,
+				nestedNames: [],
+				path: `slides[${index}]`,
+				field: "*",
+				kind: before ? "lost" : "added",
+				expected: before ? "slide" : "—",
+				actual: after ? "slide" : "—",
+				declaredBy: null
+			});
+			continue;
+		}
+		diffSlide(before, after, differences);
+	}
+	for (const difference of differences) difference.declaredBy = declaringNote(difference, notes);
+	const matched = new Set(differences.map((difference) => difference.declaredBy).filter(Boolean));
+	const accounted = (difference) => difference.declaredBy !== null || difference.kind === "added" && difference.field in WRITER_DEFAULTS;
+	return {
+		slideCount: expected.slides.length,
+		differences,
+		undeclared: differences.filter((difference) => !accounted(difference)),
+		declared: differences.filter((difference) => difference.declaredBy !== null),
+		added: differences.filter((difference) => difference.kind === "added"),
+		unmatchedNotes: notes.filter((note) => !matched.has(note))
+	};
+}
+/**
+* The theme and the layout gallery.
+*
+* Reported at `slideNumber: 0`, the same deck-level bucket the slide size uses, so a
+* deck-scoped note (which carries `slideNumber: null` and matches any slide) can declare one.
+* Masters align by **title**, not by position, for the same reason calls align by shape name:
+* the write path always emits a blank layout of its own at gallery position 0, so positional
+* alignment reports every layout in the deck as renamed and buries the one real difference —
+* that extra layout — under a shift.
+*
+* And, exactly as with shape names, a title is only usable as a key where it is *unique on
+* both sides*. Uniqueness is supposed to be an invariant here — the converter deduplicates
+* titles because a title is also what `addSlide({ masterTitle })` binds on — but keying on it
+* unconditionally makes the check assume the thing it should be testing: a mutation that
+* removed the deduplication left two layouts sharing a title, both expected entries matched
+* the same actual one, and the round trip came back clean. Falling back to position when the
+* key repeats costs nothing when the invariant holds and catches it when it does not.
+*/
+function diffChrome(expected, actual, out) {
+	diffValue(expected.theme, actual.theme, "chrome.theme", "theme", 0, null, [], out);
+	const report = (path, kind, before, after) => {
+		out.push({
+			slideNumber: 0,
+			shapeName: titleOf(before ?? after ?? null),
+			nestedNames: decorationNames(before, after),
+			path,
+			field: "master",
+			kind,
+			expected: brief(before),
+			actual: brief(after),
+			declaredBy: null
+		});
+	};
+	const byTitle = uniqueByTitle(actual.masters);
+	const expectedTitles = uniqueByTitle(expected.masters);
+	const claimed = /* @__PURE__ */ new Set();
+	let cursor = 0;
+	const nextUnclaimed = () => {
+		while (cursor < actual.masters.length) {
+			const candidate = actual.masters[cursor++];
+			if (candidate !== void 0 && !claimed.has(candidate)) return candidate;
+		}
+	};
+	expected.masters.forEach((before, index) => {
+		const title = titleOf(before);
+		const named = title !== null && expectedTitles.has(title) ? byTitle.get(title) : void 0;
+		const after = named !== void 0 && !claimed.has(named) ? named : nextUnclaimed();
+		if (after === void 0) {
+			report(`chrome.masters[${index}]`, "lost", before, void 0);
+			return;
+		}
+		claimed.add(after);
+		diffValue(before, after, `chrome.masters[${index}]`, "master", 0, null, decorationNames(before, after), out);
+	});
+	actual.masters.forEach((after, index) => {
+		if (!claimed.has(after)) report(`chrome.masters[${index}]`, "added", void 0, after);
+	});
+}
+/** Masters keyed by title, keeping only titles that identify exactly one of them. */
+function uniqueByTitle(masters) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const master of masters) {
+		const title = titleOf(master);
+		if (title !== null) counts.set(title, (counts.get(title) ?? 0) + 1);
+	}
+	const out = /* @__PURE__ */ new Map();
+	for (const master of masters) {
+		const title = titleOf(master);
+		if (title !== null && counts.get(title) === 1) out.set(title, master);
+	}
+	return out;
+}
+/**
+* The `objectName`s of every decorative shape in a master's props, taking both sides so a
+* shape that dropped out is still named by the source's.
+*/
+function decorationNames(before, after) {
+	const names = /* @__PURE__ */ new Set();
+	for (const master of [before, after]) if (master !== void 0) collectObjectNames(master, names);
+	return [...names];
+}
+/** A canonical master's `title`, which is its identity across the round trip. */
+function titleOf(master) {
+	if (master === null || typeof master !== "object" || Array.isArray(master)) return null;
+	const title = master["title"];
+	return typeof title === "string" ? title : null;
+}
+function diffSlide(expected, actual, out) {
+	const number = expected.number;
+	const at = (path, field, a, b) => {
+		if (JSON.stringify(a) !== JSON.stringify(b)) out.push(scalarDifference(number, null, [], path, field, a, b));
+	};
+	at("hidden", "hidden", expected.hidden, actual.hidden);
+	at("layoutName", "layoutName", expected.layoutName, actual.layoutName);
+	at("background", "background", expected.background, actual.background);
+	at("notesText", "notesText", expected.notesText, actual.notesText);
+	diffValue(expected.transition, actual.transition, "transition", "transition", number, null, [], out);
+	for (const [before, after] of alignCalls(expected.calls, actual.calls)) {
+		const name = before?.shapeName ?? after?.shapeName ?? null;
+		const nested = [.../* @__PURE__ */ new Set([...before?.containedNames ?? [], ...after?.containedNames ?? []])];
+		const path = `calls[${before ? expected.calls.indexOf(before) : actual.calls.indexOf(after)}]`;
+		if (!before || !after) {
+			out.push({
+				slideNumber: number,
+				shapeName: name,
+				nestedNames: nested,
+				path,
+				field: "*",
+				kind: before ? "lost" : "added",
+				expected: before ? before.method : "—",
+				actual: after ? after.method : "—",
+				declaredBy: null
+			});
+			continue;
+		}
+		if (before.method !== after.method) out.push(scalarDifference(number, name, nested, `${path}.method`, "method", before.method, after.method));
+		diffValue(before.args, after.args, `${path}.args`, "args", number, name, nested, out);
+	}
+}
+/**
+* Pair up the two slides' calls.
+*
+* Position alone is wrong the moment one shape drops out: every later call shifts by one
+* and the report fills with mismatches that are really one missing shape. Shape names
+* survive the round trip (the converter passes `objectName` through), so they are the
+* alignment key wherever they are present and unambiguous, with position as the fallback
+* for unnamed or duplicate-named shapes.
+*/
+function alignCalls(expected, actual) {
+	const usable = (calls) => {
+		const counts = /* @__PURE__ */ new Map();
+		for (const call of calls) {
+			if (call.shapeName === null) continue;
+			counts.set(call.shapeName, (counts.get(call.shapeName) ?? 0) + 1);
+		}
+		const out = /* @__PURE__ */ new Map();
+		for (const call of calls) if (call.shapeName !== null && counts.get(call.shapeName) === 1) out.set(call.shapeName, call);
+		return out;
+	};
+	const byName = usable(actual);
+	const claimed = /* @__PURE__ */ new Set();
+	const pairs = [];
+	let cursor = 0;
+	const nextUnclaimed = () => {
+		while (cursor < actual.length) {
+			const candidate = actual[cursor++];
+			if (candidate && !claimed.has(candidate)) return candidate;
+		}
+		return null;
+	};
+	for (const call of expected) {
+		const named = call.shapeName === null ? void 0 : byName.get(call.shapeName);
+		if (named && !claimed.has(named)) {
+			claimed.add(named);
+			pairs.push([call, named]);
+			continue;
+		}
+		const positional = nextUnclaimed();
+		if (positional) claimed.add(positional);
+		pairs.push([call, positional]);
+	}
+	for (const call of actual) if (!claimed.has(call)) pairs.push([null, call]);
+	return pairs;
+}
+function diffValue(expected, actual, path, field, slideNumber, shapeName, nestedNames, out) {
+	if (expected === actual) return;
+	const kindOf = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+	if (kindOf(expected) !== kindOf(actual)) {
+		out.push(scalarDifference(slideNumber, shapeName, nestedNames, path, field, expected, actual));
+		return;
+	}
+	if (Array.isArray(expected) && Array.isArray(actual)) {
+		const length = Math.max(expected.length, actual.length);
+		for (let index = 0; index < length; index++) {
+			const before = expected[index];
+			const after = actual[index];
+			if (before === void 0 || after === void 0) {
+				out.push({
+					slideNumber,
+					shapeName,
+					nestedNames,
+					path: `${path}[${index}]`,
+					field,
+					kind: before === void 0 ? "added" : "lost",
+					expected: brief(before),
+					actual: brief(after),
+					declaredBy: null
+				});
+				continue;
+			}
+			diffValue(before, after, `${path}[${index}]`, field, slideNumber, shapeName, nestedNames, out);
+		}
+		return;
+	}
+	if (expected !== null && typeof expected === "object" && actual !== null && typeof actual === "object") {
+		const record = expected;
+		const other = actual;
+		for (const key of /* @__PURE__ */ new Set([...Object.keys(record), ...Object.keys(other)])) {
+			const before = record[key];
+			const after = other[key];
+			if (before === void 0 || after === void 0) {
+				out.push({
+					slideNumber,
+					shapeName,
+					nestedNames,
+					path: `${path}.${key}`,
+					field: key,
+					kind: before === void 0 ? "added" : "lost",
+					expected: brief(before),
+					actual: brief(after),
+					declaredBy: null
+				});
+				continue;
+			}
+			diffValue(before, after, `${path}.${key}`, key, slideNumber, shapeName, nestedNames, out);
+		}
+		return;
+	}
+	out.push(scalarDifference(slideNumber, shapeName, nestedNames, path, field, expected, actual));
+}
+function scalarDifference(slideNumber, shapeName, nestedNames, path, field, expected, actual) {
+	return {
+		slideNumber,
+		shapeName,
+		nestedNames,
+		path,
+		field,
+		kind: "changed",
+		expected: brief(expected),
+		actual: brief(actual),
+		declaredBy: null
+	};
+}
+/** The first note that covers this difference, or `null` if none does. */
+function declaringNote(difference, notes) {
+	for (const note of notes) {
+		if (note.slideNumber !== null && note.slideNumber !== difference.slideNumber) continue;
+		if (note.construct.startsWith("layout.") && difference.slideNumber !== 0) continue;
+		if (note.shapeName !== null && note.shapeName !== difference.shapeName && !difference.nestedNames.includes(note.shapeName)) continue;
+		const fields = noteFields(note.construct);
+		if (!fields) continue;
+		if (fields.includes("*") || fields.includes(difference.field)) return note;
+	}
+	return null;
+}
+/**
+* The fields a construct is a promise about.
+*
+* A layout-shape construct falls back to its slide counterpart, which is the whole point of
+* borrowing the vocabulary: `layout.line.width` is `line.width` on a layout and covers exactly
+* the same field. Only the two constructs with no slide twin need entries of their own.
+*/
+function noteFields(construct) {
+	return NOTE_FIELDS[construct] ?? (construct.startsWith("layout.") ? NOTE_FIELDS[construct.slice(7)] : void 0);
+}
+/**
+* `true` when the coverage table can match this construct — directly or through the
+* layout-shape fallback. The check a corpus test runs over every note both printers emit.
+*/
+function isKnownNoteConstruct(construct) {
+	return noteFields(construct) !== void 0;
+}
+function brief(value) {
+	if (value === void 0) return "—";
+	const text = JSON.stringify(value);
+	return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+}
+//#endregion
+export { InternalError, InvalidOptionError, LAYOUT_NOTE_PREFIX, MediaError, PackageReadError, TsPptxError, UnsupportedFeatureError, canonicalDeckIr, diffDeckIr, isAssetRef, isKnownNoteConstruct, knownNoteConstructs, printScript, printStandaloneScript, readModelToIr };
+
+//# sourceMappingURL=script.js.map