@hueest/xray 0.6.0 → 0.7.0

package/dist/client.js

@@ -1,45 +1,4 @@
-import { a as serializePlate, d as formatDiagnostic, f as makeDiagnostic, l as runPlatePasses, n as deriveBreakpoints, o as CaptureTooLargeError, p as emit, r as regimeFor, s as captureView, t as serializePlateIR, u as diagnosticsHeader } from "./project-BAXKpnfF.js";
-//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js
-/**	@type {(array_buffer: ArrayBuffer) => string} */
-function encode_native(array_buffer) {
-	return new Uint8Array(array_buffer).toBase64();
-}
-/**	@type {(base64: string) => ArrayBuffer} */
-function decode_native(base64) {
-	return Uint8Array.fromBase64(base64).buffer;
-}
-/** @type {(array_buffer: ArrayBuffer) => string} */
-function encode_buffer(array_buffer) {
-	return Buffer.from(array_buffer).toString("base64");
-}
-/**	@type {(base64: string) => ArrayBuffer} */
-function decode_buffer(base64) {
-	return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
-}
-/** @type {(array_buffer: ArrayBuffer) => string} */
-function encode_legacy(array_buffer) {
-	const array = new Uint8Array(array_buffer);
-	let binary = "";
-	const chunk_size = 32768;
-	for (let i = 0; i < array.length; i += chunk_size) {
-		const chunk = array.subarray(i, i + chunk_size);
-		binary += String.fromCharCode.apply(null, chunk);
-	}
-	return btoa(binary);
-}
-/**	@type {(base64: string) => ArrayBuffer} */
-function decode_legacy(base64) {
-	const binary_string = atob(base64);
-	const len = binary_string.length;
-	const array = new Uint8Array(len);
-	for (let i = 0; i < len; i++) array[i] = binary_string.charCodeAt(i);
-	return array.buffer;
-}
-const native = typeof Uint8Array.fromBase64 === "function";
-const buffer = typeof process === "object" && process.versions?.node !== void 0;
-const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
-const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
-//#endregion
+import { a as serializePlate, d as formatDiagnostic, f as makeDiagnostic, l as distilPlate, n as deriveBreakpoints, o as CaptureTooLargeError, p as emit, r as viewSpanFor, s as captureView, t as serializePlateIR, u as diagnosticsHeader } from "./serialize-Cj-EHvMv.js";
 //#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/constants.js
 const MAX_ARRAY_LEN = 2 ** 32 - 1;
 const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
