pptx-ts 3.7.0 → 4.0.0

package/dist/script.js

@@ -1,139 +1,40 @@
-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);
-		}
-	};
-}
+import { a as TsPptxError, c as setDiagnosticHandler, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, s as resetDiagnosticState, t as InternalError } from "./errors-C4oENPcu.js";
+import { F as EMU_PER_INCH, b as FIXED_PCT_PER_PERCENT, c as SchemeColor, t as TABLE_CELL_MARGIN_DEFAULTS_EMU, w as PERCENT_SCALE } from "./table-cell-margins-EVg0EwxT.js";
+import { F as LINE_END_TYPES, I as PRESET_LINE_DASHES, U as TEXT_AUTONUM_SCHEMES, X as TEXT_VERTICAL, h as stripHash, i as HALIGN_BY_TEXT_ALIGN, in as OOXML_NS, o as LINE_CAP_BY_TOKEN, sn as bytesToBase64, tt as TRANSITION_TYPES, u as boolValue, w as DEFAULT_COLOR_MAP } from "./image-size-CvN2iCA4.js";
+import { n as VALIGN_BY_ANCHOR, r as assetFilenameExtension } from "./text-anchor-CrYXAfUu.js";
+import { n as BODY_INSET_DEFAULTS_IN, r as BODY_INSET_DEFAULTS_PT } from "./body-insets-Dw_BeWD_.js";
+import { t as ABSENT_SLIDE_SIZE_EMU } from "./slide-size-BalTjFuv.js";
+import { a as isConnector, c as isPicture, i as isAutoShape, o as isGraphicFrame, s as isGroupShape } from "./shapes-re0KyQk_.js";
 /**
-* Wrap a scope so every construct recorded through it is namespaced under
-* {@link LAYOUT_NOTE_PREFIX} — see there for why.
+* Round a length already in inches to {@link INCH_DECIMALS}, which is EMU-exact on the way back.
 *
-* 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.
+* The one rounding: `inches` below and `pointsToInches` in the mapper each carried it, and the
+* second spelled the divisor as a bare `72`.
 */
-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";
+function toInches(value) {
+	return Number(value.toFixed(6));
 }
 /**
-* 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.
+* Geometry as inches, for the options that reject a raw-EMU string. Rounded to
+* {@link INCH_DECIMALS}, which is EMU-exact on the way back.
 */