@@ -149,6 +108,47 @@ function valid_array_indices(array) {
 	return keys;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_native(base64) {
+	return Uint8Array.fromBase64(base64).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString("base64");
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_buffer(base64) {
+	return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = "";
+	const chunk_size = 32768;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
+	return btoa(binary);
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_legacy(base64) {
+	const binary_string = atob(base64);
+	const len = binary_string.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binary_string.charCodeAt(i);
+	return array.buffer;
+}
+const native = typeof Uint8Array.fromBase64 === "function";
+const buffer = typeof process === "object" && process.versions?.node !== void 0;
+const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
+//#endregion
 //#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/parse.js
 /**
 * Revive a value serialized with `devalue.stringify`
@@ -257,7 +257,8 @@ function unflatten(parsed, revivers) {
 				case "ArrayBuffer": {
 					const base64 = value[1];
 					if (typeof base64 !== "string") throw new Error("Invalid ArrayBuffer encoding");
-					hydrated[index] = decode64(base64);
+					const arraybuffer = decode64(base64);
+					hydrated[index] = arraybuffer;
 					break;
 				}
 				case "Temporal.Duration":
@@ -272,12 +273,16 @@ function unflatten(parsed, revivers) {
 					hydrated[index] = Temporal[temporalName].from(value[1]);
 					break;
 				}
-				case "URL":
-					hydrated[index] = new URL(value[1]);
+				case "URL": {
+					const url = new URL(value[1]);
+					hydrated[index] = url;
 					break;
-				case "URLSearchParams":
-					hydrated[index] = new URLSearchParams(value[1]);
+				}
+				case "URLSearchParams": {
+					const url = new URLSearchParams(value[1]);
+					hydrated[index] = url;
 					break;
+				}
 				default: throw new Error(`Unknown type ${type}`);
 			}
 		} else if (value[0] === -7) {
@@ -526,17 +531,15 @@ function stringify_primitive(thing) {
 	return String(thing);
 }
 //#endregion
-//#region src/flash.ts
+//#region src/blink.ts
 /**
-* Dev-only radiographic capture effect — pure delight. When a capture lands (and
-* actually CHANGES the stored result) we briefly "expose" the captured element: a
-* negative blink (an x-ray IS a negative — `backdrop-filter: invert`) that enters
-* SHARPLY and fades a touch slower, framed by a soft shadow ring around the box so
-* you can see WHICH area was captured. Short and quiet — it's feedback that a
-* resize/navigation (or the capture-all sweep) recorded something, not a light show.
-* Honors `prefers-reduced-motion` (then just a shadow pulse, no invert). A transient
-* `position: fixed`, `pointer-events: none` overlay just under the HUD; it never
-* touches the capture pipeline or the captured DOM.
+* The BLINK: the dev-only visual that confirms a capture landed and actually CHANGED the stored
+* result. It briefly "exposes" the captured element: a negative invert (`backdrop-filter: invert` —
+* an x-ray is a negative) that enters sharply and fades slower, framed by a soft shadow ring so the
+* captured area is visible. Feedback, not a light show. Under `prefers-reduced-motion` the invert
+* is dropped and only the shadow pulses. Rendered as a transient `position: fixed`,
+* `pointer-events: none` overlay just under the HUD; it never touches the capture pipeline or the
+* captured DOM.
 */
 const STYLE_ID = "xr-flash-style";
 const DURATION_MS = 300;
@@ -585,8 +588,8 @@ function boxOf(el) {
 	}
 	return Number.isFinite(left) ? new DOMRect(left, top, right - left, bottom - top) : null;
 }
-/** Flash the radiographic effect over `el`'s box. No-op outside a laid-out DOM. */
-function flashCapture(el) {
+/** Blink the radiographic effect over `el`'s box. No-op outside a laid-out DOM. */
+function blinkCapture(el) {
 	if (typeof document === "undefined") return;
 	const box = boxOf(el);
 	if (!box) return;
@@ -612,17 +615,14 @@ const DEFAULT_MAX_BREADTH = 512;
 const deriveMaxNodes = (maxBreadth, maxDepth) => Math.round(maxBreadth * maxDepth / 4);
 const RESIZE_DEBOUNCE = 300;
 /**
-* The capture roots for a site, the ONE place the auto/manual root models
-* diverge (ADR 0014, finding #6).
+* The capture roots for a site, the ONE place the auto/manual root models diverge (ADR 0014).
 *
-* - AUTO: `site.el` is the `display:contents` wrapper, a layout-neutral box, so
-*   the content is its CHILDREN — the synthetic root (id 0) stands in for the
-*   wrapper and the children become the plate's top level (today's behavior).
-*   `<STYLE>` children are dropped (a stitched-in scoped sheet, never content).
-* - MANUAL: `site.el` is the consumer's OWN styled element, so the element
-*   ITSELF is the root. Capturing its children would drop its box, classes,
-*   padding, border, background, and radius — the exact bug this fixes — so the
-*   element is the single root and its own box is serialized.
+* - AUTO: `site.el` is the `display:contents` wrapper, a layout-neutral box, so the content is its
+*   CHILDREN — the synthetic root (id 0) stands in for the wrapper and the children become the
+*   plate's top level. `<STYLE>` children are dropped (a stitched-in scoped sheet, never content).
+* - MANUAL: `site.el` is the consumer's OWN styled element, so the element ITSELF is the root.
+*   Capturing its children would drop its box, classes, padding, border, background, and radius —
+*   so the element is the single root and its own box is serialized.
 */
 function rootsFor(site) {
 	if (site.mode === "manual") return [site.el];
@@ -681,7 +681,8 @@ function installXrayClient(options) {
 	};
 	const lightbox = createToggleStore(win, LIGHTBOX_KEY, LIGHTBOX_PARAM, false);
 	const captureEnabled = createToggleStore(win, CAPTURE_KEY, CAPTURE_PARAM, options.capture ?? false);
-	const replayEnabled = createToggleStore(win, REPLAY_KEY, REPLAY_PARAM, options.replay === "prefer" || options.replay === "missing-only");
+	const replayBoot = options.replay === "prefer" || options.replay === "missing-only";
+	const replayEnabled = createToggleStore(win, REPLAY_KEY, REPLAY_PARAM, replayBoot);
 	const replayMode = options.replay === "missing-only" ? "missing-only" : "prefer";
 	const recordMode = options.record ?? "manual";
 	const isPrimaryForName = (site) => {
@@ -692,22 +693,20 @@ function installXrayClient(options) {
 		return true;
 	};
 	/**
-	* Measure one View into a LOCAL, fresh 1-View `PlateIR` (no shared bundle) and
-	* return it only if the generation guard still holds AFTER the settle — the
-	* heart of the ADR 0022 generation-guard preservation (plan §4). Because
-	* `captureView(roots, plate)` MUTATES the passed bundle in place
-	* (`plate.views.push`), a stale capture appended to a SHARED session PlateIR
-	* would corrupt the whole Plate's projection (one width's geometry under
-	* another's island/gate), and post-hoc rollback is impossible. So we capture
-	* into a local bundle FIRST, re-check the guard, and only the caller splices the
-	* survivor into the session bundle. Returns the local View on success, or
-	* `undefined` when the guard moved / the capture was refused / the site was torn
-	* down — the caller then DISCARDS it (never appends).
+	* Measure one View into a LOCAL, fresh 1-View `PlateIR` (no shared bundle) and return it only if
+	* the generation guard still holds AFTER the settle (the generation guard, ADR 0025; ADR 0022
+	* §4). Because `captureView(roots, plate)` MUTATES the passed bundle in place
+	* (`plate.views.push`), a stale capture appended to a SHARED session PlateIR would corrupt the
+	* whole Plate's projection (one width's geometry under another's island/gate), and post-hoc
+	* rollback is impossible. So the capture goes into a local bundle FIRST, the guard is re-checked,
+	* and only the caller splices the survivor into the session bundle. Returns the local View on
+	* success, or `undefined` when the guard moved / the capture was refused / the site was torn down
+	* — the caller then DISCARDS it (never appends).
 	*
 	* `generation` is the token snapshotted by the caller BEFORE the settle; a
-	* width-change/disposal/uninstall mid-settle moves `captureGeneration` and this
-	* returns undefined. A `CaptureTooLargeError` marks the site and warns. Any
-	* other failure warns and returns undefined.
+	* width-change/disposal/uninstall mid-settle moves `captureGeneration` and this returns
+	* undefined. A `CaptureTooLargeError` marks the site and warns. Any other failure warns and
+	* returns undefined.
 	*/
 	const captureLocalView = async (site, generation) => {
 		await settle(site.el, site.delay, settleCap, site.mode);
@@ -736,13 +735,13 @@ function installXrayClient(options) {
 		if (generation !== captureGeneration || site.disposed) return void 0;
 		return view;
 	};
-	const recording = /* @__PURE__ */ new Map();
-	const recordingBreakpoints = (buf) => [...new Set([...buf.views.flatMap((v) => v.bpSeed ?? []), ...deriveBreakpoints([], [...matchMediaQueries])])].toSorted((a, b) => a - b);
-	const projectRecording = (buf) => {
+	const sessionBuffers = /* @__PURE__ */ new Map();
+	const sessionBreakpoints = (buf) => [.../* @__PURE__ */ new Set([...buf.views.flatMap((v) => v.bpSeed ?? []), ...deriveBreakpoints([], [...matchMediaQueries])])].toSorted((a, b) => a - b);
+	const projectSessionBuffer = (buf) => {
 		if (buf.views.length === 0) return void 0;
-		const breakpoints = recordingBreakpoints(buf);
+		const breakpoints = sessionBreakpoints(buf);
 		const perBand = /* @__PURE__ */ new Map();
-		for (const view of buf.views) perBand.set(regimeFor(view.width, breakpoints).min ?? 0, view);
+		for (const view of buf.views) perBand.set(viewSpanFor(view.width, breakpoints).min ?? 0, view);
 		const views = [...perBand.values()].toSorted((a, b) => a.width - b.width);
 		return serializePlateIR({
 			name: buf.name,
@@ -750,16 +749,16 @@ function installXrayClient(options) {
 			breakpoints
 		});
 	};
-	const previewRecording = (buf) => {
-		const stored = projectRecording(buf);
+	const previewSession = (buf) => {
+		const stored = projectSessionBuffer(buf);
 		if (!stored) return false;
 		return updatePlate(buf.name, serializePlate(stored));
 	};
-	const finalizeRecording = async () => {
-		const entries = [...recording];
-		recording.clear();
+	const finalizeSession = async () => {
+		const entries = [...sessionBuffers];
+		sessionBuffers.clear();
 		await Promise.all(entries.map(async ([name, buf]) => {
-			const stored = projectRecording(buf);
+			const stored = projectSessionBuffer(buf);
 			if (!stored) return;
 			const diagnostics = buf.views.flatMap((v) => v.diagnostics ?? []);
 			const envelope = {
@@ -769,8 +768,8 @@ function installXrayClient(options) {
 			try {
 				await options.sink(envelope);
 			} catch (error) {
-				if (!recording.has(name)) recording.set(name, buf);
-				console.warn(`[xray] recording write failed for "${name}" — kept in memory; retried when you next start a recording`, error);
+				if (!sessionBuffers.has(name)) sessionBuffers.set(name, buf);
+				console.warn(`[xray] capture-session write failed for "${name}" — kept in memory; retried when you next start a session`, error);
 			}
 		}));
 	};
@@ -788,40 +787,38 @@ function installXrayClient(options) {
 		}
 		if (!captureEnabled.get()) return;
 		view.bpSeed = deriveBreakpoints(emit(view.bundle).rules, []);
-		runPlatePasses({
+		distilPlate({
 			name: site.name,
 			views: [view],
 			breakpoints: []
 		});
-		let buf = recording.get(site.name);
+		let buf = sessionBuffers.get(site.name);
 		if (!buf) {
 			buf = {
 				name: site.name,
 				views: [],
 				breakpoints: []
 			};
-			recording.set(site.name, buf);
+			sessionBuffers.set(site.name, buf);
 		}
 		buf.views = buf.views.filter((v) => v.width !== view.width);
 		buf.views.push(view);
-		if (previewRecording(buf)) flashCapture(site.el);
+		if (previewSession(buf)) blinkCapture(site.el);
 	};
 	/**
-	* Project a per-site `PlateIR` to the structured `StoredPlate` IN THE BROWSER
-	* (the ADR 0022 Serialize) and hand the envelope to the sink. Derives the
-	* breakpoint union ONCE over every View's rules + the recorded matchMedia
-	* queries (relocating the old per-View derivation), runs the reduction passes
-	* once over the whole bundle, then `serializePlateIR`. Dedupes per-PLATE by the
-	* serialized StoredPlate string. ALWAYS catches so neither mode leaks an
-	* unhandled rejection; on failure it clears the dedupe so a retry re-sends and,
-	* ONLY when `awaitSink`, rethrows so capture-all still fails loudly (pieces
-	* 3/8). The radiographic flash runs only AFTER a successful send.
+	* Project a per-site `PlateIR` to the structured `StoredPlate` IN THE BROWSER (the ADR 0022
+	* Serialize) and hand the envelope to the sink. Derives the breakpoint union ONCE over every
+	* View's rules + the recorded matchMedia queries, runs the Distil passes once over the whole
+	* bundle, then `serializePlateIR`. Dedupes per-PLATE by the serialized StoredPlate string. ALWAYS
+	* catches so neither mode leaks an unhandled rejection; on failure it clears the dedupe so a
+	* retry re-sends and, ONLY when `awaitSink`, rethrows so capture-all still fails loudly. The
+	* Blink runs only AFTER a successful send.
 	*/
 	const sendPlate = async (site, plate, awaitSink) => {
 		if (plate.views.length === 0) return;
 		plate.name = site.name;
 		plate.breakpoints = deriveBreakpoints(plate.views.flatMap((v) => emit(v.bundle).rules), [...matchMediaQueries]);
-		runPlatePasses(plate);
+		distilPlate(plate);
 		const stored = serializePlateIR(plate);
 		const diagnostics = plate.views.flatMap((v) => v.diagnostics ?? []);
 		const envelope = {
@@ -839,13 +836,13 @@ function installXrayClient(options) {
 			console.warn("[xray] capture send failed for", site.name, error);
 			return;
 		}
-		flashCapture(site.el);
+		blinkCapture(site.el);
 	};
 	/**
-	* Finalize a site's accumulated sweep `PlateIR` and POST it ONCE (awaited, the
-	* backpressure point). Clears `site.sessionPlate` first so any straggler capture
-	* for the site falls back to the browse path rather than mutating the bundle
-	* mid-flight. A session that captured no surviving View posts nothing.
+	* Finalize a site's accumulated sweep `PlateIR` and POST it ONCE (awaited, the backpressure
+	* point). Clears `site.sessionPlate` first so any straggler capture for the site falls back to
+	* the browse path rather than mutating the bundle mid-flight. A session that captured no
+	* surviving View posts nothing.
 	*/
 	const finalizeSessionPlate = async (site) => {
 		const session = site.sessionPlate;
@@ -889,15 +886,15 @@ function installXrayClient(options) {
 		}, RESIZE_DEBOUNCE);
 	};
 	win.addEventListener("resize", onResize);
-	let recordingOn = captureEnabled.get();
+	let sessionOn = captureEnabled.get();
 	const unsubscribeCapture = captureEnabled.subscribe(() => {
 		const on = captureEnabled.get();
-		if (on === recordingOn) return;
-		recordingOn = on;
+		if (on === sessionOn) return;
+		sessionOn = on;
 		if (on) {
-			finalizeRecording();
+			finalizeSession();
 			for (const site of sites) scheduleCapture(site);
-		} else finalizeRecording();
+		} else finalizeSession();
 	});
 	const extAcks = /* @__PURE__ */ new Map();
 	let nextExtReqId = 1;
@@ -999,7 +996,7 @@ function installXrayClient(options) {
 		const breakpoints = [...set].toSorted((a, b) => a - b);
 		const min = breakpoints[0];
 		const first = min === void 0 ? 390 : Math.max(1, Math.min(390, min - 1));
-		return [...new Set([first, ...breakpoints])].toSorted((a, b) => a - b);
+		return [.../* @__PURE__ */ new Set([first, ...breakpoints])].toSorted((a, b) => a - b);
 	};
 	const MAX_SWEEP_PASSES = 8;
 	const captureAllViews = async () => {
@@ -1082,12 +1079,11 @@ function installXrayClient(options) {
 	};
 }
 /**
-* Surface a capture's dev-only diagnostics as ONE grouped `console.warn` keyed
-* by plate name: a header line, then one formatted line per diagnostic via the
-* shared formatter (diagnostics.ts) — the same text the Vite server prints, so
-* the two never drift. `console.group` collapses the lines under the header;
-* we fall back to a single multi-line warn where it's unavailable. No-op when
-* there are no diagnostics, so a clean capture is silent.
+* Surface a capture's dev-only diagnostics as ONE grouped `console.warn` keyed by plate name: a
+* header line, then one formatted line per diagnostic via the shared formatter (diagnostics.ts) —
+* the same text the Vite server prints, so the two never drift. `console.group` collapses the lines
+* under the header, falling back to a single multi-line warn where unavailable. No-op when there
+* are no diagnostics, so a clean capture is silent.
 */
 function reportDiagnostics(name, diagnostics) {
 	if (!diagnostics || diagnostics.length === 0) return;
@@ -1108,10 +1104,9 @@ const CAPTURE_PARAM = "xray-capture";
 const REPLAY_KEY = "xray:replay";
 const REPLAY_PARAM = "xray-replay";
 /**
-* A sticky boolean toggle: per-tab in sessionStorage, seedable to `true` via
-* `?<param>` in the URL, flipped from the HUD or the console
-* (`__XRAY__.lightbox.set(true)`). A stored value wins over `initial`; the
-* URL param forces `true`.
+* A sticky boolean toggle: per-tab in sessionStorage, seedable to `true` via `?<param>` in the URL,
+* flipped from the HUD or the console (`__XRAY__.lightbox.set(true)`). A stored value wins over
+* `initial`; the URL param forces `true`.
 */
 function createToggleStore(win, key, param, initial) {
 	let value = initial;
@@ -1140,17 +1135,15 @@ function createToggleStore(win, key, param, initial) {
 	};
 }
 /**
-* Resolve once the subtree has been quiet (no mutations, no child resizes)
-* for `delay` ms — fonts loaded first. Charts, lazy images and late embeds
-* made single-shot capture non-deterministic in the M1 harness; this is the
-* cure. Hard-capped so a perpetually-animating subtree still captures.
+* Resolve once the subtree has been quiet (no mutations, no child resizes) for `delay` ms — fonts
+* loaded first. Charts, lazy images and late embeds made single-shot capture non-deterministic in
+* the M1 harness; this is the cure. Hard-capped so a perpetually-animating subtree still captures.
 */
 /**
-* Force lazy images in the subtree to load and await their decode, so the walk
-* measures their real boxes. A `loading="lazy"` image below the fold never enters
-* the viewport during capture, so its IntersectionObserver never fires — flip it
-* to eager to trigger the load. Capped: a slow or broken image resolves the race
-* via the timeout instead of blocking the capture.
+* Force lazy images in the subtree to load and await their decode, so the walk measures their real
+* boxes. A `loading="lazy"` image below the fold never enters the viewport during capture, so its
+* IntersectionObserver never fires — flip it to eager to trigger the load. Capped: a slow or broken
+* image resolves the race via the timeout instead of blocking the capture.
 */
 function awaitImages(root, cap) {
 	const imgs = Array.from(root.querySelectorAll("img"));

package/dist/core.d.ts

@@ -1,66 +1,56 @@
-import { _ as ViewCapture, a as CollectAxis, c as XrayCaptureWalker, d as LeafKind, f as MergedPlate, h as RenderNode, i as CaptureWalkerContext, l as defineXrayCaptureWalker, m as PlateNode, n as CaptureSize, o as CollectLimits, p as Plate, r as CaptureTooLargeError, s as WalkerDecision, t as CaptureOptions, u as BASE_CSS, v as composeCss, y as emptyPlate } from "./serialize-BqbQVxYl.js";
-
+import { _ as ViewCapture, a as CollectAxis, c as XrayCaptureWalker, d as GatedPlate, f as LeafKind, h as RenderNode, i as CaptureWalkerContext, l as defineXrayCaptureWalker, m as PlateNode, n as CaptureSize, o as CollectLimits, p as Plate, r as CaptureTooLargeError, s as WalkerDecision, t as CaptureOptions, u as BASE_CSS, v as composeCss, y as emptyPlate } from "./measure-CUQxB-Ic.js";
 //#region src/chunk.d.ts
 /**
- * Turn a merged plate (RenderNode tree) into the shipped plate (chunks). The
- * root's own content classes travel as `rootCls` (the adapter puts them on the
- * root element); its children become `chunks`. A capture-less plate has null
- * chunks and renders the fallback.
+ * Turn a merged plate (RenderNode tree) into the shipped plate (chunks). The root's own content
+ * classes travel as `rootCls` (the adapter puts them on the root element); its children become
+ * `chunks`. A capture-less plate has null chunks and renders the fallback.
  *
- * Two-artifact contract (plan 005 round 2): the returned `Plate` is the TREE
- * artifact only — the input's `css` is deliberately NOT copied onto it. The
- * css string stays the producer's (`MergedPlate`/`StoredPlate`) field; each
- * lowering site decides independently how its css travels (the plugin's
- * virtual `.css` modules + `export const css`, `captureElement`'s
- * `{ plate, css }` pair, or the `xray:plate` dev event, which ships no css).
+ * Two-artifact contract (ADR 0026): the returned `Plate` is the TREE artifact only; the input's
+ * `css` is deliberately NOT copied onto it. The css string stays the producer's
+ * (`GatedPlate`/`StoredPlate`) field, and each lowering site decides independently how its css
+ * travels: the plugin's virtual `.css` modules + `export const css`, `captureElement`'s `{ plate,
+ * css }` pair, or the `xray:plate` dev event, which ships no css.
  */
-declare function serializePlate(merged: MergedPlate): Plate;
+declare function serializePlate(merged: GatedPlate): Plate;
 /**
- * Distinct plate names referenced by the tree's stitches, in first-seen order.
- * Walks a `RenderNode` tree (the stored, post-classify shape), so it drives the
- * gen-side stitch import graph straight off a `StoredPlate.tree`
- * (`renderPlateModule`, index.ts). Relocated here from the now-deleted `merge.ts`
- * in the ADR 0022 cutover — it is the one node-side primitive that survived the
- * `mergeViews`/`addCapture` removal (the multi-View merge/gate now lives in the
- * in-browser `serializePlateIR`, project.ts).
+ * Distinct plate names referenced by the tree's stitches, in first-seen order. Walks a `RenderNode`
+ * tree (the stored, post-classify shape), so it drives the gen-side stitch import graph straight
+ * off a `StoredPlate.tree` (`renderPlateModule`, index.ts). The one node-side primitive needed at
+ * build time; multi-View gating happens in the in-browser `serializePlateIR` (serialize.ts, ADR
+ * 0022).
  */
 declare function collectRefs(tree: RenderNode | null): string[];
 //#endregion
 //#region src/core.d.ts
 /**
- * Capture a live DOM subtree straight to the two renderable artifacts: the
- * structural `plate` (tree, lowered to chunks) and its scoped `css` string —
- * independent parts, per the two-artifact contract. Runs the same uniform
- * pipeline the dev client does for a single View — measure (`captureView`),
- * reduce (`runPlatePasses`), project (`serializePlateIR` → the structured
- * `StoredPlate`), then lower to chunks (`serializePlate`) — in one call.
- * `roots` are the top-level elements to capture (a component's rendered
- * roots). Render however suits: `renderPlateHtml(plate, composeCss(css))`,
- * or `<Skeleton plate={plate} css={composeCss(css)}>` with the React adapter.
+ * Capture a live DOM subtree straight to the two renderable artifacts: the structural `plate`
+ * (tree, lowered to chunks) and its scoped `css` string — independent parts, per the two-artifact
+ * contract. Runs the same uniform pipeline the dev client does for a single View — measure
+ * (`captureView`), distil (`distilPlate`), project (`serializePlateIR` → the structured
+ * `StoredPlate`), then lower to chunks (`serializePlate`) — in one call. `roots` are the top-level
+ * elements to capture (a component's rendered roots). Render however suits: `renderPlateHtml(plate,
+ * composeCss(css))`, or `<Skeleton plate={plate} css={composeCss(css)}>` with the React adapter.
  *
- * `options.walker` is the public programmable capture walker (ADR 0018, Q2 —
- * yes, public): the same `XrayCaptureWalker` the `<Skeleton captureWalker>` prop
- * threads through in dev, available here for driving capture directly. It is
- * capture-only and never persisted into the returned artifacts.
+ * `options.walker` is the public programmable capture walker (ADR 0018): the same
+ * `XrayCaptureWalker` the `<Skeleton captureWalker>` prop threads through in dev, available here
+ * for driving capture directly. It is capture-only and never persisted into the returned
+ * artifacts.
  */
 declare function captureElement(roots: readonly Element[], options: CaptureOptions): {
   plate: Plate;
   css: string;
 };
 /**
- * Render a stitch-free Plate to an HTML string — the framework-neutral
- * equivalent of `<Skeleton plate loading />`, for when you don't want to pull
- * a framework adapter (demos, plain DOM, server strings). Drop it in with
- * `el.innerHTML = renderPlateHtml(plate, composeCss(css))` or React's
+ * Render a stitch-free Plate to an HTML string — the framework-neutral equivalent of `<Skeleton
+ * plate loading />`, for when you don't want to pull a framework adapter (demos, plain DOM, server
+ * strings). Drop it in with `el.innerHTML = renderPlateHtml(plate, composeCss(css))` or React's
  * `dangerouslySetInnerHTML`.
  *
- * `css` is the caller's explicit input (two-artifact contract): pass
- * `composeCss(css)` for the standard BASE_CSS + plate-rules composition
- * (BASE_CSS is what makes bones paint and pulse), the raw capture css if the
- * base rules are already on the page, or your own composition. Stitched
- * plates (a nested `<Skeleton>`) need an adapter to mount their child plates,
- * so they throw here.
+ * `css` is the caller's explicit input (two-artifact contract): pass `composeCss(css)` for the
+ * standard BASE_CSS + plate-rules composition (BASE_CSS is what makes bones paint and pulse), the
+ * raw capture css if the base rules are already on the page, or your own composition. Stitched
+ * plates (a nested `<Skeleton>`) need an adapter to mount their child plates, so they throw here.
  */
 declare function renderPlateHtml(plate: Plate, css: string): string;
 //#endregion
-export { BASE_CSS, type CaptureOptions, type CaptureSize, CaptureTooLargeError, type CaptureWalkerContext, type CollectAxis, type CollectLimits, type LeafKind, type MergedPlate, type Plate, type PlateNode, type ViewCapture, type WalkerDecision, type XrayCaptureWalker, captureElement, collectRefs, composeCss, defineXrayCaptureWalker, emptyPlate, renderPlateHtml, serializePlate };
+export { BASE_CSS, type CaptureOptions, type CaptureSize, CaptureTooLargeError, type CaptureWalkerContext, type CollectAxis, type CollectLimits, type GatedPlate, type LeafKind, type Plate, type PlateNode, type ViewCapture, type WalkerDecision, type XrayCaptureWalker, captureElement, collectRefs, composeCss, defineXrayCaptureWalker, emptyPlate, renderPlateHtml, serializePlate };