-function asIrValue(value) {
-	return value;
+function inches(emuValue) {
+	return toInches(emuValue / EMU_PER_INCH);
 }
 //#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));
+	return toInches(pt / 72);
 }
 /**
 * A colour for a write-API `color` field. The read model splits a colour into a raw
@@ -141,30 +42,117 @@ function pointsToInches(pt) {
 * 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"
-]);
+* Only the 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.
+*
+* Derived from `SchemeColor` rather than transcribed from it. A hand-written copy of the ten
+* meant that a member added to the enum would keep being treated as unwritable here: baked to
+* a hex literal under an "approximated" note that had stopped being true, which is worse than
+* a loud failure. The write side already asks the same question of the same enum
+* (`gen/define/chart.ts`).
+*/
+const WRITABLE_SCHEME_TOKENS = new Set(Object.values(SchemeColor));
 /** `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);
 }
+/**
+* A source's `schemeClr` token as the write API's `color`, baked to a literal hex (with a
+* note) when the token is one of the seven the write path cannot carry, or `undefined` when
+* the source names no token at all.
+*
+* `undefined` means "this leg has nothing to say" — the caller's own-colour ladder decides
+* from there. Seven sites make this decision and four of them made it correctly: the table
+* fill, the cell fill and the cell border all returned an unwritable token *raw*, so a cell
+* filled `<a:schemeClr val="dk1"/>` emitted `fill: { color: 'dk1' }` and the generated script
+* warned and painted the cell the default text colour, with no note; the gradient stop baked
+* without recording one.
+*
+* @param scheme - the raw `a:schemeClr/@val`, or `null` when the source names none
+* @param resolvedHex - the literal the token resolves to, for the baking leg
+* @param notes - the scope the approximation is recorded on
+* @param construct - the note's construct id, e.g. `table.cell.fill.schemeToken`
+* @param label - how the note's prose names the thing, e.g. `cell fill`
+*/
+function schemeColorOption(scheme, resolvedHex, notes, construct, label) {
+	if (isWritableSchemeToken(scheme)) return scheme;
+	if (scheme === null) return void 0;
+	notes.note(construct, "approximated", "unwritable", `${label} 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 resolvedHex === null ? void 0 : literalColor(resolvedHex);
+}
+/**
+* One colour, as the read model splits it, resolved into the write API's single `color` field.
+*
+* The ladder, in order:
+*
+* 1. a **writable scheme token** — kept as a token, so the copy keeps tracking its theme;
+* 2. the surface's **own literal**, where the read model separates it from the resolved one;
+* 3. an **unwritable token**, noted and baked to the literal it resolves to;
+* 4. the **resolved literal**, for the colour models the write API's hex option cannot name;
+* 5. `undefined` — nothing to say, and the caller's own arm decides from there.
+*
+* Steps 2 and 3 cannot both apply: `a:solidFill` holds exactly one colour child, so a surface
+* has either an `a:srgbClr` or an `a:schemeClr` and never both. That is what makes one order
+* safe for all six sites, which is worth stating because the six had three orders between them
+* — one put the own literal first, one never consulted it at all, and one tested the token for
+* `null` before calling. {@link schemeColorOption} extracted the middle step and the ladder
+* around it stayed copied.
+*
+* @param color - the three spellings the read model reports
+* @param notes - the scope an unwritable token is noted on
+* @param construct - the note's construct id, e.g. `table.cell.fill.schemeToken`
+* @param label - how the note's prose names the thing, e.g. `cell fill`
+*/
+function colorOption(color, notes, construct, label) {
+	if (isWritableSchemeToken(color.scheme)) return color.scheme;
+	if (color.ownHex != null) return literalColor(color.ownHex);
+	return schemeColorOption(color.scheme, color.resolvedHex, notes, construct, label) ?? (color.resolvedHex === null ? void 0 : literalColor(color.resolvedHex));
+}
+/**
+* `a:bodyPr/@anchor` and `a:tcPr/@anchor` -> the write API's `valign`.
+*
+* Derived from the same table `resolveTextAnchor` reads, rather than written out again here:
+* this side cannot import `gen/`, so the two directions had no way to stay in step.
+*/
+const ANCHOR_TO_VALIGN = VALIGN_BY_ANCHOR;
+/**
+* The `a:prstDash` values the write API's `dashType` can spell.
+*
+* A dash outside `ST_PresetLineDashVal` cannot have come from a conformant deck; both mappers
+* that read one drop it to a plain dashed rule and note the loss, and both built this set.
+*/
+const WRITABLE_DASHES = new Set(PRESET_LINE_DASHES);
+/**
+* A shape's or frame's Selection Pane name as the IR's `sourceName`, or nothing when it has none.
+*
+* `sourceName` is how a call in the emitted script says which shape it came from, so it is
+* omitted rather than written empty. Three mappers spelled the ternary; this is it.
+*/
+function nameOf(subject) {
+	return subject.name ? { sourceName: subject.name } : {};
+}
+/**
+* The write options that carry a source object's identity onto the object a call authors: its
+* Selection Pane name and its alt text.
+*
+* Seven call builders spelled `objectName: shape.name || undefined` beside {@link nameOf}, so what a
+* source's identity becomes on the write side was a decision made seven times over, and none of the
+* seven made it for the description: `p:cNvPr/@descr` was read and never emitted, so every picture's
+* and text box's alt text was lost with no note. An empty description is no description, which is
+* how the write side spells one it was not given.
+* @param subject - the source shape or graphic frame
+*/
+function identityOptions(subject) {
+	return {
+		objectName: subject.name || void 0,
+		altText: subject.description || void 0
+	};
+}
 /** Normalize a hex to the bare 6-digit uppercase form the write API expects. */
 function literalColor(hex) {
-	return hex.replace(/^#/, "").toUpperCase();
+	return stripHash(hex).toUpperCase();
 }
 /**
 * Build an IR object from possibly-absent parts, dropping every `undefined`.
@@ -198,25 +186,69 @@ 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.
+* A 0-1 fraction the read model took off a fixed-point percentage, as the write API's 0-100
+* percent.
+*
+* `parsePercent` divided the source's thousandths of a percent by `PERCENT_SCALE`; this undoes
+* exactly that, so the integer the writer re-derives (`Math.round(percent × 1000)`) is the one
+* the source held. A stop at `pos="33333"` is `33.333`, not `33`: whole-percent rounding moved
+* it by up to half a percent and the re-read deck agreed with the rounded value, so the round
+* trip could not see it.
+*/
+function fractionToPercent(fraction) {
+	return Math.round(fraction * PERCENT_SCALE) / FIXED_PCT_PER_PERCENT;
+}
+/**
+* A 0-1 opacity as the write API's 0-100 transparency, at the source's own precision;
+* `undefined` when unset **or fully opaque**.
+*
+* Fully opaque is not `0`, and that is this function's rule rather than each caller's:
+* emitting `transparency: 0` for an `a:alphaModFix amt="100000"` produces a key the output
+* cannot have, because 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. One of five callers implemented that; the other four passed the value straight
+* through, and it stayed invisible only because the canonicaliser drops `transparency: 0` as
+* an implied default.
 */
 function alphaToTransparency(alpha) {
 	if (alpha === void 0 || alpha === null) return void 0;
-	return Math.round((1 - alpha) * 100);
+	const transparency = fractionToPercent(1 - alpha);
+	return transparency > 0 ? transparency : void 0;
 }
 /**
-* 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.
+* Where a shape sits on the slide, or `null` when nothing places it — in which case a
+* `shape.frameUnresolved` note has been recorded and the caller drops the shape.
+*
+* `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.
+*
+* Neither frame resolves for a shape with no `a:xfrm` of its own that is not a placeholder, or a
+* placeholder whose layout and master define no geometry either. The mappers used to part ways
+* there: a connector returned `null` with no note, breaking the rule that a dropped shape is
+* never silent, and every other kind was emitted with no `x/y/w/h`, which the writer places at
+* its default position. Neither is where the source put it, and the second looks deliberate, so
+* every kind now drops the shape and says so.
+*
+* Takes the `Shape` base rather than `AnyShape` so a `p:graphicFrame` — a table or a chart —
+* gets the same fallback and the same note. It had its own `positionOfFrame`, which returned
+* `{}` in exactly the case this fallback exists for, with no note: `absoluteFrame` is `null`
+* whenever an enclosing group lacks a usable transform, so a table inside such a group emitted
+* `addTable(rows, { objectName, tableStyle })` with no geometry at all.
 */
-function positionOfFrame(frame) {
-	const box = frame.absoluteFrame;
-	if (!box) return {};
+function frameOf(shape, notes) {
+	const frame = shape.absoluteFrame;
+	if (frame) return frame;
+	const resolved = shape.resolvedFrame;
+	if (!resolved) {
+		notes.note("shape.frameUnresolved", "dropped", "unread", "this shape has no transform of its own (a:xfrm) and no placeholder geometry to inherit, so nothing places it; it is omitted rather than emitted at the default position");
+		return null;
+	}
+	notes.note("shape.frameInherited", "flattened", "unsupported", resolved.source === "own" ? "this shape sits in a group whose transform could not be composed, so its own position is baked in as a slide-absolute one" : `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 resolved;
+}
+/** A box from {@link frameOf} as `Coord`-typed EMU strings, so the source geometry survives exactly. */
+function positionOptions(box) {
 	return {
 		x: emu(box.left),
 		y: emu(box.top),
@@ -225,7 +257,107 @@ function positionOfFrame(frame) {
 	};
 }
 //#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;
+	const crop = cropOption(picture.srcRect);
+	noteUncarriedGeometry(picture, notes, subject, crop !== void 0);
+	return compactRequired({
+		type: "image",
+		image: compactRequired({
+			crop,
+			data: asset
+		}),
+		transparency: 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);
+}
+/**
+* The source crop as the write API's `crop`, or `undefined` when this rect cannot be one — in which
+* case the caller notes it as uncarried instead. A picture fill's `image.crop` and a picture's own
+* `crop` take the same percentage insets, so both go through here.
+*
+* An all-zero rect is `undefined` rather than four zeros: `<a:srcRect/>` is what the write
+* path emits with no `crop` at all, so carrying zeros would add an option that changes
+* nothing and take the fill off its byte-identical path for no reason.
+*
+* Two shapes of rect are legal in a source and not expressible as `crop`, and both belong
+* to the write path rather than to this mapper (`gen/drawingml/src-rect.ts` throws on
+* each): a **negative** inset, which is how a `contain`-style fill bleeds the source past
+* the surface, and a pair of opposite insets summing to 100% or more, which leaves no
+* source area. Carrying either would emit a script that throws when it is run, so they
+* stay uncarried and keep their note.
+*/
+function cropOption(srcRect) {
+	if (!isRectSet(srcRect) || srcRect === null) return void 0;
+	const edges = {
+		b: fractionToPercent(srcRect.bottom),
+		l: fractionToPercent(srcRect.left),
+		r: fractionToPercent(srcRect.right),
+		t: fractionToPercent(srcRect.top)
+	};
+	if (Object.values(edges).some((v) => v < 0 || v > 100)) return void 0;
+	if (edges.l + edges.r >= 100 || edges.t + edges.b >= 100) return void 0;
+	return compact({
+		b: edges.b || void 0,
+		l: edges.l || void 0,
+		r: edges.r || void 0,
+		t: edges.t || void 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. `cropCarried`
+* is the one that is conditional on more than the source — the crop is expressible as
+* `image.crop` unless its insets fall outside what that option accepts, so whether it is
+* lost is the caller's answer to give.
+*/
+function noteUncarriedGeometry(picture, notes, subject, cropCarried) {
+	const lost = [];
+	if (picture.mode === "tile" || picture.tile !== null) lost.push("tiling (a:tile)");
+	if (isRectSet(picture.srcRect) && !cropCarried) lost.push("the source crop (a:srcRect), whose insets fall outside the 0–100% `image.crop` accepts");
+	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 stretched blip at a fixed dpi="0" rotWithShape="1", with only its <a:srcRect> under the caller's control, so ${lost.join(", ")} ${lost.length === 1 ? "does" : "do"} not carry`);
+}
+//#endregion
 //#region src/script/from-read/surface-fill.ts
+/** How a note's prose names a gradient stop's surface. */
+function stopLabel(where) {
+	if (where === "line") return "line gradient stop";
+	if (where === "slide.background" || where === "master.background") return "background gradient stop";
+	return "fill gradient stop";
+}
 /**
 * 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
@@ -233,12 +365,15 @@ function positionOfFrame(frame) {
 */
 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;
+		const color = colorOption({
+			scheme: stop.colorRef.scheme,
+			resolvedHex: stop.colorRef.resolved?.effectiveHex ?? null
+		}, notes, `${where}.gradient.schemeToken`, stopLabel(where));
+		if (color === void 0) return null;
 		return compact({
 			color,
-			position: Math.round((stop.position ?? 0) * 100),
-			transparency: alphaToTransparency(stop.alpha)
+			position: fractionToPercent(stop.position ?? 0),
+			transparency: alphaToTransparency(stop.colorRef.resolved?.alpha)
 		});
 	}).filter((stop) => stop !== null);
 	if (stops.length < 2) {
@@ -263,74 +398,952 @@ function gradientStops(gradient, notes, where) {
 * 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.
+* Each colour takes the ladder every other colour does. `PatternFillProps.fgColor`/`bgColor` are
+* `Color`, and the pattern emitter writes a token as `a:schemeClr`, so a writable token stays a
+* token. Both used to be baked to hex, and a theme-coloured hatch could not be told from a literal
+* one, so the copy stopped tracking its theme with nothing to say so.
 */
-function patternOption(pattern) {
+function patternOption(pattern, notes, where) {
 	if (!pattern?.preset) return void 0;
+	const color = (scheme, resolved, label) => colorOption({
+		scheme,
+		resolvedHex: resolved?.effectiveHex ?? null
+	}, notes, `${where}.pattern.schemeToken`, label);
 	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
+			fgColor: color(pattern.foreground.scheme, pattern.foreground.resolved, "pattern foreground"),
+			bgColor: color(pattern.background.scheme, pattern.background.resolved, "pattern background")
 		}) ?? { 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.
+* The three surfaces a fill can sit on, and how a note names each. One record rather than three
+* constants in three modules, because every field of it is decided by `where`.
 */
-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)
+const FILL_SURFACES = {
+	fill: {
+		label: "fill",
+		picture: {
+			construct: "fill.picture",
+			subject: "this shape's surface",
+			element: "a:blipFill"
+		}
+	},
+	"table.fill": {
+		label: "table fill",
+		picture: {
+			construct: "table.fill.picture",
+			subject: "this table",
+			element: "a:tblPr/a:blipFill"
+		}
+	},
+	"table.cell.fill": {
+		label: "cell fill",
+		picture: {
+			construct: "table.cell.fill.picture",
+			subject: "this table cell",
+			element: "a:tcPr/a:blipFill"
+		}
+	}
+};
+/**
+* A surface's `EG_FillProperties` as the write API's fill option, or `undefined` when the
+* surface states none.
+*
+* The order is the whole of it, and it is not arbitrary: an explicit `a:noFill` is a statement
+* and comes first; then the non-solid members, because a surface carrying one holds no
+* `a:solidFill` for the colour legs to find and `resolvedFill` would answer with a style's
+* banding colour the source never showed; then the colour ladder — a writable scheme token, the
+* surface's own literal, the resolved literal.
+*
+* Three copies of this walked three subjects that expose the same accessor names, and they had
+* drifted: only the shape's read `alphaModFix`, so a table or cell whose `a:solidFill` carried
+* one lost its transparency with nothing declaring the loss.
+*
+* @param subject - the shape, table or cell
+* @param ctx - the mapping context, for notes and the asset resolver
+* @param where - which surface this is, deciding the note constructs and prose
+* @param opts - `styled` short-circuits a styled surface with no fill of its own
+*/
+function surfaceFill(subject, ctx, where, opts = {}) {
+	const { notes, assets } = ctx;
+	const surface = FILL_SURFACES[where];
+	if (subject.fillNoFill) return { type: "none" };
+	const gradient = subject.gradientFill;
+	if (gradient) {
+		const stops = gradientStops(gradient, notes, where);
+		if (stops) return {
+			type: "gradient",
+			gradient: stops
+		};
+	}
+	const pattern = patternOption(subject.patternFill, notes, where);
+	if (pattern) return pattern;
+	const picture = subject.pictureFill;
+	if (picture) return pictureFillOption(picture, assets, notes, surface.picture);
+	const scheme = subject.fillSchemeColor;
+	if (isWritableSchemeToken(scheme)) return { color: scheme };
+	if (subject.fillColor != null) return { color: literalColor(subject.fillColor) };
+	if (opts.styled && subject.hasOwnFill === false) return void 0;
+	const resolved = subject.resolvedFill;
+	if (!resolved) return void 0;
+	return compact({
+		color: colorOption({
+			scheme,
+			resolvedHex: resolved.effectiveHex
+		}, notes, `${where}.schemeToken`, surface.label),
+		transparency: alphaToTransparency(resolved.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;
+//#endregion
+//#region src/script/from-read/background.ts
+/** The slide tier: a slide's own `p:bg`, which a slide falls back from to its layout's. */
+const SLIDE_BACKGROUND = {
+	construct: "slide.background",
+	subject: "this slide's background",
+	fallback: "the slide takes its layout's background"
+};
+/** The layout/master tier, which has nothing below it to inherit from. */
+const MASTER_BACKGROUND = {
+	construct: "master.background",
+	subject: "this layout's background",
+	fallback: "the layout is emitted with no background"
+};
+/**
+* Map one tier's background onto the write API's `background` option.
+*
+* `undefined` means *say nothing* — the caller omits the key, and the slide or layout takes
+* whatever it would have inherited. That is the right answer for an absent background and for
+* an explicit `a:noFill`, and it is also what a recorded loss falls back to.
+* @param background - the background the read model resolved, if any
+* @param notes - where a loss this mapper cannot avoid is recorded
+* @param assets - how a picture background's part becomes bytes the script can carry
+* @param tier - which tier is asking, for the note it records
+* @returns the IR background, or `undefined`
+*/
+function backgroundIr(background, notes, assets, tier) {
+	if (!background) return void 0;
+	if (background.type !== "themeRef") return fillIr(background, notes, assets, tier);
+	const fill = background.resolvedFill;
+	const ir = fill ? fillIr(fill, notes, assets, tier) : void 0;
+	if (fill && ir) {
+		notes.note(tier.construct, "flattened", "unwritable", `${tier.subject} is a theme reference (p:bgRef into the theme's background fill list), which has no write-API option; the ${fill.type === "solid" ? "colour" : fill.type} it currently resolves to is baked in and stops following the theme`);
+		return ir;
+	}
+	notes.note(tier.construct, "dropped", "unwritable", `${tier.subject} is a theme reference whose fill does not resolve to one the write API can express, and a reference itself has no write-API option; ${tier.fallback}`);
+}
+/** An explicit background fill, or `undefined` for none or for one with nothing to carry. */
+function fillIr(fill, notes, assets, tier) {
+	switch (fill.type) {
+		case "none": return;
+		case "solid": return solidIr(fill.colorRef, notes, tier);
+		case "image": {
+			const asset = fill.partName === null ? null : assets.assetFor(fill.partName);
+			return asset ? { data: asset } : void 0;
+		}
+		case "gradient": {
+			const gradient = gradientStops(fill.gradient, notes, tier.construct);
+			return gradient ? {
+				type: "gradient",
+				gradient
+			} : void 0;
+		}
+		case "pattern": {
+			const pattern = patternOption(fill, notes, tier.construct);
+			return pattern ? pattern : void 0;
+		}
+	}
+}
+/**
+* A solid colour, with the transparency its `a:alpha` states.
+*
+* Through the shared colour ladder, not the resolved hex alone. This read the resolved colour
+* and only the resolved colour, so a background painted with a theme token came out as the
+* literal that token happened to resolve to and stopped following the theme -- silently, where
+* every other surface that bakes a token says so. A writable token is kept as a token; an
+* unwritable one is baked and noted, under this tier's own `…schemeToken` construct.
+*/
+function solidIr(colorRef, notes, tier) {
+	const resolved = colorRef.resolved;
+	const color = colorOption({
+		scheme: colorRef.scheme,
+		ownHex: colorRef.srgb,
+		resolvedHex: resolved?.effectiveHex ?? null
+	}, notes, `${tier.construct}.schemeToken`, "background");
+	if (color === void 0) return void 0;
+	const transparency = alphaToTransparency(resolved?.alpha);
+	return transparency === void 0 ? { color } : {
+		color,
+		transparency
+	};
+}
+//#endregion
+//#region src/script/fidelity.ts
+/** A loss both printers have. */
+const BOTH_TIERS = ["template", "standalone"];
+/**
+* A loss only the standalone printer has, because the template-anchored one keeps the construct in
+* its template.
+*
+* Document properties are the plain case: the read half notes the ones with no write-API setter,
+* which matters for a script that rebuilds the deck, but the template-anchored tier never authors
+* them. They ride in the template, every one. 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, names and placeholder definitions are genuine losses for a script that rebuilds the
+* design, and untouched by one whose template *is* the design. A caveat that does not apply to the
+* output in front of you is worse than none: it teaches the reader to skim the ones that do.
+*/
+const STANDALONE_ONLY = ["standalone"];
+/**
+* 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.
+*
+* Each entry is a dotted option PATH, matched one of two ways depending on the note that names it:
+*
+* - **A note scoped to a shape** is already confined to that shape's call, so its entries are
+*   matched as a SUFFIX of where the difference sits inside it: a bare `fill` means "the fill
+*   option wherever it appears in the call", and `line.width` means that width and not a table
+*   cell border's. Write the bare form where the word is unambiguous and qualify it the moment
+*   the same word names two different things. Matching the terminal key alone is how `type`,
+*   written about a fill's solid default, came to excuse a character bullet that returned as a
+*   numbered list, and how a bare `color` in a run-colour note excused the shape's fill and
+*   outline colours, and in a cell note every colour in the table.
+* - **A note with no shape** (a slide or deck loss) has nothing confining it to one call, so its
+*   entries are anchored at the root of the diff. Each names one node by its full path
+*   (`background`, `chrome.masters.title`) and covers that node only, and a trailing `.*` extends
+*   it to everything beneath (`transition.sound.*`). As suffixes they matched inside every call in
+*   scope, and a deck's `master.background` excused every run colour and every lost image in the
+*   deck.
+*
+* `'*'` covers every difference inside the note's scope — correct only where the note says the
+* whole shape or slide 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.
+*
+* Each entry also names the printers whose output the note describes (`tiers`), and each printer
+* reports only the notes that apply to it. Two hand-kept sets used to decide that, one per printer,
+* so a new chrome construct was reported by the template-anchored tier unless someone remembered
+* to list it. An entry without `tiers` no longer satisfies the catalogue's type.
+*/
+const NOTE_CONSTRUCTS = {
+	"chart.blanks": {
+		fields: ["values"],
+		tiers: BOTH_TIERS
+	},
+	"chart.combo": {
+		fields: ["type"],
+		tiers: BOTH_TIERS
+	},
+	"chart.data": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"chart.labels": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"chart.type": {
+		fields: ["type"],
+		tiers: BOTH_TIERS
+	},
+	"chart.type3D": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"chart.xValues": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"chart.xLabels": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"chart.workbook": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"chartEx.all": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"connector.binding": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"connector.line": {
+		fields: [
+			"color",
+			"width",
+			"dashType",
+			"beginArrowType",
+			"endArrowType"
+		],
+		tiers: BOTH_TIERS
+	},
+	"connector.rotation": {
+		fields: ["rotate"],
+		tiers: BOTH_TIERS
+	},
+	"deck.docProps": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"deck.docPropsDefault": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"deck.slideSize": {
+		fields: ["slideSize.*"],
+		tiers: BOTH_TIERS
+	},
+	"diagram.all": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"fill.gradient": {
+		fields: ["gradient", "fill"],
+		tiers: BOTH_TIERS
+	},
+	"fill.gradient.path": {
+		fields: ["gradient", "fill"],
+		tiers: BOTH_TIERS
+	},
+	"line.gradient": {
+		fields: ["gradient", "line"],
+		tiers: BOTH_TIERS
+	},
+	"line.gradient.path": {
+		fields: ["gradient", "line"],
+		tiers: BOTH_TIERS
+	},
+	"line.gradient.schemeToken": {
+		fields: ["gradient", "line"],
+		tiers: BOTH_TIERS
+	},
+	"fill.picture": {
+		fields: ["fill"],
+		tiers: BOTH_TIERS
+	},
+	"fill.picture.geometry": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"fill.gradient.schemeToken": {
+		fields: ["gradient", "fill"],
+		tiers: BOTH_TIERS
+	},
+	"fill.pattern.schemeToken": {
+		fields: ["fill.pattern.fgColor", "fill.pattern.bgColor"],
+		tiers: BOTH_TIERS
+	},
+	"fill.schemeToken": {
+		fields: ["fill", "fill.color"],
+		tiers: BOTH_TIERS
+	},
+	"glow.schemeToken": {
+		fields: ["glow.color"],
+		tiers: BOTH_TIERS
+	},
+	"graphicFrame.unknown": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"group.child": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"group.childSpace": {
+		fields: [
+			"x",
+			"y",
+			"w",
+			"h",
+			"rotate",
+			"flipH",
+			"flipV"
+		],
+		tiers: BOTH_TIERS
+	},
+	"group.empty": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"group.transform": {
+		fields: [
+			"rotate",
+			"flipH",
+			"flipV"
+		],
+		tiers: BOTH_TIERS
+	},
+	"image.crop": {
+		fields: ["crop"],
+		tiers: BOTH_TIERS
+	},
+	"image.data": {
+		fields: ["data", "$asset"],
+		tiers: BOTH_TIERS
+	},
+	"image.recolor": {
+		fields: [
+			"duotone",
+			"grayscale",
+			"biLevel",
+			"clrChange"
+		],
+		tiers: BOTH_TIERS
+	},
+	"image.svg": {
+		fields: [
+			"svg",
+			"data",
+			"$asset"
+		],
+		tiers: BOTH_TIERS
+	},
+	"line.arrowSize": {
+		fields: ["beginArrowType", "endArrowType"],
+		tiers: BOTH_TIERS
+	},
+	"master.background": {
+		fields: ["chrome.masters.background.*"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.background.gradient": {
+		fields: ["chrome.masters.background.*"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.background.gradient.path": {
+		fields: ["chrome.masters.background.*"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.background.gradient.schemeToken": {
+		fields: ["chrome.masters.background.*"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.background.pattern.schemeToken": {
+		fields: ["chrome.masters.background.*"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.background.schemeToken": {
+		fields: ["chrome.masters.background.*"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.colorMap": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"master.decoration": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"master.default": {
+		fields: ["master"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.multiple": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"master.name": {
+		fields: ["chrome.masters.title", "layoutName"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.nameCollision": {
+		fields: ["chrome.masters.title", "layoutName"],
+		tiers: STANDALONE_ONLY
+	},
+	"master.placeholders": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"master.txStyles": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"theme.fmtScheme": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"layout.decoration": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"layout.group": {
+		fields: [],
+		tiers: STANDALONE_ONLY
+	},
+	"line.align": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"line.dash": {
+		fields: ["line.dashType"],
+		tiers: BOTH_TIERS
+	},
+	"line.schemeToken": {
+		fields: ["line.color"],
+		tiers: BOTH_TIERS
+	},
+	"line.width": {
+		fields: ["line.width"],
+		tiers: BOTH_TIERS
+	},
+	"media.audioVideo": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"notes.formatting": {
+		fields: ["notesText"],
+		tiers: BOTH_TIERS
+	},
+	"shadow.schemeToken": {
+		fields: ["shadow.color"],
+		tiers: BOTH_TIERS
+	},
+	"shape.custGeom.guides": {
+		fields: ["points"],
+		tiers: BOTH_TIERS
+	},
+	"shape.effects": {
+		fields: ["shadow", "glow"],
+		tiers: BOTH_TIERS
+	},
+	"shape.empty": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"shape.frameInherited": {
+		fields: [
+			"x",
+			"y",
+			"w",
+			"h"
+		],
+		tiers: BOTH_TIERS
+	},
+	"shape.frameUnresolved": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"shape.hidden": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"shape.hyperlink": {
+		fields: ["hyperlink"],
+		tiers: BOTH_TIERS
+	},
+	"shape.placeholder": {
+		fields: ["placeholder"],
+		tiers: BOTH_TIERS
+	},
+	"slide.animation": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"slide.background": {
+		fields: ["background"],
+		tiers: BOTH_TIERS
+	},
+	"slide.background.gradient": {
+		fields: ["background"],
+		tiers: BOTH_TIERS
+	},
+	"slide.background.gradient.path": {
+		fields: ["background"],
+		tiers: BOTH_TIERS
+	},
+	"slide.background.gradient.schemeToken": {
+		fields: ["background"],
+		tiers: BOTH_TIERS
+	},
+	"slide.background.pattern.schemeToken": {
+		fields: ["background"],
+		tiers: BOTH_TIERS
+	},
+	"slide.background.schemeToken": {
+		fields: ["background"],
+		tiers: BOTH_TIERS
+	},
+	"slide.carried": {
+		fields: ["*"],
+		tiers: ["template"]
+	},
+	"slide.layout": {
+		fields: ["layoutName"],
+		tiers: BOTH_TIERS
+	},
+	"slide.name": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"slide.transition": {
+		fields: ["transition"],
+		tiers: BOTH_TIERS
+	},
+	"slide.transitionSound": {
+		fields: ["transition.sound.*"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.borders.dash": {
+		fields: ["border", "diagonal"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.headers": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.field": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.equation": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.picture": {
+		fields: ["fill"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.picture.geometry": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.schemeToken": {
+		fields: ["fill", "fill.color"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.borders.schemeToken": {
+		fields: ["border", "diagonal"],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.schemeToken": {
+		fields: ["tableFill", "tableFill.color"],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.picture": {
+		fields: ["tableFill"],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.picture.geometry": {
+		fields: [],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.gradient": {
+		fields: ["tableFill"],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.gradient.path": {
+		fields: ["tableFill"],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.gradient.schemeToken": {
+		fields: ["tableFill"],
+		tiers: BOTH_TIERS
+	},
+	"table.fill.pattern.schemeToken": {
+		fields: ["tableFill.pattern.fgColor", "tableFill.pattern.bgColor"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.gradient": {
+		fields: ["fill"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.gradient.path": {
+		fields: ["fill"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.gradient.schemeToken": {
+		fields: ["fill"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.fill.pattern.schemeToken": {
+		fields: ["fill.pattern.fgColor", "fill.pattern.bgColor"],
+		tiers: BOTH_TIERS
+	},
+	"table.cell.vert": {
+		fields: ["textDirection", "vert"],
+		tiers: BOTH_TIERS
+	},
+	"table.rowAuto": {
+		fields: ["rowH"],
+		tiers: BOTH_TIERS
+	},
+	"table.style": {
+		fields: ["tableStyle"],
+		tiers: BOTH_TIERS
+	},
+	"text.align": {
+		fields: ["align"],
+		tiers: BOTH_TIERS
+	},
+	"text.bullet.numberType": {
+		fields: ["bullet"],
+		tiers: BOTH_TIERS
+	},
+	"text.bullet.sizePt": {
+		fields: ["bullet"],
+		tiers: BOTH_TIERS
+	},
+	"text.bullet.sizePct": {
+		fields: ["bullet"],
+		tiers: BOTH_TIERS
+	},
+	"text.bullet.schemeToken": {
+		fields: ["bullet"],
+		tiers: BOTH_TIERS
+	},
+	"text.bullet.picture": {
+		fields: ["bullet"],
+		tiers: BOTH_TIERS
+	},
+	"text.color.default": {
+		fields: ["options.color"],
+		tiers: BOTH_TIERS
+	},
+	"text.color.inherited": {
+		fields: ["options.color"],
+		tiers: BOTH_TIERS
+	},
+	"text.color.schemeToken": {
+		fields: ["options.color"],
+		tiers: BOTH_TIERS
+	},
+	"text.equation": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"text.field": {
+		fields: ["*"],
+		tiers: BOTH_TIERS
+	},
+	"text.hyperlink": {
+		fields: ["hyperlink"],
+		tiers: BOTH_TIERS
+	},
+	"text.hyperlink.underline": {
+		fields: ["options.underline"],
+		tiers: BOTH_TIERS
+	},
+	"text.bullet.glyph": {
+		fields: ["bullet"],
+		tiers: BOTH_TIERS
+	},
+	"text.autofit.fontScale": {
+		fields: ["fit"],
+		tiers: BOTH_TIERS
+	},
+	"text.autofit.lnSpcReduction": {
+		fields: ["fit"],
+		tiers: BOTH_TIERS
+	},
+	"text.paraSpaceZero": {
+		fields: ["paraSpaceBefore", "paraSpaceAfter"],
+		tiers: BOTH_TIERS
+	},
+	"text.vert": {
+		fields: ["vert"],
+		tiers: BOTH_TIERS
+	}
+};
+/**
+* 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 `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.";
+/**
+* `true` when a note describes the output of the printer for `tier`.
+*
+* A construct's catalogue entry decides. A `layout.`-prefixed construct with no entry of its own is
+* a slide construct borrowed for a loss in re-authoring a layout's decoration, so whatever its
+* slide twin says, it applies only to the standalone tier: the template-anchored one does not
+* rebuild layouts.
+*/
+function noteAppliesTo(construct, tier) {
+	const entry = NOTE_CONSTRUCTS[construct];
+	if (entry) return entry.tiers.includes(tier);
+	if (construct.startsWith("layout.")) return tier === "standalone";
+	return true;
+}
+/**
+* `a`, `a and b`, `a, b and c` — a note is a sentence a human reads, and a bare
+* `join(', ')` made a two-item one read as a list that had lost its last member.
+*/
+function andList(items) {
+	if (items.length < 2) return items.join("");
+	return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+/**
+* The note each {@link UnwritableFramePayload} records.
+*
+* Here rather than beside the shape mapper that records them, because the printer reads it too
+* and the printer does not reach into `from-read/`. `graphicFrameCall` picks its note from it. The
+* template-anchored printer keeps these on a slide it copies whole and drops every other note
+* recorded there: these say which construct forced the copy, and the rest describe a
+* transcription that tier never prints.
+*/
+const UNWRITABLE_FRAME_CONSTRUCTS = {
+	chartEx: "chartEx.all",
+	diagram: "diagram.all",
+	unknown: "graphicFrame.unknown"
+};
+/** 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";
 }
-/** `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);
+/**
+* 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;
 }
 /**
-* Note the parts of the fill's geometry the write path's fixed stretch cannot express.
+* `base`, or `base (2)`, `base (3)`, … — the first spelling `used` does not already hold.
 *
-* 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.
+* The rule {@link MasterIr}'s `props.title` is made unique by. Shared because the standalone
+* printer has to predict the title the reader gives the write path's own `DEFAULT` layout when a
+* source layout already carries that name.
 */
-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`);
+function uniqueTitle(base, used) {
+	let title = base;
+	for (let suffix = 2; used.has(title); suffix++) title = `${base} (${suffix})`;
+	return title;
 }
+/**
+* The `docProps` fields that round-trip, each keyed by its write-API setter and naming the read
+* accessor it comes from: four are `docProps/core.xml`, read through `Presentation.coreProperties`
+* (`author` is `dc:creator`), and `company` is `<Company>` in `docProps/app.xml`, read through
+* `Presentation.appProperties`.
+*
+* The one spelling of the list. {@link DeckPropsIr}, the mapping, the core properties that are not
+* carried, the ones a written deck is stamped with and the round trip's writer defaults all derive
+* from it. They used to be spelled out at each of those sites, and `company`, added late, was
+* missing from one of them.
+*/
+const DECK_PROPS = {
+	title: {
+		part: "core",
+		key: "title"
+	},
+	author: {
+		part: "core",
+		key: "creator"
+	},
+	subject: {
+		part: "core",
+		key: "subject"
+	},
+	revision: {
+		part: "core",
+		key: "revision"
+	},
+	company: {
+		part: "app",
+		key: "company"
+	}
+};
+/** {@link DECK_PROPS}' keys, in its order. */
+const DECK_PROP_KEYS = Object.keys(DECK_PROPS);
 //#endregion
 //#region src/script/from-read/detect.ts
 /**
@@ -352,8 +1365,6 @@ function noteUncarriedGeometry(picture, notes, subject) {
 * 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",
@@ -409,11 +1420,11 @@ function isAudioVideo(element) {
 *
 * 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
+* *can* author one (`TextProps.math`, plus the `pptx-ts/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");
+	return has(element, OOXML_NS.m, "oMath");
 }
 /**
 * `true` when this `p:sp` is a text box rather than an auto shape.
@@ -427,9 +1438,15 @@ function hasEquation(element) {
 *
 * Direct child rather than a subtree search: `p:cNvSpPr` sits under `p:nvSpPr`, and a group
 * would otherwise answer for its first child.
+*
+* Parsed through {@link boolValue} rather than compared to `'1'`: `txBox` is `xsd:boolean`, and
+* this module's whole job is reading decks this library did not write. PowerPoint and `gen/` both
+* emit `1`, so a bare comparison is right for every fixture here and wrong for a producer that
+* spells it `true` — which would convert that deck's text boxes as auto shapes, silently.
 */
 function isTextBox(element) {
-	return child(child(element, OOXML_NS.p, "nvSpPr"), OOXML_NS.p, "cNvSpPr")?.getAttribute("txBox") === "1";
+	const nvSpPr = child(element, OOXML_NS.p, "nvSpPr");
+	return boolValue(child(nvSpPr, OOXML_NS.p, "cNvSpPr")?.getAttribute("txBox")) === true;
 }
 /**
 * `true` when a group's child coordinate space equals its own frame, so its children are
@@ -513,59 +1530,30 @@ function hasDecorativeShapes(element) {
 * 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"
-};
+const ALIGN = HALIGN_BY_TEXT_ALIGN;
 /** `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"
-]);
+/**
+* `a:bodyPr/@vert` values the write API's `vert` accepts. `TextVertType` is the whole
+* `ST_TextVerticalType`, so this is `TEXT_VERTICAL` itself, and `text.vert` fires only for a token
+* outside the schema.
+*/
+const WRITABLE_VERT = new Set(TEXT_VERTICAL);
 /**
 * 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"
-]);
+* the lookup has one job left: telling a scheme the write path can spell from one it cannot.
+*
+* Built from the tuple the write API's `numberType` is derived from and its emitter checks, so
+* the two cannot disagree about a scheme.
+*/
+const AUTO_NUMBER_TYPES = new Set(TEXT_AUTONUM_SCHEMES);
 /**
 * `Paragraph.bulletDetail` → the write API's `bullet` option.
 *
@@ -644,10 +1632,11 @@ function startAtOption(startAt) {
 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`);
+	const clampedPct = sizePct === null ? null : Math.min(400, Math.max(25, sizePct));
+	if (sizePct !== null && clampedPct !== sizePct) notes.note("text.bullet.sizePct", "approximated", "unwritable", `bullet glyph size ${sizePct}% is outside the 25–400% range the write API accepts, so it is printed as ${clampedPct}% — the bound the write path clamps it to`);
 	return compact({
 		fontFace: orUndefined(bullet.font),
-		size: sizePct === null || sizePct < 25 || sizePct > 400 ? void 0 : sizePct,
+		size: clampedPct ?? void 0,
 		color: bulletColor(bullet, notes)
 	}) ?? {};
 }
@@ -656,13 +1645,11 @@ function bulletStyle(bullet, notes) {
 * 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);
+	return colorOption({
+		scheme: bullet.colorRef.scheme,
+		ownHex: bullet.colorRef.srgb,
+		resolvedHex: bullet.colorRef.resolved?.effectiveHex ?? null
+	}, notes, "text.bullet.schemeToken", "bullet");
 }
 /**
 * Per-run character formatting, shared by shape text and table-cell text.
@@ -676,8 +1663,11 @@ function bulletColor(bullet, notes) {
 * 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) {
+function runOptions(run, ctx) {
+	const { notes } = ctx;
 	const underline = run.underline;
+	const hyperlink = hyperlinkOption(run, ctx);
+	if (hyperlink !== void 0 && underline === null) notes.note("text.hyperlink.underline", "flattened", "unwritable", "this run links somewhere and states no underline, which PowerPoint paints underlined all the same; the write path writes u=\"sng\" on a link that sets none, so the text looks the same but states an underline it used to leave to the link");
 	return compact({
 		bold: orUndefined(run.bold),
 		italic: orUndefined(run.italic),
@@ -689,7 +1679,7 @@ function runOptions(run, notes) {
 		highlight: run.highlight ? literalColor(run.highlight.effectiveHex) : void 0,
 		caps: orUndefined(run.caps),
 		baseline: orUndefined(run.baselinePct),
-		hyperlink: hyperlinkOption(run)
+		hyperlink
 	});
 }
 /**
@@ -700,33 +1690,128 @@ function runOptions(run, notes) {
 */
 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 (scheme !== null) return schemeColorOption(scheme, run.resolvedColor?.effectiveHex ?? null, notes, "text.color.schemeToken", "run");
 	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");
+		notes.note("text.color.default", "approximated", "unread", "this run inherits its colour and nothing resolves what it inherits (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);
 }
+/** The `@action` of a jump to another slide of the deck. */
+const SLIDE_JUMP = "ppaction://hlinksldjump";
 /**
-* 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.
+* A run's hyperlink: a URL, or a jump to another slide of this deck by its number.
+*
+* The read model reports a slide jump as the target's part name, and the write API takes a slide
+* number, which {@link MapContext.slideNumberOf} resolves. Anything else a run can link to has no
+* run-level spelling (a show jump such as "next slide", which the write side emits at shape level
+* only; a custom show; another file; a slide jump from a layout's shape) and is noted. A slide
+* jump used to be dropped with a comment saying the deck-level walk handled it, which it did not,
+* so the text kept its link formatting and went nowhere.
 */
-function hyperlinkOption(run) {
-	const link = run.hyperlink;
-	if (!link?.url) return void 0;
-	return compact({
+function hyperlinkOption(run, ctx) {
+	return linkOption(run.hyperlink, ctx, RUN_LINK);
+}
+/** The show-jump actions `HyperlinkProps.action` spells, by the `@action` each one is written as. */
+const SHOW_JUMP_ACTIONS = new Map([
+	"firstslide",
+	"previousslide",
+	"nextslide",
+	"lastslide",
+	"lastslideviewed",
+	"endshow"
+].map((jump) => [`ppaction://hlinkshowjump?jump=${jump}`, jump]));
+const RUN_LINK = {
+	construct: "text.hyperlink",
+	takesAction: false,
+	subject: "this run's hyperlink",
+	spells: "all a run's hyperlink option spells (a show jump, a custom show, another file, or a slide jump from a layout's shape)",
+	loss: "the text keeps its formatting and links nowhere"
+};
+const SHAPE_LINK = {
+	construct: "shape.hyperlink",
+	takesAction: false,
+	subject: "this shape's hyperlink",
+	spells: "all a shape's hyperlink option spells (a custom show, another file, or a slide jump from a layout's shape)",
+	loss: "the shape is emitted without it and clicking it does nothing"
+};
+/**
+* The `@action` PowerPoint puts on an audio or video picture's `p:cNvPr`. It is structural rather
+* than a link anyone set -- the media emitter writes it itself (`gen/slide/objects/media.ts`), and
+* `addMedia` writes it again -- so it is not a hyperlink to carry and not a loss to note.
+*/
+const MEDIA_ACTION = "ppaction://media";
+/** A shape's own click hyperlink, as `addShape`/`addText`/`addImage` take it. */
+function shapeHyperlinkOption(shape, ctx) {
+	const link = shape.hyperlink;
+	if (link?.action === MEDIA_ACTION) return void 0;
+	return linkOption(link, ctx, {
+		...SHAPE_LINK,
+		takesAction: true
+	});
+}
+/**
+* One reading of a click hyperlink for both sites that carry one. A run and a shape take the same
+* `HyperlinkProps` apart from `action`, which only a shape's is written as, so the difference is a
+* flag rather than a second copy of the mapping.
+*/
+function linkOption(link, ctx, site) {
+	if (!link) return void 0;
+	const tooltip = link.tooltip ?? void 0;
+	if (link.url) return compact({
 		url: link.url,
-		tooltip: link.tooltip ?? void 0
+		tooltip
 	});
+	const slide = link.action === SLIDE_JUMP && link.targetPartName ? ctx.slideNumberOf(link.targetPartName) : null;
+	if (slide !== null) return compact({
+		slide,
+		tooltip
+	});
+	const jump = link.action === null ? void 0 : SHOW_JUMP_ACTIONS.get(link.action);
+	if (site.takesAction && jump !== void 0) return compact({
+		action: jump,
+		tooltip
+	});
+	ctx.notes.note(site.construct, "dropped", "unwritable", `${site.subject} (${link.action ?? "an internal target"}) is neither a URL nor a jump to another slide of the deck, which is ${site.spells}, so ${site.loss}`);
+}
+/** The constructs and wording {@link noteUnreadText} records a shape's or a table cell's losses in. */
+const UNREAD_TEXT = {
+	shape: {
+		field: "text.field",
+		equation: "text.equation",
+		subject: "this shape",
+		call: "addText",
+		equationLoss: "the shape is emitted without it - even though TextProps.math (and the ts-pptx/math subpath) could author one"
+	},
+	cell: {
+		field: "table.cell.field",
+		equation: "table.cell.equation",
+		subject: "this table cell",
+		call: "addTable",
+		equationLoss: "the cell is emitted without it"
+	}
+};
+/**
+* Note the text a frame holds that no run carries, and return the text its runs do.
+*
+* Authorable text is *runs*. `TextFrame.text` also counts `a:fld` field text (a slide number, date
+* or footer placeholder), which has no run behind it, and an OMML equation contributes to neither.
+* Both were checked for an auto shape only, so the same field in a table cell was lost with no note.
+* @param frame - the text frame
+* @param element - the element holding it, searched for an equation
+* @param notes - the scope the losses are recorded on
+* @param holder - whether the frame belongs to a shape or a table cell
+* @returns the frame's run text
+*/
+function noteUnreadText(frame, element, notes, holder) {
+	const wording = UNREAD_TEXT[holder];
+	const runText = frame.paragraphs.flatMap((p) => p.runs.map((run) => run.text)).join("");
+	if (frame.text.replaceAll("\n", "").length > runText.length) notes.note(wording.field, "dropped", "unread", `${wording.subject} holds an automatic field (a:fld - a slide number, date or footer), which has no accessor and no ${wording.call} expression, so its text is not reproduced`);
+	if (hasEquation(element)) notes.note(wording.equation, "dropped", "unread", `${wording.subject} holds an OMML equation, which no accessor exposes, so ${wording.equationLoss}`);
+	return runText;
 }
 /** Paragraph-level properties, replicated onto each of the paragraph's runs. */
 function paragraphOptions(paragraph, notes) {
@@ -755,11 +1840,11 @@ function paragraphOptions(paragraph, notes) {
 * blank line survives — dropping it would silently close up vertical space the author put
 * there deliberately.
 */
-function textRuns(frame, notes) {
+function textRuns(frame, ctx) {
 	const paragraphs = frame.paragraphs;
 	const items = [];
 	paragraphs.forEach((paragraph, paragraphIndex) => {
-		const paraOpts = paragraphOptions(paragraph, notes);
+		const paraOpts = paragraphOptions(paragraph, ctx.notes);
 		const runs = paragraph.runs;
 		const breaks = paragraphIndex < paragraphs.length - 1;
 		if (runs.length === 0) {
@@ -778,7 +1863,7 @@ function textRuns(frame, notes) {
 			delete continuation["bullet"];
 			const options = compact({
 				...runIndex === 0 ? paraOpts : continuation,
-				...runOptions(run, notes),
+				...runOptions(run, ctx),
 				...isLastRun && breaks ? { breakLine: true } : {}
 			});
 			items.push(compact({
@@ -803,7 +1888,7 @@ function textFrameOptions(frame, notes) {
 	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],
+		valign: anchor === null ? "top" : ANCHOR_TO_VALIGN[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),
@@ -856,45 +1941,24 @@ function bakedPct(value, name, notes) {
 * 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)
+		pointsToInches(top ?? BODY_INSET_DEFAULTS_PT.top),
+		pointsToInches(right ?? BODY_INSET_DEFAULTS_PT.right),
+		pointsToInches(bottom ?? BODY_INSET_DEFAULTS_PT.bottom),
+		pointsToInches(left ?? BODY_INSET_DEFAULTS_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) {
+function tableCall(frame, table, ctx) {
+	const { notes } = ctx;
+	const box = frameOf(frame, notes);
+	if (!box) return null;
 	const styleId = table.styleId;
 	const hasStyle = table.resolvedStyle !== null;
 	const rows = [];
@@ -903,29 +1967,33 @@ function tableCall(frame, table, notes, assets) {
 		const cells = [];
 		for (const cell of row.cells) {
 			if (cell.isMergeContinuation) continue;
-			cells.push(cellIr(cell, hasStyle, notes, assets));
+			cells.push(cellIr(cell, hasStyle, ctx));
 		}
 		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");
+	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; the auto rows are emitted as null in rowH, which pins nothing, so addTable gives each of them an even share of the table height rather than sizing it to its content");
 	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,
+			...positionOptions(box),
+			...identityOptions(frame),
 			tableStyle: orUndefined(styleId),
-			tableFill: tableFill(table, notes, assets),
+			tableFill: tableFill(table, ctx),
 			hasHeader: table.firstRowHeader ? true : void 0,
+			hasFooter: table.lastRowFooter ? true : void 0,
 			hasBandedRows: table.bandedRows ? true : void 0,
+			hasBandedColumns: table.bandedColumns ? true : void 0,
+			hasFirstColumn: table.firstColumnHeader ? true : void 0,
+			hasLastColumn: table.lastColumnFooter ? 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)
+			rowH: rowHeights.every((h) => h === 0) ? void 0 : rowHeights.map((h) => h === 0 ? null : inches(h))
 		}) ?? {}],
-		...frame.name ? { sourceName: frame.name } : {}
+		...nameOf(frame)
 	};
 }
 /**
@@ -937,23 +2005,8 @@ function tableCall(frame, table, notes, assets) {
 * 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;
+function tableFill(table, ctx) {
+	return surfaceFill(table, ctx, "table.fill");
 }
 /**
 * One cell as a `TableCell`.
@@ -962,32 +2015,34 @@ function tableFill(table, notes, assets) {
 * 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) {
+function cellIr(cell, hasStyle, ctx) {
+	const { notes } = ctx;
 	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");
+	if (frame) noteUnreadText(frame, cell.element_, notes, "cell");
 	const options = compact({
-		fill: cellFill(cell, hasStyle, notes, assets),
+		fill: cellFill(cell, hasStyle, ctx),
 		border: cellBorders(cell, notes),
 		diagonal: cellDiagonals(cell, notes),
 		anchorCtr: cell.anchorCtr ? true : void 0,
 		cell3D: cellThreeD(cell),
-		valign: anchor === null ? void 0 : ANCHOR[anchor],
+		valign: anchor === null ? void 0 : ANCHOR_TO_VALIGN[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)
+			inches(margins.top ?? TABLE_CELL_MARGIN_DEFAULTS_EMU.top),
+			inches(margins.right ?? TABLE_CELL_MARGIN_DEFAULTS_EMU.right),
+			inches(margins.bottom ?? TABLE_CELL_MARGIN_DEFAULTS_EMU.bottom),
+			inches(margins.left ?? TABLE_CELL_MARGIN_DEFAULTS_EMU.left)
 		] : void 0,
-		...frame?.paragraphs[0]?.runs[0] ? runOptions(frame.paragraphs[0].runs[0], notes) ?? {} : {}
+		...frame?.paragraphs[0]?.runs[0] ? runOptions(frame.paragraphs[0].runs[0], ctx) ?? {} : {}
 	});
 	return compact({
-		text: frame ? textRuns(frame, notes) : cell.text,
+		text: frame ? textRuns(frame, ctx) : cell.text,
 		options
 	}) ?? { text: "" };
 }
@@ -1029,25 +2084,28 @@ function cellThreeD(cell) {
 		} : void 0
 	}) ?? {};
 }
-/** The `ST_TextVerticalType` values `TextBaseProps.textDirection` accepts. */
-const WRITABLE_TEXT_DIRECTIONS = /* @__PURE__ */ new Set([
-	"horz",
-	"vert",
-	"vert270",
-	"wordArtVert"
-]);
+/**
+* The `ST_TextVerticalType` values `TextBaseProps.textDirection` accepts, as a `Record` over that
+* union so the compiler catches a direction either side gains.
+*/
+const WRITABLE_TEXT_DIRECTIONS = {
+	horz: true,
+	vert: true,
+	vert270: true,
+	wordArtVert: true
+};
 /**
 * 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
+* `ST_TextVerticalType` has seven values and the write option covers four. The other three
+* (`eaVert`, `mongolianVert` and `wordArtVertRtl`) are East-Asian and right-to-left 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;
+	if (Object.hasOwn(WRITABLE_TEXT_DIRECTIONS, 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`);
 }
 /**
@@ -1066,26 +2124,8 @@ function cellTextDirection(cell, notes) {
 * 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) };
+function cellFill(cell, hasStyle, ctx) {
+	return surfaceFill(cell, ctx, "table.cell.fill", { styled: hasStyle });
 }
 /**
 * The four edge borders as the write API's `[top, right, bottom, left]` tuple.
@@ -1106,20 +2146,6 @@ function cellBorders(cell, notes) {
 	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`.
 *
@@ -1132,12 +2158,15 @@ 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);
+	const known = dash === null || WRITABLE_DASHES.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)),
+		color: colorOption({
+			scheme: edge.colorRef.scheme,
+			resolvedHex: edge.colorRef.resolved?.effectiveHex ?? null
+		}, notes, "table.cell.borders.schemeToken", "cell border"),
 		width: orUndefined(edge.widthPt)
 	}) ?? {};
 }
@@ -1167,6 +2196,30 @@ const CHART_TYPE = {
 	surface: "surface",
 	surface3D: "surface"
 };
+/**
+* The 3-D groups rebuilt flat, because the write API has no 3-D type for them. `bar3D` and
+* `bubble3D` keep their own, and a 3-D surface is what the write side's `surface` already draws.
+*/
+const FLATTENED_3D = /* @__PURE__ */ new Set([
+	"area3D",
+	"line3D",
+	"pie3D"
+]);
+/**
+* The plot types whose `showLabel` writes the category name. A scatter's writes nothing unless a
+* `dataLabelFormatScatter` is also set, so a scatter is not among them.
+*/
+const CATEGORY_NAME_TYPES = /* @__PURE__ */ new Set(["doughnut", "pie"]);
+/**
+* The plot types that pair every value with an X value of its own (`c:xVal` and `c:yVal`, plus
+* `c:bubbleSize` on a bubble) rather than with a category. `addChart` spells them as a leading row
+* of X values followed by one row per series.
+*/
+const XY_TYPES = /* @__PURE__ */ new Set([
+	"bubble",
+	"bubble3D",
+	"scatter"
+]);
 /** `c:legendPos/@val` → the write API's `legendPos`. */
 const LEGEND_POS = {
 	r: "r",
@@ -1176,32 +2229,37 @@ const LEGEND_POS = {
 	tr: "tr"
 };
 function chartCall(frame, chart, notes) {
+	const box = frameOf(frame, notes);
+	if (!box) return null;
 	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 (sourceType !== null && FLATTENED_3D.has(sourceType)) notes.note("chart.type3D", "flattened", "unwritable", `a 3-D ${type} chart (c:${sourceType}Chart) is rebuilt as a flat ${type} chart: the write API has no 3-D ${type} type, so its depth, rotation and perspective are gone`);
 	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) {
+	const xy = XY_TYPES.has(type);
+	const data = xy ? xyData(chart, type, notes) : seriesData(chart, notes);
+	if (data.length === 0 || chart.series.every((series) => (xy ? series.yValues : series.values).length === 0)) {
 		notes.note("chart.data", "dropped", "unsupported", "this chart caches no plottable series values");
 		return null;
 	}
+	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");
 	return {
 		method: "addChart",
 		args: [data, compact({
 			type,
-			...positionOfFrame(frame),
-			objectName: frame.name || void 0,
+			surface3D: sourceType === "surface" ? false : void 0,
+			...positionOptions(box),
+			...identityOptions(frame),
 			...titleOptions(chart),
 			...legendOptions(chart),
-			...labelOptions(chart),
+			...labelOptions(chart, type, notes),
 			...axisOptions(chart),
 			chartColors: seriesColors(chart)
 		}) ?? { type }],
-		...frame.name ? { sourceName: frame.name } : {}
+		...nameOf(frame)
 	};
 }
 /**
@@ -1210,21 +2268,81 @@ function chartCall(frame, chart, notes) {
 * 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;
-		});
+	const levels = chart.categoryLevels.map((level) => level.map((label) => label ?? ""));
+	const labels = levels.length > 1 ? levels : levels[0];
+	const dense = blanksToZero(notes);
+	return chart.series.map((series, index) => {
+		const values = dense(series.values);
 		return compact({
 			name: orUndefined(series.name),
 			values,
-			labels: index === 0 && categories.length > 0 ? categories : void 0
+			labels: index === 0 && levels[0]?.length ? labels : 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;
+}
+/**
+* A scatter or bubble chart as `OptsChartData[]`: the X row, then one row per series with its Y
+* values and, on a bubble, its sizes. The X row is not a series and has no name in the chart part;
+* its column header lives only in the workbook, which is regenerated anyway.
+*
+* `addChart` plots every series against that one X row, while a chart part gives each series a
+* `c:xVal` of its own. The first series' X values are taken, and a series whose own differ is noted.
+* @param type - the write-API chart type the chart is rebuilt as
+*/
+function xyData(chart, type, notes) {
+	const series = chart.series;
+	const first = series[0];
+	if (!first) return [];
+	const dense = blanksToZero(notes);
+	const xValues = plottedX(first);
+	const withSizes = type !== "scatter";
+	const rows = [{ values: dense(xValues) }];
+	let ownX = false;
+	for (const one of series) {
+		const own = plottedX(one);
+		if (own.length !== xValues.length || own.some((value, i) => value !== xValues[i])) ownX = true;
+		const values = dense(one.yValues);
+		rows.push(compact({
+			name: orUndefined(one.name),
+			values,
+			sizes: withSizes ? dense(one.bubbleSizes) : void 0
+		}) ?? { values });
+	}
+	if (ownX) notes.note("chart.xValues", "approximated", "unwritable", `the series of this ${type} chart do not share one set of X values, and addChart plots every series against a single X row, so each is rebuilt against the first series' X values`);
+	if (series.some((one) => one.xLabels !== null)) notes.note("chart.xLabels", "dropped", "unwritable", `this ${type} chart is plotted against text X labels, which PowerPoint places at 1 to n in point order; it is rebuilt against those positions and plots the same, but addChart takes numbers for its X row, so the labels are gone`);
+	return rows;
+}
+/**
+* The X coordinates a series is plotted at. A series plotted against text has none of its own, and
+* neither has a series with no `c:xVal`: PowerPoint places the points of both at 1 to n, and an X row
+* of those positions draws the same chart. Taking the X values instead turned every label into a
+* blank and the blank into a 0, and gave a series with no `c:xVal` an empty X row, against which
+* `addChart` plots no point at all.
+*/
+function plottedX(series) {
+	const labels = series.xLabels;
+	if (labels !== null) return positions(labels.length);
+	const xValues = series.xValues;
+	return xValues.length === 0 ? positions(series.yValues.length) : xValues;
+}
+/** The positions 1 to `count`. */
+function positions(count) {
+	return Array.from({ length: count }, (_unused, i) => i + 1);
+}
+/**
+* Densify cached points for `number[]`, noting once per chart when a blank had to become 0.
+* The returned function is called once per point list, and the note is recorded on the first blank.
+*/
+function blanksToZero(notes) {
+	let noted = false;
+	return (points) => points.map((value) => {
+		if (value !== null) return value;
+		if (!noted) {
+			noted = true;
+			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 0;
+	});
 }
 function titleOptions(chart) {
 	const title = chart.title;
@@ -1241,17 +2359,32 @@ function legendOptions(chart) {
 		legendPos: legend.position === null ? void 0 : LEGEND_POS[legend.position]
 	};
 }
-function labelOptions(chart) {
-	const labels = chart.dataLabels;
+/**
+* Data-label flags as `ChartOpts`.
+*
+* Two of the read model's flags have no key of their own on the write side, and they were emitted
+* as `showCatName` and `showLegendKey` anyway. Neither is a `ChartOpts` key, so the writer ignored
+* both and nothing said so. `ChartOpts` spells the category name `showLabel`, which a pie and a
+* doughnut write as one; nothing spells the legend-key swatch.
+*
+* A pie and a doughnut are read from the series' own block. PowerPoint writes the flags the user set
+* there and an all-off block for the group, so reading the group block rebuilt a labelled pie
+* without its labels.
+* @param type - the write-API chart type the chart is rebuilt as
+*/
+function labelOptions(chart, type, notes) {
+	const carriesCategoryName = CATEGORY_NAME_TYPES.has(type);
+	const labels = (carriesCategoryName ? chart.series[0]?.dataLabels : null) ?? chart.dataLabels;
 	if (!labels) return {};
+	if (labels.showLegendKey === true) notes.note("chart.labels", "dropped", "unwritable", "the data labels show the legend key swatch (c:showLegendKey), which no ChartOpts option spells, so the labels come back without it");
+	if (labels.showCategoryName === true && !carriesCategoryName) notes.note("chart.labels", "dropped", "unwritable", `the data labels show the category name (c:showCatName); ChartOpts spells that showLabel, which only a pie and a doughnut write as the category name, so on this ${type} chart the labels come back without it`);
 	return {
 		showValue: labels.showValue ?? void 0,
 		showSerName: labels.showSeriesName ?? void 0,
-		showCatName: labels.showCategoryName ?? void 0,
+		showLabel: carriesCategoryName ? labels.showCategoryName ?? void 0 : void 0,
 		showPercent: labels.showPercent ?? void 0,
-		showLegendKey: labels.showLegendKey ?? void 0,
 		showLeaderLines: labels.showLeaderLines ?? void 0,
-		dataLabelPosition: orUndefined(labels.position),
+		dataLabelPosition: orUndefined(labels.position) ?? (type === "pie" ? "bestFit" : void 0),
 		dataLabelFormatCode: labels.numberFormat?.formatCode ?? void 0
 	};
 }
@@ -1284,94 +2417,39 @@ function seriesColors(chart) {
 	if (series.length === 0) return void 0;
 	const colors = [];
 	for (const one of series) {
-		const hex = one.fill?.color;
+		const hex = one.fill?.colorRef.srgb;
 		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"
-};
+//#region src/script/from-read/context.ts
 /**
-* 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.
+* The same context, with its notes bound to one shape.
+*
+* A note recorded through the result names that shape, which is what lets a reader of the
+* emitted script find the shape a loss belongs to. Callers used to re-derive this inline as
+* `notes.forShape(shape.name || null)`, sometimes twice in one function and once in a callee
+* that already had a scoped one.
+*
+* An unnamed shape scopes to `''`, not `null`. `null` is how a slide or deck note is scoped, and
+* the round trip matches such a note's fields from the root of the diff, where a shape's
+* `line.width` is never found, so a correctly noted loss on an unnamed shape was reported as
+* undeclared.
+* @param ctx - the enclosing context
+* @param shape - the shape to scope to; an unnamed one scopes to `''`
 */
-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;
+function forShape(ctx, shape) {
+	return {
+		...ctx,
+		notes: ctx.notes.forShape(shape.name || "")
+	};
 }
+//#endregion
+//#region src/script/from-read/shape-paint.ts
+/** Arrowhead types `ShapeLineProps` accepts: every `ST_LineEndType`, the tokens `a:headEnd/@type` uses. */
+const WRITABLE_ARROWS = new Set(LINE_END_TYPES);
 /**
 * `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
@@ -1381,31 +2459,6 @@ 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.
 */
@@ -1426,29 +2479,42 @@ function transformOptions(shape) {
 * 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)
-	});
+function fillOption(shape, ctx) {
+	return surfaceFill({
+		...fillAccessors(shape),
+		fillColor: shape.fillColor
+	}, ctx, "fill");
+}
+/**
+* The `EG_FillProperties` accessors {@link surfaceFill} reads, projected off a read-model shape.
+*
+* A projection rather than passing the shape itself: `AnyShape` is a union whose members carry
+* far more than this, and naming the six keys is what makes "a shape, a table and a cell answer
+* the same six questions" a checked statement rather than an observation.
+*/
+function fillAccessors(shape) {
+	return {
+		gradientFill: shape.gradientFill,
+		patternFill: shape.patternFill,
+		pictureFill: shape.pictureFill,
+		fillSchemeColor: shape.fillSchemeColor,
+		resolvedFill: shape.resolvedFill
+	};
+}
+/**
+* Everything about an outline that does not survive, noted.
+*
+* Three independent conditions, none of which decides any of `lineOption`'s emitted values --
+* they were interleaved with the option build, which is what made that function four
+* decisions wearing one name.
+*
+* @param values - the outline's already-read parts, so this does not re-read the DOM
+*/
+function noteLineLosses(shape, values, notes) {
+	const { widthPt, dash, scheme, resolved } = values;
+	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");
 }
 /**
 * A shape's outline as `ShapeLineProps`.
@@ -1474,18 +2540,22 @@ function lineOption(shape, notes) {
 	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");
+	const color = colorOption({
+		scheme,
+		ownHex: shape.lineColor,
+		resolvedHex: resolved?.effectiveHex ?? null
+	}, notes, "line.schemeToken", "outline");
+	noteLineLosses(shape, {
+		widthPt,
+		dash,
+		scheme,
+		resolved
+	}, notes);
 	return compact({
 		color,
 		width: orUndefined(widthPt),
 		dashType: dash !== null && WRITABLE_DASHES.has(dash) ? dash : void 0,
-		cap: cap === null ? void 0 : CAP_TOKENS[cap],
+		cap: cap === null ? void 0 : LINE_CAP_BY_TOKEN[cap],
 		transparency: alphaToTransparency(resolved?.alpha),
 		...arrowOptions(shape, notes)
 	});
@@ -1508,64 +2578,145 @@ function shadowOption(shape, notes) {
 	if (!source) return void 0;
 	return compact({
 		type: outer ? "outer" : "inner",
-		color: source.color === null ? void 0 : literalColor(source.color),
+		color: colorOption({
+			scheme: source.colorRef.scheme,
+			resolvedHex: source.colorRef.resolved?.effectiveHex ?? null
+		}, notes, "shadow.schemeToken", "shadow"),
 		blur: source.blurPt,
 		offset: source.offsetPt,
 		angle: source.angleDeg,
-		transparency: alphaToTransparency(source.alpha)
+		transparency: alphaToTransparency(source.colorRef.resolved?.alpha)
 	});
 }
 /** Glow. The read model reports opacity as a 0–1 alpha, which is the write API's unit too. */
-function glowOption(shape) {
+function glowOption(shape, notes) {
 	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
+		color: colorOption({
+			scheme: glow.colorRef.scheme,
+			resolvedHex: glow.colorRef.resolved?.effectiveHex ?? null
+		}, notes, "glow.schemeToken", "glow"),
+		opacity: glow.colorRef.resolved?.alpha
 	});
 }
 /** The style block every shape kind shares. */
-function styleOptions(shape, notes, assets) {
+function styleOptions(shape, ctx) {
+	const { notes } = ctx;
 	return {
-		fill: fillOption(shape, notes, assets),
+		fill: fillOption(shape, ctx),
 		line: lineOption(shape, notes),
 		shadow: shadowOption(shape, notes),
-		glow: glowOption(shape)
+		glow: glowOption(shape, notes)
 	};
 }
 /**
-* 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.
+* 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.
+*/
+//#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.
+*/
+/**
+* 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, ctx) {
+	const scoped = forShape(ctx, shape);
+	if (shape.hidden) {
+		noteHidden(scoped.notes);
+		return null;
+	}
+	if (isGroupShape(shape)) return groupCall(shape, scoped);
+	if (isPicture(shape)) return pictureCall(shape, scoped);
+	if (isConnector(shape)) return connectorCall(shape, scoped.notes);
+	if (isGraphicFrame(shape)) return graphicFrameCall(shape, scoped);
+	if (isAutoShape(shape)) return autoShapeCall(shape, scoped);
+	return null;
+}
+/**
+* The shape's authorable text, and the notes for what it holds that cannot be authored.
+*
+* "Has text" means text this converter can author, which is *runs*. `TextFrame.text` also
+* counts `a:fld` field text -- a slide number, date or footer placeholder -- and there is no
+* run behind it, so measuring by `text` made every field placeholder emit an `addText`
+* carrying a single empty string: an invisible empty box where a number used to be.
+*
+* Extracted from `autoShapeCall`, which inlined this alongside the placeholder note, the
+* common-option assembly and three mutually exclusive emission arms.
+* @returns the frame when it holds authorable runs, else `null`
 */
-function autoShapeCall(shape, notes, assets) {
+function autoShapeText(shape, notes) {
+	const frame = shape.hasTextFrame ? shape.textFrame : null;
+	if (frame === null) return null;
+	return noteUnreadText(frame, shape.element_, notes, "shape").length > 0 ? frame : null;
+}
+function autoShapeCall(shape, ctx) {
+	const { notes } = ctx;
+	const box = frameOf(shape, notes);
+	if (!box) return null;
 	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");
+	const frame = autoShapeText(shape, notes);
 	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),
+		...positionOptions(box),
 		...transformOptions(shape),
-		...styleOptions(shape, notes, assets),
-		objectName: shape.name || void 0
+		...styleOptions(shape, ctx),
+		...identityOptions(shape),
+		hyperlink: shapeHyperlinkOption(shape, ctx)
 	};
 	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");
+		noteCustGeomGuides(notes);
+		const points = customGeometryPoints(box, custom);
+		if (frame !== null) {
+			const options = compact({
+				...common,
+				...textFrameOptions(frame, notes),
+				...isTextBox(shape.element_) ? { isTextBox: true } : {},
+				shape: "custGeom",
+				points
+			});
+			return {
+				method: "addText",
+				args: [textRuns(frame, ctx), options ?? {}],
+				...nameOf(shape)
+			};
+		}
 		return {
 			method: "addShape",
 			args: ["custGeom", compact({
 				...common,
-				points: customGeometryPoints(shape, custom)
+				points
 			}) ?? {}],
 			...nameOf(shape)
 		};
 	}
-	if (hasText && frame !== null) {
+	if (frame !== null) {
 		const options = compact({
 			...common,
 			...textFrameOptions(frame, notes),
@@ -1577,7 +2728,7 @@ function autoShapeCall(shape, notes, assets) {
 		});
 		return {
 			method: "addText",
-			args: [textRuns(frame, notes), options ?? {}],
+			args: [textRuns(frame, ctx), options ?? {}],
 			...nameOf(shape)
 		};
 	}
@@ -1594,6 +2745,29 @@ function autoShapeCall(shape, notes, assets) {
 		...nameOf(shape)
 	};
 }
+/** The note for what a `custGeom` holds beside its path, shared by a freeform shape and a picture clipped to one. */
+function noteCustGeomGuides(notes) {
+	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");
+}
+/**
+* A picture's clip as `addImage` spells it: `points` for a freeform, `shape` and `shapeAdjust` for
+* a preset.
+*
+* PowerPoint writes `rect` for a picture that has not been cropped to a shape, and `addImage` writes
+* `rect` when it is given no `shape`, so a `rect` is left off rather than printed on every picture.
+*/
+function pictureClipOptions(shape, box, notes) {
+	const custom = shape.customGeometry;
+	if (custom) {
+		noteCustGeomGuides(notes);
+		return { points: customGeometryPoints(box, custom) };
+	}
+	const preset = shape.presetGeometry;
+	return preset === null || preset === "rect" ? {} : {
+		shape: preset,
+		...adjustOptions(shape)
+	};
+}
 /**
 * Preset-geometry adjust handles (`a:avLst`) as `shapeAdjust`.
 *
@@ -1619,15 +2793,18 @@ function adjustOptions(shape) {
 * `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.
+* is scaled onto the box the call is placed at 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.
+*
+* The box is the one {@link frameOf} placed the call at, not `absoluteFrame`: in a group whose
+* transform cannot be composed that is `null`, the shape is placed at its resolved box, and
+* scaling by 1 would print its points in raw path units.
 */
-function customGeometryPoints(shape, custom) {
-	const frame = shape.absoluteFrame;
+function customGeometryPoints(box, custom) {
 	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 sx = path.w > 0 ? box.width / path.w : 1;
+		const sy = path.h > 0 ? box.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) {
@@ -1692,7 +2869,10 @@ function customGeometryPoints(shape, custom) {
 * 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) {
+function pictureCall(shape, ctx) {
+	const { notes, assets } = ctx;
+	const box = frameOf(shape, notes);
+	if (!box) return null;
 	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) {
@@ -1706,20 +2886,20 @@ function pictureCall(shape, notes, assets) {
 	}
 	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;
+	const crop = cropOption(shape.crop);
+	if (crop === void 0 && isRectSet(shape.crop)) notes.note("image.crop", "approximated", "unwritable", "this picture's source crop (a:srcRect) has an inset outside the 0–100% `crop` accepts, or opposite insets that leave no image, so the picture is emitted uncropped");
 	return {
 		method: "addImage",
 		args: [{
 			...compact({
-				...positionOptions(shape, notes),
+				...positionOptions(box),
 				...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
-				}
+				...identityOptions(shape),
+				...pictureClipOptions(shape, box, notes),
+				shadow: shadowOption(shape, notes),
+				hyperlink: shapeHyperlinkOption(shape, ctx),
+				line: lineOption(shape, notes),
+				crop
 			}),
 			data: asset
 		}],
@@ -1741,6 +2921,22 @@ const CONNECTOR_LINE_KEYS = [
 	"endArrowType"
 ];
 /**
+* Every other `ShapeLineProps` key: what a connector's flat stroke options cannot express, which
+* the `connector.line` note declares.
+*
+* Typed as the complement of {@link CONNECTOR_LINE_KEYS}, so a stroke option the write API gains
+* does not compile here until it is placed, carried or noted. Unplaced, it would reach `lineOption`'s
+* output and the copy loop would drop it without a note. `type` is the fill kind, and gets this far
+* only as `'gradient'`: a `'none'` outline has already become a `line` shape.
+*/
+const CONNECTOR_FLATTENED_LINE_KEYS = {
+	type: true,
+	gradient: true,
+	pattern: true,
+	transparency: true,
+	cap: true
+};
+/**
 * A `Connector` becomes `addConnector`.
 *
 * The endpoints are the one real translation here. OOXML gives a connector a bounding box
@@ -1752,17 +2948,22 @@ const CONNECTOR_LINE_KEYS = [
 * 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");
+	const drawn = connectorLine(shape, notes, "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 (!drawn) return null;
+	if (drawn.line?.["type"] === "none") return {
+		method: "addShape",
+		args: ["line", drawn.options],
+		...nameOf(shape)
+	};
+	const frame = drawn.box;
 	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 line = drawn.line ?? {};
 	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");
+	if (Object.keys(CONNECTOR_FLATTENED_LINE_KEYS).some((key) => line[key] !== void 0)) notes.note("connector.line", "flattened", "unwritable", "a connector styles its stroke with flat colour, width, dash and arrowhead options, which cannot express a gradient stroke, a stroke transparency or a line cap, so a gradient or a transparency falls back to a plain line and a cap to the default");
 	const right = frame.left + frame.width;
 	const bottom = frame.top + frame.height;
 	return {
@@ -1773,7 +2974,7 @@ function connectorCall(shape, notes) {
 			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,
+			...identityOptions(shape),
 			...stroke
 		}) ?? {}],
 		...nameOf(shape)
@@ -1797,20 +2998,21 @@ function unwritableFramePayload(shape) {
 	return "unknown";
 }
 /** A `GraphicFrame` hosts a table or a chart; both have their own mapper. */
-function graphicFrameCall(shape, notes, assets) {
+function graphicFrameCall(shape, ctx) {
+	const { notes } = ctx;
 	const table = shape.table;
-	if (table) return tableCall(shape, table, notes, assets);
+	if (table) return tableCall(shape, table, ctx);
 	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");
+			notes.note(UNWRITABLE_FRAME_CONSTRUCTS.chartEx, "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");
+			notes.note(UNWRITABLE_FRAME_CONSTRUCTS.diagram, "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");
+			notes.note(UNWRITABLE_FRAME_CONSTRUCTS.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;
 	}
 }
@@ -1825,17 +3027,25 @@ function graphicFrameCall(shape, notes, assets) {
 * 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.
+* Charts, tables and placeholders are excluded from groups by the write API, so a group holding
+* one loses that child. A connector is kept as the `line` shape it paints as, which a group takes.
 */
-function groupCall(shape, notes, assets) {
+function groupCall(shape, ctx) {
+	const { notes } = ctx;
+	const box = frameOf(shape, notes);
+	if (!box) return null;
 	const children = [];
 	for (const child of shape.shapes) {
-		const call = shapeCall(child, notes, assets);
+		if (isConnector(child)) {
+			const drawn = connectorLine(child, forShape(ctx, child).notes, "this connector is bound to shapes; it is re-authored as a line shape inside its group, which paints the same stroke but no longer follows them");
+			if (drawn) children.push(lineShape(drawn.options));
+			continue;
+		}
+		const call = shapeCall(child, ctx);
 		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`);
+			notes.note("group.child", "dropped", "unsupported", `addGroup accepts no ${kindLabel(call.method)} child (a group takes text, shapes, images and other groups), so this child is omitted from the group`);
 			continue;
 		}
 		children.push(tagged);
@@ -1849,12 +3059,16 @@ function groupCall(shape, notes, assets) {
 	return {
 		method: "addGroup",
 		args: [children, compact({
-			...positionOptions(shape, notes),
-			objectName: shape.name || void 0
+			...positionOptions(box),
+			...identityOptions(shape)
 		}) ?? {}],
 		...nameOf(shape)
 	};
 }
+/** A call's object kind as a note's prose names it: `addImage` is `image`. */
+function kindLabel(method) {
+	return method.replace(/^add/, "").toLowerCase();
+}
 /**
 * 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.
@@ -1896,10 +3110,6 @@ function commonShapeVariant(call) {
 		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.
@@ -1918,16 +3128,12 @@ function nameOf(shape) {
 * coordinates. `addTable` genuinely has nowhere to go, and is the one kind this reports as
 * lost.
 */
-function masterObject(shape, notes, assets) {
+function masterObject(shape, ctx) {
 	if (isConnector(shape)) {
-		const scoped = notes.forShape(shape.name || null);
-		if (shape.hidden) {
-			noteHidden(scoped);
-			return null;
-		}
-		return connectorObject(shape, scoped);
+		const drawn = connectorLine(shape, forShape(ctx, shape).notes, "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 drawn && lineShape(drawn.options);
 	}
-	const call = shapeCall(shape, notes, assets);
+	const call = shapeCall(shape, ctx);
 	if (!call) return null;
 	const shared = commonShapeVariant(call);
 	if (shared) return shared;
@@ -1936,7 +3142,10 @@ function masterObject(shape, notes, assets) {
 		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;
+			if (type === void 0 || first === void 0) {
+				forShape(ctx, shape).notes.note("decoration", "dropped", "unwritable", "a chart on a slide layout that names no type or carries no series has no defineSlideMaster({ objects }) variant, so it is dropped from the layout the output rebuilds");
+				return null;
+			}
 			return { chart: compact({
 				type,
 				data: first,
@@ -1944,52 +3153,74 @@ function masterObject(shape, notes, assets) {
 			}) ?? {} };
 		}
 		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`);
+			forShape(ctx, shape).notes.note("decoration", "dropped", "unwritable", `a ${kindLabel(call.method)} 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.
+* A `Connector` as the `line` shape it paints as, or `null` when it produces nothing: it is hidden,
+* or nothing places it. Either way the note has been recorded.
+*
+* A layout reaches a connector only this way. The alternative 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 rule under a title is usually a
+* connector rather than a shape. Drawing it as a `line` preset paints the identical stroke, and a
+* shape carries `rotate`, which `addConnector` does not. What that costs is the endpoint binding,
+* which on a layout costs nothing that was working: `a:stCxn`/`a:endCxn` reference shapes in the
+* layout's own tree.
+*
+* `addConnector` reads its endpoints and stroke from the same place, so the frame, the binding note
+* and the stroke are decided once for every way a connector is emitted. The binding note's prose
+* is the caller's, since what the loss means depends on where the connector lands.
+* @param shape - the connector
+* @param notes - the scope bound to this connector
+* @param bindingDetail - the endpoint-binding note's detail, for where this connector lands
 */
-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),
+function connectorLine(shape, notes, bindingDetail) {
+	if (shape.hidden) {
+		noteHidden(notes);
+		return null;
+	}
+	const box = frameOf(shape, notes);
+	if (!box) return null;
+	if (shape.startConnection || shape.endConnection) notes.note("connector.binding", "dropped", "unsupported", bindingDetail);
+	const line = lineOption(shape, notes);
+	return {
+		box,
+		line,
+		options: compactRequired({
+			...positionOptions(box),
 			...transformOptions(shape),
-			line: lineOption(shape, notes),
+			line,
 			shadow: shadowOption(shape, notes),
-			glow: glowOption(shape),
-			objectName: shape.name || void 0
-		}) ?? {}
+			glow: glowOption(shape, notes),
+			...identityOptions(shape)
+		})
+	};
+}
+/**
+* A connector's `line` shape as a key-tagged descriptor, the form a layout object and a group child
+* both take. Through `compact` like the other arms, so every emitted descriptor spells its keys in
+* the same order and the printed script does not read as two different mappers.
+*/
+function lineShape(options) {
+	return { shape: compact({
+		type: "line",
+		options
 	}) ?? {} };
 }
 //#endregion
 //#region src/script/from-read/chrome.ts
 /** Build the chrome IR for a deck. */
-function chromeToIr(pres, notes, assets) {
+function chromeToIr(pres, ctx) {
+	const { notes } = ctx;
 	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)
+		masters: layoutsToIr(masters, ctx)
 	};
 }
 /** The theme's colour scheme and font faces, in `ThemeProps` spelling. */
@@ -2030,7 +3261,8 @@ function recordMasterLosses(masters, theme, notes) {
 * called "Title and Content", and two `defineSlideMaster` calls sharing a title would make
 * every slide bind to whichever won.
 */
-function layoutsToIr(masters, notes, assets) {
+function layoutsToIr(masters, ctx) {
+	const { notes, assets } = ctx;
 	const out = [];
 	const used = /* @__PURE__ */ new Set();
 	let placeholderCount = 0;
@@ -2042,8 +3274,7 @@ function layoutsToIr(masters, notes, assets) {
 		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})`;
+		const title = uniqueTitle(base, used);
 		if (title !== base) collided.push(`${JSON.stringify(base)} → ${JSON.stringify(title)}`);
 		used.add(title);
 		const placeholders = layout.placeholders.length;
@@ -2051,8 +3282,8 @@ function layoutsToIr(masters, notes, assets) {
 			placeholderCount += placeholders;
 			placeholderLayouts++;
 		}
-		const background = backgroundProps(layout.background ?? master.background, notes, assets);
-		const objects = layoutObjects(layout, notes, assets);
+		const background = backgroundIr(layout.background ?? master.background, notes, assets, MASTER_BACKGROUND);
+		const objects = layoutObjects(layout, ctx);
 		out.push({
 			layoutIndex: index,
 			props: compact({
@@ -2088,21 +3319,25 @@ function layoutsToIr(masters, notes, assets) {
 * 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) {
+function layoutObjects(layout, ctx) {
 	const out = [];
-	collectObjects(layout.shapes, out, layoutShapeScope(notes), assets);
+	collectObjects(layout.shapes, out, {
+		...ctx,
+		notes: layoutShapeScope(ctx.notes),
+		slideNumberOf: () => null
+	});
 	return out;
 }
 /** {@link layoutObjects}'s walk, recursing through groups. */
-function collectObjects(shapes, out, notes, assets) {
+function collectObjects(shapes, out, ctx) {
 	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);
+			forShape(ctx, shape).notes.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, ctx);
 			continue;
 		}
-		const object = masterObject(shape, notes, assets);
+		const object = masterObject(shape, ctx);
 		if (object !== null) out.push(object);
 	}
 }
@@ -2120,63 +3355,17 @@ function collectObjects(shapes, out, notes, assets) {
 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
-};
+* Built from the tuple the write API's `TransitionType` is derived from and its emitter validates
+* against, so the three cannot disagree. A list kept here by hand would drift out of date the
+* moment the writer gained a name, and the symptom would be a printed script that does not compile
+* or a transition dropped with a note it did not deserve.
+*/
+const WRITABLE_TYPES = new Set(TRANSITION_TYPES);
 /**
 * `true` when the write API has a name for this transition.
 *
@@ -2191,7 +3380,7 @@ const WRITABLE_TYPES = {
 * 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);
+	return info.namespace === "p" && WRITABLE_TYPES.has(info.type);
 }
 /**
 * Map a slide's transition, recording a note for anything that does not survive.
@@ -2199,7 +3388,8 @@ function isWritable(info) {
 * 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) {
+function transitionToIr(slide, ctx) {
+	const { notes, assets } = ctx;
 	const info = slide.transition;
 	if (!info) return void 0;
 	if (!isWritable(info)) {
@@ -2251,26 +3441,21 @@ function soundPartName(slide, 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"
-};
+/** An RFC 7230 token without `$`, a quote or a backtick. */
+const MEDIA_TOKEN = String.raw`[\w!#%&*+.^|~-]+`;
+/** `type/subtype` with optional `; name=value` parameters, each part a {@link MEDIA_TOKEN}. */
+const MEDIA_TYPE = new RegExp(String.raw`^${MEDIA_TOKEN}\/${MEDIA_TOKEN}(?:[ \t]*;[ \t]*${MEDIA_TOKEN}=${MEDIA_TOKEN})*$`);
+/**
+* A part's content type as the IR may carry it.
+*
+* The value is the deck's own `[Content_Types].xml` attribute, and it reaches a printed script
+* inside a `data:` URI. Anything outside the media-type grammar is not a type a renderer could
+* act on anyway, so it becomes `application/octet-stream` rather than text the printer has to
+* be trusted to neutralise.
+*/
+function assetContentType(contentType) {
+	return MEDIA_TYPE.test(contentType) ? contentType : "application/octet-stream";
+}
 /**
 * Collects media as shapes reference it, assigning each part a stable sequential name.
 *
@@ -2296,8 +3481,9 @@ var Assets = class {
 		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 contentType = assetContentType(part.contentType);
+		const extension = assetFilenameExtension(contentType) ?? partName.split(".").pop() ?? "bin";
+		const kind = contentType.startsWith("audio/") ? "audio" : "image";
 		const index = (this.#counts.get(kind) ?? 0) + 1;
 		this.#counts.set(kind, index);
 		const name = `${kind}${index}.${extension}`;
@@ -2305,8 +3491,8 @@ var Assets = class {
 		this.#byPartName.set(partName, ref);
 		this.#assets.push({
 			name,
-			contentType: part.contentType,
-			bytes: part.bytes
+			contentType,
+			bytes: part.serialize()
 		});
 		return ref;
 	}
@@ -2323,15 +3509,24 @@ function readModelToIr(pres) {
 	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`);
+	if (!size) deckScope.note("deck.slideSize", "approximated", "unsupported", `this deck declares no slide size, so the output uses the ${inches(ABSENT_SLIDE_SIZE_EMU.widthEmu)}in × ${inches(ABSENT_SLIDE_SIZE_EMU.heightEmu)}in PowerPoint opens such a deck at`);
 	const layouts = layoutGallery(pres);
-	const chrome = chromeToIr(pres, deckScope, assets);
-	const slides = pres.slides.map((slide, index) => slideToIr(slide, index + 1, collector, assets, layouts));
+	const slideNumbers = new Map(pres.slides.map((slide, index) => [slide.partName, index + 1]));
+	const slideNumberOf = (partName) => slideNumbers.get(partName) ?? null;
+	const chrome = chromeToIr(pres, {
+		notes: deckScope,
+		assets,
+		slideNumberOf
+	});
+	const slides = pres.slides.map((slide, index) => slideToIr(slide, index + 1, collector, {
+		assets,
+		slideNumberOf
+	}, layouts));
 	return {
 		slideSize: size ? {
 			widthEmu: size.widthEmu,
 			heightEmu: size.heightEmu
-		} : DEFAULT_SLIDE_SIZE,
+		} : { ...ABSENT_SLIDE_SIZE_EMU },
 		props: deckProps(pres, deckScope),
 		chrome,
 		slides,
@@ -2340,26 +3535,37 @@ function readModelToIr(pres) {
 	};
 }
 /**
-* 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.
+* The core properties with no write-API setter, each as a note's prose names it.
+*
+* Typed as every `CoreProperties` key {@link DECK_PROPS} does not read, less the three timestamps,
+* which describe the file rather than the deck. A property the read model gains does not compile
+* here until it is placed.
+*/
+const UNCARRIED_CORE_PROPS = {
+	keywords: "keywords",
+	description: "description",
+	category: "category",
+	contentStatus: "content status",
+	lastModifiedBy: "last-modified-by"
+};
+/**
+* Deck properties, reduced to the {@link DECK_PROPS} fields this converter can carry: they have a
+* write-API setter AND the read model reports them. The core fields in
+* {@link UNCARRIED_CORE_PROPS} have no setter. All of them survive anyway in a template-anchored
+* output, since the source deck itself becomes the template; 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
-	}) ?? {};
+	const parts = {
+		core: pres.coreProperties,
+		app: pres.appProperties
+	};
+	if (Object.keys(UNCARRIED_CORE_PROPS).some((key) => parts.core[key] !== void 0)) notes.note("deck.docProps", "dropped", "unwritable", `only ${andList(DECK_PROP_KEYS)} round-trip; ${andList(Object.values(UNCARRIED_CORE_PROPS))} have no write-API setter`);
+	const read = (key) => {
+		const source = DECK_PROPS[key];
+		return source.part === "core" ? parts.core[source.key] : parts.app[source.key];
+	};
+	return compact(Object.fromEntries(DECK_PROP_KEYS.map((key) => [key, read(key)]))) ?? {};
 }
 /**
 * The deck's layouts keyed by partname, each resolved to what a printer needs to bind to
@@ -2379,23 +3585,28 @@ function layoutGallery(pres) {
 		nameIsUnique: (nameCounts.get(handle.name) ?? 0) === 1
 	}]));
 }
-function slideToIr(slide, number, collector, assets, layouts) {
+function slideToIr(slide, number, collector, deck, layouts) {
 	const notes = scopeNotes(collector, number);
+	const ctx = {
+		...deck,
+		notes
+	};
+	const { assets } = deck;
 	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),
+		...backgroundOf(slide, notes, assets),
 		...notesOf(slide, notes)
 	};
-	const transition = transitionToIr(slide, notes, assets);
+	const transition = transitionToIr(slide, ctx);
 	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);
+		const call = shapeCall(shape, ctx);
 		if (call) calls.push(call);
 	}
 	recordAnimationLoss(slide, notes);
@@ -2422,25 +3633,41 @@ function hasUnwritableContent(slide) {
 	});
 	return check(slide.shapes);
 }
-function backgroundOf(slide, notes) {
+/**
+* A slide's own background, as the write API's `background` option.
+*
+* Only a slide-scoped background is carried: an inherited one comes with the layout, so
+* re-authoring it onto the slide would pin a colour that should keep following the layout.
+*/
+function backgroundOf(slide, notes, assets) {
 	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 {};
-	}
+	const ir = backgroundIr(background, notes, assets, SLIDE_BACKGROUND);
+	return ir ? { background: ir } : {};
 }
 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");
+	if (frame && frame.paragraphs.some(hasNotesFormatting)) notes.note("notes.formatting", "flattened", "unsupported", "speaker notes carry as plain text; per-run formatting, hyperlinks, bullets and indent levels, and the notes slide's own placeholder geometry, do not");
 	return { notesText: text };
 }
 /**
+* `true` when a speaker-notes paragraph states anything plain text cannot carry.
+*
+* `addNotes` takes plain text. The note used to fire for bold and italic only, so underline,
+* strike, colour, size, face, highlight, a hyperlink, a bullet or an indent level went with
+* nothing said. An explicit off (`u="none"`, `strike="noStrike"`, a suppressed bullet) is how plain
+* text reads anyway, so it does not count. Reads accessors only: `runOptions` would record colour
+* notes for text that emits no call.
+*/
+function hasNotesFormatting(paragraph) {
+	if (paragraph.level > 0) return true;
+	const bullet = paragraph.bulletDetail;
+	if (bullet !== null && bullet.kind !== "none") return true;
+	return paragraph.runs.some((run) => run.bold === true || run.italic === true || run.underline !== null && run.underline !== "none" || run.strike !== null && run.strike !== "noStrike" || run.color !== null || run.schemeColor !== null || run.fontSizePt !== null || run.fontName !== null || run.highlight !== null || run.hyperlink !== null);
+}
+/**
 * Build animations, which live in a slide-scoped `p:timing` element rather than in any
 * shape's subtree.
 *
@@ -2510,12 +3737,30 @@ function printString(value) {
 			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;
+			out += code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233 || code >= 55296 && code <= 57343 ? "\\u" + code.toString(16).padStart(4, "0") : char;
 		}
 	}
 	return `${out}'`;
 }
 /**
+* What ends a `//` comment: CR, LF, and U+2028 and U+2029, which ECMAScript counts as line
+* terminators too. Built from code points because those two, written raw, would end a regex
+* literal just as they end a comment.
+*/
+const LINE_TERMINATORS = new RegExp(`[\r\n${String.fromCharCode(8232, 8233)}]`, "g");
+/**
+* Deck text made safe to sit inside a comment: the `/* … *\/` banner or a `//` line.
+*
+* A comment is the one place the printer puts deck text with no literal around it, and two
+* things end one early, turning the rest into code: `*\/` closes a block comment, and a line
+* terminator closes a line comment. `JSON.stringify` escapes CR and LF but leaves U+2028 and
+* U+2029 raw, and ECMAScript counts both as line terminators, so a layout named across a line
+* separator broke the script it was printed into.
+*/
+function commentText(text) {
+	return text.replace(/\*\//g, "*\\/").replace(LINE_TERMINATORS, " ");
+}
+/**
 * 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
@@ -2579,6 +3824,24 @@ function printArguments(prefix, args, indentLevel, asset) {
 	const inner = "	".repeat(indentLevel + 1);
 	return `${pad}${prefix}(\n${args.map((arg) => `${inner}${printValue(arg, indentLevel + 1, asset)}`).join(",\n")}\n${pad})`;
 }
+//#endregion
+//#region src/script/print/common.ts
+/**
+* The parts of printing a script that do not depend on which tier is being printed.
+*
+* Two printers target the same IR — one anchored to the source deck as a template, one
+* standalone — and they differ only in how a deck and its chrome are set up. Everything after
+* that is identical: a slide's statements, how image bytes reach the script, and how the
+* fidelity notes are rendered into the banner. Keeping that here is not tidiness. A slide body
+* printed two slightly different ways would mean the round-trip oracle certifies one tier and
+* only resembles a check on the other, and the drift would be invisible in review.
+*/
+/**
+* Default import specifier for an emitted script — this package's *published* name, which is
+* not its directory name. Getting it wrong produces a script that prints and typechecks and
+* then fails at `import`, so it is pinned by a test rather than left to a literal.
+*/
+const PACKAGE_NAME = "pptx-ts";
 /**
 * Apply the defaults both printers share.
 *
@@ -2591,7 +3854,7 @@ function resolvePrintOptions(options) {
 		outputPath: options.outputPath ?? "./output.pptx",
 		assetDir: (options.assetDir ?? "./assets").replace(/\/$/, ""),
 		assetMode: options.assets ?? "file",
-		packageName: options.packageName ?? "@shbernal/ts-pptx"
+		packageName: options.packageName ?? PACKAGE_NAME
 	};
 }
 /** Width the header comment's prose wraps at, leaving room for the ` * ` prefix. */
@@ -2608,8 +3871,9 @@ 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}`;
+		const raw = asset.name.replace(/\.[^.]*$/, "").replace(/[^A-Za-z0-9_$]/g, "_");
+		const base = /^[A-Za-z_$]/.test(raw) ? raw : `_${raw}`;
+		let identifier = base;
 		let suffix = 2;
 		while (used.has(identifier)) identifier = `${base}_${suffix++}`;
 		used.add(identifier);
@@ -2617,42 +3881,56 @@ function assetIdentifiers(ir) {
 	}
 	return out;
 }
-/** Resolve an {@link AssetRef} to the `const` identifier standing for its bytes. */
+/**
+* Resolve an {@link AssetRef} to the `const` identifier standing for its bytes, remembering which
+* assets were printed.
+*
+* `printed`, not `DeckIr.assets`, is what a tier binds and returns. The chrome registers its
+* pictures through the same resolver as the slides, so a layout's background and logo are in
+* `DeckIr.assets`, and so are a carried slide's images. The template-anchored tier prints neither
+* (its template *is* the chrome, and a carried slide is copied), yet it bound every asset with a
+* `readFile`, returned the bytes, counted them in the banner and, in `'inline'` mode, inlined
+* them. So each tier prints its statements first and binds what they referenced.
+*/
 function assetPrinter(identifiers) {
-	return (ref) => {
+	const printed = /* @__PURE__ */ new Set();
+	const print = (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`);
+		printed.add(ref.$asset);
 		return identifier;
 	};
+	return {
+		print,
+		printed
+	};
 }
 /**
-* One `const` per asset, each holding a complete `data:` URI.
+* One `const` per printed 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.
+*
+* Bound in `DeckIr.assets` order rather than first-printed order, so the output stays a function
+* of the IR. `printed` comes from {@link assetPrinter}.
 */
-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 [];
+function printAssetBindings(ir, identifiers, assetDir, mode, printed, inlineComment = "// Media bytes, inlined so this script needs no files but its template.") {
+	const bound = printedAssets(ir, printed);
+	if (bound.length === 0) return [];
 	const lines = mode === "file" ? ["// Media bytes, loaded from the asset directory beside this script."] : [inlineComment];
-	for (const asset of ir.assets) {
+	for (const asset of bound) {
 		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)}`)}`);
+			const prefix = printString(`data:${asset.contentType};base64,`);
+			lines.push(`const ${identifier} = ${prefix} + (await readFile(here(${path}))).toString('base64')`);
+		} else lines.push(`const ${identifier} = ${printString(`data:${asset.contentType};base64,${bytesToBase64(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.
@@ -2665,7 +3943,7 @@ function printSlide(slide, parts, collector, printAsset) {
 	const identifier = `slide${slide.number}`;
 	const lines = [
 		"",
-		`// ${parts.comment}`,
+		`// ${commentText(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`);
@@ -2674,7 +3952,7 @@ function printSlide(slide, parts, collector, 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, " ")}`);
+		if (call.sourceName) lines.push(`// ${commentText(call.sourceName.replace(/\s+/g, " "))}`);
 		lines.push(printArguments(`${identifier}.${call.method}`, call.args, 0, printAsset));
 	}
 	return lines;
@@ -2695,7 +3973,7 @@ function header(prose, notes) {
 	}
 	return [
 		"/*",
-		...lines.map((line) => line ? ` * ${line}` : " *"),
+		...lines.map((line) => line ? ` * ${commentText(line)}` : " *"),
 		" */"
 	].join("\n");
 }
@@ -2742,62 +4020,77 @@ function wrap(text, width, continuation) {
 * @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
+* @param {ReadonlySet<string>} printed - the assets the script's statements reference
 * @returns {PrintedScript} the finished script
 */
-function printedScript(lines, ir, assetMode, notes) {
+function printedScript(lines, ir, assetMode, notes, printed) {
 	return {
 		code: lines.join("\n"),
-		assets: new Map(assetMode === "file" ? ir.assets.map((asset) => [asset.name, asset.bytes]) : []),
+		assets: new Map(assetMode === "file" ? printedAssets(ir, printed).map((asset) => [asset.name, asset.bytes]) : []),
 		notes
 	};
 }
-//#endregion
-//#region src/script/print/script.ts
+/** The IR's assets a script printed, in `DeckIr.assets` order. */
+function printedAssets(ir, printed) {
+	return ir.assets.filter((asset) => printed.has(asset.name));
+}
 /**
-* 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.");
+* The emitted script's imports and its `here` helper, which every path it reads or writes goes
+* through.
+*
+* Both tiers printed this block line by line and differed only in what they import: the
+* template-anchored one reads and writes files and opens the source deck through the read half,
+* while the standalone one reads files only when it has media to load.
+* @param packageName - the import specifier, from the print options
+* @param imports - the `node:fs/promises` names to import, and whether to import the read half
+*/
+function printPreamble(packageName, imports) {
+	return [
+		...imports.fs.length > 0 ? [`import { ${imports.fs.join(", ")} } from 'node:fs/promises'`] : [],
+		"import { fileURLToPath } from 'node:url'",
+		`import TsPptx from ${printString(packageName)}`,
+		...imports.read ? [`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 three lines that construct a generator and size it to the source deck.
+*
+* Both tiers print them, and both used to convert the EMU slide size themselves — reaching
+* across the seam into `from-read/values.ts` to do it. `ir.ts` keeps `slideSize` in EMU
+* deliberately, because converting there "would introduce a rounding decision at the wrong
+* layer"; the printer is not that layer either, so the conversion lives in `script/units.ts`
+* and the two-line preamble lives here.
+*
+* `appendSlides` compares slide sizes exactly and throws when they differ, so a change to the
+* printed inches fails loudly rather than quietly.
+* @param size - the deck's slide size, in EMU
+* @param indent - the prefix each line takes; the tier-B generator emits them inside a function
+*/
+function printLayoutSetup(size, indent = "") {
+	return [
+		`${indent}const pptx = new TsPptx()`,
+		`${indent}pptx.defineLayout({ name: 'source', width: ${inches(size.widthEmu)}, height: ${inches(size.heightEmu)} })`,
+		`${indent}pptx.layout = 'source'`
+	];
+}
+//#endregion
+//#region src/script/print/script.ts
 /** 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 assets = assetPrinter(assetNames);
+	const printAsset = assets.print;
+	const body = printSlides$1(ir, collector, printAsset);
 	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 carried = new Set(ir.slides.filter((slide) => slide.source === "carried").map((slide) => slide.number));
+	const notes = [...ir.fidelity, ...collector.notes].filter((note) => noteAppliesTo(note.construct, "template") && !transcriptionOfCarried(note, carried));
 	const lines = [
 		header([
 			"Generated from a .pptx by ts-pptx/script.",
@@ -2806,17 +4099,14 @@ function printScript(ir, options = {}) {
 			"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}` : ""}.`,
+			`Expects ${templatePath} (the source deck, unmodified) beside this file${assetMode === "file" && assets.printed.size > 0 ? `, plus ${assets.printed.size} 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))",
+		...printPreamble(packageName, {
+			fs: ["readFile", "writeFile"],
+			read: true
+		}),
 		"",
 		"// The source deck is the template: fromTemplate strips its slides and leaves its masters,",
 		"// layouts, theme and document properties exactly as they were.",
@@ -2824,10 +4114,22 @@ function printScript(ir, options = {}) {
 	];
 	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);
+	const assetLines = printAssetBindings(ir, assetNames, assetDir, assetMode, assets.printed);
 	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);
+	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 {", ...printLayoutSetup(ir.slideSize, "	"), "	return pptx", "}", ...body, "", `await writeFile(here(${printString(outputPath)}), await deck.save())`, "");
+	return printedScript(lines, ir, assetMode, notes, assets.printed);
+}
+/** The notes a slide this tier copies whole still reports: why it was copied, and what forced it. */
+const CARRIED_SLIDE_CONSTRUCTS = /* @__PURE__ */ new Set(["slide.carried", ...Object.values(UNWRITABLE_FRAME_CONSTRUCTS)]);
+/**
+* `true` for a note about transcribing a slide this tier copies instead.
+*
+* The IR maps a carried slide's shapes anyway, for the standalone tier, and each records its own
+* losses. `importSlide` copies the slide whole, so here those losses do not happen, and
+* `slide.carried` already excuses every difference on it, so the round trip could not tell.
+*/
+function transcriptionOfCarried(note, carried) {
+	return note.slideNumber !== null && carried.has(note.slideNumber) && !CARRIED_SLIDE_CONSTRUCTS.has(note.construct);
 }
 /**
 * The slide statements, batched into generators, preceded by the layout handles they bind to.
@@ -2898,7 +4200,7 @@ function printAppend(generatorName, first, collector, declared, declarations) {
 	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}')`);
+		declarations.push(`const ${identifier} = deck.layouts()[${layout.index}] // ${commentText(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} })`;
 }
@@ -2915,30 +4217,50 @@ function printAuthoredSlide(slide, generatorName, 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.
+* {@link DeckIr} → a runnable TypeScript module that depends on nothing but this package.
+* **Tier A.**
+*
+* **The trade, stated once.** The template-anchored printer (`printScript`) reuses the source
+* `.pptx` and gets the deck's entire design back byte for byte, at the cost of shipping that
+* file alongside the script and of leaving the design uneditable. This one ships a single
+* `.ts` file. Everything the source deck's chrome contained has to be *re-authored* from what
+* the read model exposes, and the read model deliberately exposes the property tiers a slide
+* inherits — colours, fonts, placeholder geometry — not the parts a slide merely sits on top
+* of. So the output is a deck that renders its slides faithfully and wears a different suit.
+*
+* **The ceiling is measured, not estimated, and no amount of printer work moves it.** Two
+* constructs are unreachable from *both* directions: `a:fmtScheme` (nothing reads it, and the
+* write path emits a hardcoded Office one) and `p:txStyles` (no reader, though
+* `SlideMasterProps.textStyles` could author it). A third, `p:clrMap`, is readable and has no
+* setter. Each is a fidelity note here and a `pass` in the other tier, which is the whole
+* reason the other tier shipped first. A **master's** own decoration joins them for a
+* structural reason rather than a reading one: `defineSlideMaster` creates a layout, so there
+* is no master shape tree to write to. A *layout's* decoration used to be on this list and is
+* not any more — it is transcribed into that layout's `objects`.
+*
+* **One structural difference beyond the chrome.** A slide marked `carried` has no source
+* package to be carried from here, so it is transcribed like any other and loses only the
+* construct that made it uncarryable — which each shape has already declared for itself. That
+* is why {@link DeckIr}'s calls are populated even for a carried slide.
 */
-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 assets = assetPrinter(assetNames);
+	const printAsset = assets.print;
 	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 props = printDocProps(ir, collector);
+	const theme = Object.keys(ir.chrome.theme).length > 0 ? printValue(ir.chrome.theme, 0, printAsset) : null;
+	const notes = [...ir.fidelity, ...collector.notes].filter((note) => noteAppliesTo(note.construct, "standalone"));
+	const needsReadFile = assetMode === "file" && assets.printed.size > 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}` : ""}.`,
+			`Standalone: this script needs nothing but ${packageName}${needsReadFile ? ` and ${assets.printed.size} 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",
@@ -2948,44 +4270,31 @@ function printStandaloneScript(ir, options = {}) {
 			`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))",
+		...printPreamble(packageName, {
+			fs: needsReadFile ? ["readFile"] : [],
+			read: false
+		}),
 		"",
-		"const pptx = new TsPptx()",
-		`pptx.defineLayout({ name: 'source', width: ${inches(ir.slideSize.widthEmu)}, height: ${inches(ir.slideSize.heightEmu)} })`,
-		"pptx.layout = 'source'"
+		...printLayoutSetup(ir.slideSize)
 	];
-	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 (theme !== null) 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 = ${theme}`);
 	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.");
+	const assetLines = printAssetBindings(ir, assetNames, assetDir, assetMode, assets.printed, "// 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);
+	return printedScript(lines, ir, assetMode, notes, assets.printed);
 }
 /**
-* The document properties the write API can set.
+* The document properties the write API can set, the ones `DECK_PROPS` in `ir.ts` lists.
 *
-* 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.
+* The rest the read model exposes are 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`);
+	const stamped = DECK_PROP_KEYS.filter((key) => !(key in ir.props));
+	if (stamped.length > 0) scopeNotes(collector, null).note("deck.docPropsDefault", "approximated", "unwritable", `the source deck declares no ${andList(stamped)}, 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)}`)];
 }
@@ -3001,14 +4310,33 @@ function printDocProps(ir, collector) {
 * 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 [];
+	const seeded = ir.chrome.masters.find(isSeedLayout);
+	if (!seeded) scopeNotes(collector, null, uniqueTitle("DEFAULT", new Set(ir.chrome.masters.map((master) => master.props["title"]).filter((t) => typeof t === "string")))).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");
+	const authored = ir.chrome.masters.filter((master) => master !== seeded);
+	if (authored.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))
+		...authored.map((master) => printArguments("pptx.defineSlideMaster", [master.props], 0, printAsset))
 	];
 }
+/**
+* What the layout the write path seeds every presentation with reads back as: blank, titled
+* `DEFAULT`, on the white its master's `p:bgRef` resolves to. `compact` sorts an IR object's keys,
+* so the serialized form is stable.
+*/
+const SEED_LAYOUT_PROPS = JSON.stringify({
+	background: { color: "FFFFFF" },
+	title: "DEFAULT"
+});
+/**
+* Whether a source layout is the one the output's constructor seeds: first in the gallery, where
+* the seed sits, and identical to it. Anything else is re-authored, even a layout named `DEFAULT`,
+* because binding its slides to the seed would lose what sets it apart.
+*/
+function isSeedLayout(master) {
+	return master.layoutIndex === 0 && JSON.stringify(master.props) === SEED_LAYOUT_PROPS;
+}
 /** Every slide, in source order, each bound to the master its source layout became. */
 function printSlides(ir, collector, printAsset) {
 	const byLayout = /* @__PURE__ */ new Map();
@@ -3087,17 +4415,6 @@ const IMPLIED_DEFAULTS = {
 	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);
@@ -3156,7 +4473,11 @@ function collectObjectNames(value, out) {
 * 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 (isAssetRef(value)) {
+		const digest = digests.get(value.$asset);
+		if (digest === void 0) throw new InvalidOptionError("script/unresolved-asset-reference", `Asset reference ${value.$asset} has no entry in DeckIr.assets, so it cannot be compared by content`);
+		return { $asset: digest };
+	}
 	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;
@@ -3175,7 +4496,7 @@ function canonicalValue(value, digests) {
 	return out;
 }
 function isDefaultMargin(value) {
-	return Array.isArray(value) && value.length === DEFAULT_MARGIN.length && value.every((item, index) => item === DEFAULT_MARGIN[index]);
+	return Array.isArray(value) && value.length === BODY_INSET_DEFAULTS_IN.length && value.every((item, index) => item === BODY_INSET_DEFAULTS_IN[index]);
 }
 /**
 * Content digests keyed by asset name, so the same bytes compare equal under any name.
@@ -3198,6 +4519,78 @@ function assetDigests(assets) {
 	return out;
 }
 //#endregion
+//#region src/script/verify/align.ts
+/**
+* ts-pptx: pairing two lists of the same things for comparison.
+*
+* The round trip compares a deck against the deck its script produced, and both the slide
+* calls and the chrome masters have to be paired up before anything can be diffed. Position
+* alone is wrong the moment one item drops out: every later one shifts by one, and the report
+* fills with mismatches that are really one missing shape. So a stable key — a shape's
+* `objectName`, a master's title — aligns what it can, with position as the fallback.
+*
+* Both sides wrote this out, down to two near-identical `nextUnclaimed` closures, and they
+* differed in one respect that matters. `diffChrome`'s own reasoning is recorded there: a
+* mutation that removed layout-title deduplication left two layouts sharing a title and the
+* round trip came back clean, so its key has to identify exactly one item *on both sides*.
+* The call aligner checked the actual side only, and that reasoning was never carried back.
+* This is the both-sides rule, once.
+*/
+/**
+* Pair `expected` with `actual`, keyed where the key is unambiguous and positional elsewhere.
+*
+* The result holds one entry per pairing, in expected order, then one `[null, item]` for each
+* unclaimed actual item. A `[item, null]` means the item was lost; a `[null, item]` means it
+* was added.
+*
+* @param expected - the source deck's items, in document order
+* @param actual - the round-tripped deck's items, in document order
+* @param keyOf - the alignment key, or `null` for an item that has none
+*/
+function alignByKey(expected, actual, keyOf) {
+	const uniqueBy = (items) => {
+		const counts = /* @__PURE__ */ new Map();
+		for (const item of items) {
+			const key = keyOf(item);
+			if (key !== null) counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+		const out = /* @__PURE__ */ new Map();
+		for (const item of items) {
+			const key = keyOf(item);
+			if (key !== null && counts.get(key) === 1) out.set(key, item);
+		}
+		return out;
+	};
+	const byKey = uniqueBy(actual);
+	const expectedKeys = uniqueBy(expected);
+	const claimed = /* @__PURE__ */ new Set();
+	const reserved = /* @__PURE__ */ new Set();
+	for (const before of expected) {
+		const key = keyOf(before);
+		if (key === null || !expectedKeys.has(key)) continue;
+		const named = byKey.get(key);
+		if (named !== void 0) reserved.add(named);
+	}
+	let cursor = 0;
+	const nextUnclaimed = () => {
+		while (cursor < actual.length) {
+			const candidate = actual[cursor++];
+			if (candidate !== void 0 && !claimed.has(candidate) && !reserved.has(candidate)) return candidate;
+		}
+		return null;
+	};
+	const pairs = [];
+	for (const before of expected) {
+		const key = keyOf(before);
+		const named = key !== null && expectedKeys.has(key) ? byKey.get(key) : void 0;
+		const after = named !== void 0 && !claimed.has(named) ? named : nextUnclaimed();
+		if (after !== null && after !== void 0) claimed.add(after);
+		pairs.push([before, after ?? null]);
+	}
+	for (const after of actual) if (!claimed.has(after)) pairs.push([null, after]);
+	return pairs;
+}
+//#endregion
 //#region src/script/verify/diff.ts
 /**
 * The round-trip oracle: does the deck a printed script builds match the deck it was read
@@ -3254,164 +4647,18 @@ 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",
+	"border.type": "a table cell border edge the write path completes; the source’s came from the style graph the read model cannot separate",
+	"border.color": "a table cell border edge the write path completes; the source’s came from the style graph the read model cannot separate",
+	"border.width": "a table cell border edge the write path completes; the source’s came from the style graph the read model cannot separate",
+	"line.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",
+	altText: "a picture with no alt text is described by its image path on the write side",
+	"fill.type": "a fill with no explicit kind takes the write path’s solid default",
+	"line.type": "an outline 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"]
+	...Object.fromEntries(DECK_PROP_KEYS.map((key) => [`props.${key}`, `a deck that declares no ${key} gets the write path’s own`]))
 };
 /**
 * Every note construct this table knows how to match, for a test to check against. The
@@ -3419,7 +4666,7 @@ const NOTE_FIELDS = {
 * which is what a corpus check should use.
 */
 function knownNoteConstructs() {
-	return Object.keys(NOTE_FIELDS).sort();
+	return Object.keys(NOTE_CONSTRUCTS).sort();
 }
 /**
 * Compare the deck a script was generated from against the deck it produced.
@@ -3433,7 +4680,12 @@ 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);
+	diffValue(expected.props, actual.props, "props", "props", {
+		slideNumber: 0,
+		shapeName: null,
+		nestedNames: [],
+		out: differences
+	});
 	diffChrome(expected.chrome, actual.chrome, differences);
 	const slideCount = Math.max(expected.slides.length, actual.slides.length);
 	for (let index = 0; index < slideCount; index++) {
@@ -3458,9 +4710,9 @@ function diffDeckIr(expected, actual, notes) {
 	}
 	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;
+	const accounted = (difference) => difference.declaredBy !== null || difference.kind === "added" && Object.keys(WRITER_DEFAULTS).some((spec) => specCovers(spec, difference, "suffix"));
 	return {
-		slideCount: expected.slides.length,
+		slideCount: Math.max(expected.slides.length, actual.slides.length),
 		differences,
 		undeclared: differences.filter((difference) => !accounted(difference)),
 		declared: differences.filter((difference) => difference.declaredBy !== null),
@@ -3487,7 +4739,12 @@ function diffDeckIr(expected, actual, notes) {
 * 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);
+	diffValue(expected.theme, actual.theme, "chrome.theme", "theme", {
+		slideNumber: 0,
+		shapeName: null,
+		nestedNames: [],
+		out
+	});
 	const report = (path, kind, before, after) => {
 		out.push({
 			slideNumber: 0,
@@ -3501,45 +4758,23 @@ function diffChrome(expected, actual, out) {
 			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;
+	alignByKey(expected.masters, actual.masters, titleOf).forEach(([before, after], index) => {
+		if (before === null) {
+			report(`chrome.masters[${index}]`, "added", void 0, after ?? void 0);
+			return;
 		}
-	};
-	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) {
+		if (after === null) {
 			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);
+		diffValue(before, after, `chrome.masters[${index}]`, "master", {
+			slideNumber: 0,
+			shapeName: null,
+			nestedNames: decorationNames(before, after),
+			out
+		});
 	});
 }
-/** 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.
@@ -3564,8 +4799,13 @@ function diffSlide(expected, actual, out) {
 	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)) {
+	diffValue(expected.transition, actual.transition, "transition", "transition", {
+		slideNumber: number,
+		shapeName: null,
+		nestedNames: [],
+		out
+	});
+	for (const [before, after] of alignByKey(expected.calls, actual.calls, (call) => call.shapeName)) {
 		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)}]`;
@@ -3584,55 +4824,16 @@ function diffSlide(expected, actual, out) {
 			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]);
+		diffValue(before.args, after.args, `${path}.args`, "args", {
+			slideNumber: number,
+			shapeName: name,
+			nestedNames: nested,
+			out
+		});
 	}
-	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) {
+function diffValue(expected, actual, path, field, site) {
+	const { slideNumber, shapeName, nestedNames, out } = site;
 	if (expected === actual) return;
 	const kindOf = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
 	if (kindOf(expected) !== kindOf(actual)) {
@@ -3658,7 +4859,7 @@ function diffValue(expected, actual, path, field, slideNumber, shapeName, nested
 				});
 				continue;
 			}
-			diffValue(before, after, `${path}[${index}]`, field, slideNumber, shapeName, nestedNames, out);
+			diffValue(before, after, `${path}[${index}]`, field, site);
 		}
 		return;
 	}
@@ -3682,7 +4883,7 @@ function diffValue(expected, actual, path, field, slideNumber, shapeName, nested
 				});
 				continue;
 			}
-			diffValue(before, after, `${path}.${key}`, key, slideNumber, shapeName, nestedNames, out);
+			diffValue(before, after, `${path}.${key}`, key, site);
 		}
 		return;
 	}
@@ -3701,15 +4902,73 @@ function scalarDifference(slideNumber, shapeName, nestedNames, path, field, expe
 		declaredBy: null
 	};
 }
+/**
+* The dotted option path a difference sits at, array indices removed: `calls[4].args[1].line.width`
+* becomes `['calls', 'args', 'line', 'width']`.
+*
+* Both exclusion mechanisms used to match the terminal key alone, at any depth anywhere in the
+* IR — so `type` (written about a fill's solid default) excused an added `bullet.type`, waving
+* through a character bullet that came back as a numbered list; `title` (written about
+* `docProps`) excused an added chart title; and `width` (written about `a:ln/@w`) excused an
+* added table-cell bevel or border width. Matching a suffix keeps every bare key working where
+* it is unambiguous and lets a spec say WHICH `width` it means.
+*/
+function pathKeys(difference) {
+	const keys = difference.path.split(".").map((segment) => segment.replace(/\[[^\]]*\]/g, ""));
+	return keys[keys.length - 1] === difference.field ? keys : [...keys, difference.field];
+}
+/**
+* Whether one exclusion spec covers a difference. `'*'` covers everything in the note's scope.
+* Anything else is matched against the difference's own path in one of two modes:
+*
+* - `'suffix'`: the spec is a dotted SUFFIX of the path. Used for a note scoped to a shape, which
+*   the shape scoping has already confined to one call, so the spec only has to say which option
+*   inside it. Used for {@link WRITER_DEFAULTS} too, whose entries are option names wherever the
+*   write path materialises them.
+* - `'root'`: the spec is the dotted path of one node from the root of the diff (`background`,
+*   `chrome.masters.title`), and covers that node only. A trailing `.*` extends it to everything
+*   beneath the node as well (`transition.sound.*`). Used for a note with no shape, which nothing
+*   else confines. Matched as a suffix, a slide or deck note's field names matched inside every
+*   call in its scope: `master.background`'s `color` excused every run colour in the deck, and
+*   `slide.transitionSound`'s `$asset` excused different image bytes on its slide. Exact by
+*   default because `slide.transition` is `transition` and must not cover the sound inside it.
+*/
+function specCovers(spec, difference, anchor) {
+	if (spec === "*") return true;
+	const wanted = spec.split(".");
+	const keys = pathKeys(difference);
+	if (anchor === "root") {
+		const subtree = wanted[wanted.length - 1] === "*";
+		const node = subtree ? wanted.slice(0, -1) : wanted;
+		if (subtree ? node.length > keys.length : node.length !== keys.length) return false;
+		return node.every((segment, index) => segment === keys[index]);
+	}
+	if (wanted.length > keys.length) return false;
+	return wanted.every((segment, index) => segment === keys[keys.length - wanted.length + index]);
+}
+/**
+* Whether the shape a shape-scoped note names is the one a difference sits on: the call itself, or
+* a group child inside it.
+*
+* A shape with no name of its own is scoped as `''`, and its call carries no name to match, so a
+* note on one covers the unnamed calls on its slide and nothing else. Not a named shape, and not
+* the slide's own keys either, which a `*` note would otherwise excuse. An unnamed group child is
+* not matched through its group: the group's call names no such child.
+*/
+function coversShape(shapeName, difference) {
+	if (shapeName === "") return difference.shapeName === null && difference.path.startsWith("calls[");
+	return shapeName === difference.shapeName || difference.nestedNames.includes(shapeName);
+}
 /** 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;
+		if (note.shapeName !== null && !coversShape(note.shapeName, difference)) continue;
 		const fields = noteFields(note.construct);
 		if (!fields) continue;
-		if (fields.includes("*") || fields.includes(difference.field)) return note;
+		const anchor = note.shapeName === null ? "root" : "suffix";
+		if (fields.some((field) => specCovers(field, difference, anchor))) return note;
 	}
 	return null;
 }
@@ -3721,7 +4980,8 @@ function declaringNote(difference, notes) {
 * 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);
+	const table = NOTE_CONSTRUCTS;
+	return table[construct]?.fields ?? (construct.startsWith("layout.") ? table[construct.slice(7)]?.fields : void 0);
 }
 /**
 * `true` when the coverage table can match this construct — directly or through the
@@ -3736,6 +4996,6 @@ function brief(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 };
+export { InternalError, InvalidOptionError, LAYOUT_NOTE_PREFIX, MediaError, PackageReadError, TsPptxError, UnsupportedFeatureError, canonicalDeckIr, diffDeckIr, isAssetRef, isKnownNoteConstruct, knownNoteConstructs, printScript, printStandaloneScript, readModelToIr, resetDiagnosticState, setDiagnosticHandler };
 
 //# sourceMappingURL=script.js.map