@hueest/xray 0.2.0 → 0.4.0

package/dist/{react.core-IyFy2b_8.js → react.core-DMIhXHZF.js}

@@ -1,4 +1,4 @@
-import { a as ROOT_ATTR, o as ROOT_CLASS, s as ROOT_INSTANT_ATTR, t as BASE_CSS } from "./plate-DoE1HEXp.js";
+import { a as ROOT_ATTR, o as ROOT_CLASS, s as ROOT_INSTANT_ATTR, t as BASE_CSS } from "./plate-BRR6d8Se.js";
 import { t as escapeStyleText } from "./css-escape-N7bOusGW.js";
 import { Fragment, useEffect, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -74,6 +74,7 @@ function collectStitchNames(chunks) {
 	const walk = (cs) => {
 		for (const chunk of cs) {
 			if (typeof chunk === "string") continue;
+			if ("t" in chunk) continue;
 			if ("r" in chunk) names.push(chunk.r);
 			else walk(chunk.k);
 		}
@@ -256,6 +257,10 @@ function renderChunks(chunks, resolveStitch) {
 			style: DISPLAY_CONTENTS,
 			dangerouslySetInnerHTML: { __html: chunk }
 		}, i);
+		if ("t" in chunk) return /* @__PURE__ */ jsx("div", {
+			style: DISPLAY_CONTENTS,
+			dangerouslySetInnerHTML: { __html: chunk.t.repeat(chunk.n) }
+		}, i);
 		if ("r" in chunk) return /* @__PURE__ */ jsx(Fragment, { children: resolveStitch(chunk.r) }, i);
 		return /* @__PURE__ */ jsx("div", {
 			className: chunk.c,

package/dist/{react.core-BzMG_cDy.d.ts → react.core-NhWc9qan.d.ts}

@@ -1,5 +1,4 @@
-import { r as Plate } from "./plate-Bv6W-GkA.js";
-import { o as XrayCaptureWalker } from "./serialize-B--oY2bV.js";
+import { c as XrayCaptureWalker, f as Plate } from "./serialize-BgdGt34A.js";
 import { ReactNode } from "react";
 
 //#region src/react.core.d.ts
@@ -44,10 +43,21 @@ interface SkeletonBase {
    * The escape hatch beyond the declarative `data-xr-*` annotations: a closure
    * that decides, per element, whether to ignore it, collapse it to one Bone, or
    * defer to the built-in walk. Threaded through the dev adapter into
-   * `captureRegime`; PRODUCTION ignores it entirely (it never captures). On both
+   * `captureView`; PRODUCTION ignores it entirely (it never captures). On both
    * `root` variants of the union, so a manual root may carry one too.
    */
   captureWalker?: XrayCaptureWalker;
+  /**
+   * Per-Skeleton Collect limits (ADR 0022, dev only): override the plugin's
+   * `collect` defaults for THIS boundary's capture. Flat primitives — not a nested
+   * object — so they stay referentially stable across renders and never churn the
+   * dev capture effect's deps. `maxNodes` caps total surviving nodes, `maxBreadth`
+   * the widest level, `maxDepth` the nesting depth; an omitted `maxNodes` derives
+   * from the resolved breadth × depth. PRODUCTION ignores them (it never captures).
+   */
+  maxNodes?: number;
+  maxBreadth?: number;
+  maxDepth?: number;
 }
 /**
  * Props accepted by the React `<Skeleton>` component, generic over the optional

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { t as SkeletonProps } from "./react.core-BzMG_cDy.js";
+import { t as SkeletonProps } from "./react.core-NhWc9qan.js";
 
 //#region src/react.d.ts
 /**

package/dist/react.dev.d.ts

@@ -1,4 +1,4 @@
-import { t as SkeletonProps } from "./react.core-BzMG_cDy.js";
+import { t as SkeletonProps } from "./react.core-NhWc9qan.js";
 
 //#region src/react.dev.d.ts
 /**

package/dist/react.dev.js

@@ -1,5 +1,5 @@
-import { n as BOUNDARY_ATTR } from "./plate-DoE1HEXp.js";
-import { a as renderPlate, i as markStitchesLive, n as isRenderProp, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-IyFy2b_8.js";
+import { n as BOUNDARY_ATTR } from "./plate-BRR6d8Se.js";
+import { a as renderPlate, i as markStitchesLive, n as isRenderProp, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-DMIhXHZF.js";
 import { Suspense, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/react.dev.tsx
@@ -88,7 +88,7 @@ function useLivePlate(plate) {
 * `react.tsx`.
 */
 function Skeleton(props) {
-	const { plate, loading = false, suspense = false, fallback, delay, children, data, captureWalker } = props;
+	const { plate, loading = false, suspense = false, fallback, delay, children, data, captureWalker, maxNodes, maxBreadth, maxDepth } = props;
 	const manual = props.root === "manual";
 	const lightBoxOn = useLightBox();
 	const livePlate = useLivePlate(plate);
@@ -112,6 +112,9 @@ function Skeleton(props) {
 		manual,
 		data,
 		captureWalker,
+		maxNodes,
+		maxBreadth,
+		maxDepth,
 		children
 	});
 	if (suspense) return /* @__PURE__ */ jsx(Suspense, {
@@ -128,6 +131,20 @@ function Content(props) {
 	return /* @__PURE__ */ jsx(CaptureBoundary, { ...props });
 }
 /**
+* Assemble the per-site Collect limits (ADR 0022) from the flat `<Skeleton>` props
+* into the nested shape `captured` expects, or `undefined` when none are set (so
+* the client's plugin defaults apply). Called inside the capture effect, keyed on
+* the flat primitives, so it never builds an object during render.
+*/
+function collectLimits(maxNodes, maxBreadth, maxDepth) {
+	if (maxNodes === void 0 && maxBreadth === void 0 && maxDepth === void 0) return void 0;
+	return {
+		maxNodes,
+		maxBreadth,
+		maxDepth
+	};
+}
+/**
 * `root="auto"` (default): the existing `display:contents` boundary wrapper marks
 * the capture seam so a parent capture stops here and references this plate by
 * name rather than re-serializing the content (ADR 0006). A render prop is called
@@ -135,7 +152,7 @@ function Content(props) {
 * element, carries the marker); its result renders inside the wrapper exactly as
 * plain children do.
 */
-function CaptureBoundary({ plate, delay, children, data, captureWalker }) {
+function CaptureBoundary({ plate, delay, children, data, captureWalker, maxNodes, maxBreadth, maxDepth }) {
 	const ref = useRef(null);
 	useEffect(() => {
 		const el = ref.current;
@@ -143,12 +160,16 @@ function CaptureBoundary({ plate, delay, children, data, captureWalker }) {
 		return globalThis.__XRAY__?.captured(plate.name, el, {
 			delay,
 			walker: captureWalker,
-			mode: "auto"
+			mode: "auto",
+			collect: collectLimits(maxNodes, maxBreadth, maxDepth)
 		});
 	}, [
 		plate.name,
 		delay,
-		captureWalker
+		captureWalker,
+		maxNodes,
+		maxBreadth,
+		maxDepth
 	]);
 	const effective = useFixtureData(plate.name, data, isRenderProp(children));
 	return /* @__PURE__ */ jsx("div", {
@@ -171,7 +192,7 @@ function CaptureBoundary({ plate, delay, children, data, captureWalker }) {
 * can produce. A dev-time effect asserts the ref fired and loudly `console.error`s
 * when it did not.
 */
-function ManualBoundary({ plate, delay, children, data, captureWalker }) {
+function ManualBoundary({ plate, delay, children, data, captureWalker, maxNodes, maxBreadth, maxDepth }) {
 	const disposeRef = useRef(void 0);
 	const attachedRef = useRef(false);
 	const ref = useCallback((el) => {
@@ -183,12 +204,16 @@ function ManualBoundary({ plate, delay, children, data, captureWalker }) {
 		disposeRef.current = globalThis.__XRAY__?.captured(plate.name, el, {
 			delay,
 			walker: captureWalker,
-			mode: "manual"
+			mode: "manual",
+			collect: collectLimits(maxNodes, maxBreadth, maxDepth)
 		});
 	}, [
 		plate.name,
 		delay,
-		captureWalker
+		captureWalker,
+		maxNodes,
+		maxBreadth,
+		maxDepth
 	]);
 	useEffect(() => () => disposeRef.current?.(), []);
 	useEffect(() => {

package/dist/react.js

@@ -1,4 +1,4 @@
-import { a as renderPlate, i as markStitchesLive, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-IyFy2b_8.js";
+import { a as renderPlate, i as markStitchesLive, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-DMIhXHZF.js";
 import { Suspense, useEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/react.tsx

package/dist/{plate-Bv6W-GkA.d.ts → serialize-BgdGt34A.d.ts}

@@ -5,8 +5,8 @@
  * browser console (`client.ts`) and the Vite server output (`index.ts`) print.
  *
  * Motivation: the serializer silently swallows a handful of capture omissions
- * (an unreadable cross-origin stylesheet, skipped pseudo-elements, a collapsed
- * list run, an over-the-limit subtree). Early adopters asking "why does this
+ * (an unreadable cross-origin stylesheet, skipped pseudo-elements, off-screen
+ * bones dropped at the fold, an over-the-limit subtree). Early adopters asking "why does this
  * skeleton look wrong?" had to read the serializer source to find out. These
  * diagnostics surface those omissions as data the capture process returns, so a
  * caller can log them — without the core performing any console side effects.
@@ -14,7 +14,7 @@
  * Strictly DEV-ONLY (see the plan's decisions and ADR 0008): this type is NOT a
  * public package export and MUST NEVER reach the persisted Plate JSON, the
  * `MergedPlate`, or the production adapter. It rides on the TRANSIENT
- * `ViewCapture.diagnostics` field only, which `captureRegime` populates and the
+ * `ViewIR.diagnostics` field only, which `captureView` populates and the
  * dev client strips before posting (so committed `plates/<name>.json` stays
  * byte-identical to a capture that produced no diagnostics).
  *
@@ -44,10 +44,10 @@ interface CaptureDiagnostic {
  * serializer (or an existing oversized-capture warning folded into the same
  * vocabulary). Kept as a const union so the message table is exhaustive.
  */
-type DiagnosticCode = 'unreadable-stylesheet' | 'unreadable-import' | 'skipped-dynamic-pseudo' | 'skipped-pseudo-element' | 'unsupported-rule' | 'dropped-tag' | 'pruned-run' | 'too-large' | 'invalid-plate-file';
+type DiagnosticCode = 'unreadable-stylesheet' | 'unreadable-import' | 'skipped-dynamic-pseudo' | 'skipped-pseudo-element' | 'unsupported-rule' | 'dropped-tag' | 'dropped-subset' | 'dropped-cropped' | 'too-large' | 'invalid-plate-file';
 //#endregion
 //#region src/plate.d.ts
-type LeafKind = 'text' | 'media' | 'box';
+type LeafKind = 'text' | 'text-block' | 'media' | 'box';
 /**
  * The shipped structural capture of a component's rendered DOM — the data a
  * Skeleton renders from (see CONTEXT.md). Self-contained: pre-serialized chunks
@@ -81,21 +81,27 @@ interface Plate {
 /**
  * One serialized child of a plate root (or of a stitch-bearing node): a
  * stitch-free HTML run (`string`), a stitch to a child plate (`{ r: name }`),
- * or a stitch-bearing element kept real so its inner stitches can mount
- * (`{ c: className, k: chunk[] }`). The framework-neutral render contract: an
- * adapter injects the strings and mounts a child plate at each stitch (ADR 0008).
+ * a stitch-bearing element kept real so its inner stitches can mount
+ * (`{ c: className, k: chunk[] }`), or a templated uniform run (`{ t: html, n }`):
+ * the cell's HTML once plus a repeat count the adapter expands to N copies (Phase
+ * 2). The framework-neutral render contract: an adapter injects the strings,
+ * mounts a child plate at each stitch, and repeats each template (ADR 0008).
  */
 type Chunk = string | {
   r: string;
 } | {
   c: string;
   k: Chunk[];
+} | {
+  t: string;
+  n: number;
 };
 /**
- * A plate after view-merge + classify but before chunk serialization: the
- * build-time RenderNode tree plus its scoped CSS. Produced by `mergeViews` and
- * `capture`, then serialized into the shipped `Plate` (chunks) at load
- * (`serializePlate`). Never shipped to the client.
+ * A plate after the in-browser Serialize (emit + merge/gate + classify) but
+ * before chunk serialization: the build-time RenderNode tree plus its scoped
+ * CSS. Produced by `serializePlateIR` (the structural part of `StoredPlate`) and
+ * the single-View `capture`, then serialized into the shipped `Plate` (chunks) at
+ * load (`serializePlate`). Never shipped to the client.
  */
 interface MergedPlate {
   v: number;
@@ -114,6 +120,12 @@ interface PlateNode {
    * against `Plate.refs` (prod) or the live store (dev).
    */
   ref?: string;
+  /**
+   * A templated uniform run (Phase 2): render this node's subtree `count` times.
+   * The serializer emits the subtree's HTML once plus the count; the adapter
+   * expands it to N copies at render. Absent on ordinary nodes.
+   */
+  count?: number;
   kids?: PlateNode[];
 }
 /**
@@ -126,6 +138,8 @@ interface RenderNode {
   leaf?: LeafKind;
   ref?: string;
   cls?: string;
+  /** A templated uniform run (Phase 2): serialize this subtree once + a count the adapter repeats. */
+  count?: number;
   kids?: RenderNode[];
 }
 /**
@@ -146,8 +160,11 @@ interface PlateRule {
 }
 /**
  * One capture of a component within one viewport view — `[min, max)` in px,
- * either side open-ended when undefined. What the dev client ships to the
- * plugin, and what the plate file accumulates (ADR 0004).
+ * either side open-ended when undefined. The id-form `{ tree, rules }` shape
+ * `emit` projects a measured View into (ADR 0004). NO LONGER the disk/wire shape
+ * after the ADR 0022 cutover — `StoredPlate` (below) is. Kept as the
+ * framework-neutral per-View capture shape, exported for consumers reading the
+ * id-form projection directly.
  */
 interface ViewCapture {
   /** Viewport width at capture time. */
@@ -158,23 +175,31 @@ interface ViewCapture {
   rules: PlateRule[];
   /**
    * TRANSIENT, dev-only capture diagnostics (why this view may be lower
-   * fidelity). Populated by `captureRegime` in the browser; the dev client logs
-   * it and posts it (so the Vite server can print the same text), then it is
-   * STRIPPED at the merge layer (`addCapture`) before persisting. It MUST NEVER
-   * be persisted: it is not part of the committed `plates/<name>.json` shape,
-   * the `isViewCapture` validator does not require it, and `addCapture` drops it
-   * so neither it nor `mergeViews` ever writes it. Absent in production (the
-   * prod adapter ships no capture). See diagnostics.ts and ADR 0008.
+   * fidelity). Captured in the browser (mirrored onto `ViewIR.diagnostics`); the
+   * dev client logs it and posts it alongside the `StoredPlate` (so the Vite
+   * server can print the same text). It MUST NEVER be persisted: it is not part
+   * of the committed
+   * `StoredPlate` disk shape, the validator does not carry it, and the POST
+   * envelope keeps it in a SIBLING field that never reaches the stored artifact
+   * (ADR 0008). Absent in production (the prod adapter ships no capture). See
+   * diagnostics.ts and ADR 0008.
    */
   diagnostics?: CaptureDiagnostic[];
 }
-/** The committed `plates/<name>.json`: per-view captures, merged at load. */
-interface PlateFile {
-  v: number;
-  name: string;
-  /** Width thresholds (view boundaries) derived so far. */
+/**
+ * The committed `plates/<name>.json` shape AFTER the ADR 0022 cutover: the whole
+ * Plate already projected in the browser (the in-browser Serialize folds emit +
+ * the multi-View merge/gate + classify in one session), so disk holds ONE gated,
+ * content-addressed tree + css instead of per-View captures merged at load. It is
+ * a `MergedPlate` (the structural `{tree, css}` `serializePlate` consumes) PLUS the
+ * `breakpoints` the HUD coverage reads — the analysis-only geometry never crosses
+ * the wire (ADR 0021). The gen-side runs `serializePlate(stored) → Plate` (chunks)
+ * at module-load, leaving the Tailwind/Bundle passthrough a clean gen-side seam.
+ * Replaces `PlateFile` (+ `ViewCapture`) on disk and on the `/__xray` wire.
+ */
+interface StoredPlate extends MergedPlate {
+  /** Width thresholds (view boundaries); the HUD coverage derives its bands from these. */
   breakpoints: number[];
-  views: ViewCapture[];
 }
 /** The (unserialized) plate an import resolves to before anything has been captured. */
 declare function emptyPlate(name: string): MergedPlate;
@@ -298,6 +323,11 @@ interface CaptureHook {
     delay?: number;
     walker?: unknown;
     mode?: 'auto' | 'manual';
+    collect?: {
+      maxNodes?: number;
+      maxBreadth?: number;
+      maxDepth?: number;
+    };
   }) => (() => void) | undefined;
   /** Light Box toggle: force every `<Skeleton>` to its skeleton, read by `<Skeleton>`. */
   lightbox?: ToggleStore;
@@ -305,8 +335,8 @@ interface CaptureHook {
   capture?: ToggleStore;
   /** Read side for `<Skeleton>`. */
   plates?: PlateStore;
-  /** Write side for the dev client's HMR-event handler. */
-  updatePlate?: (name: string, plate: Plate) => void;
+  /** Write side for the dev client's HMR-event handler. Returns whether the plate changed. */
+  updatePlate?: (name: string, plate: Plate) => boolean;
   /** Dev-only: run the HUD-triggered capture-all-views sweep via the extension (ADR 0010). */
   captureAllViews?: () => Promise<void>;
   /** Dev-only per-plate breakpoints + captured spans, from disk; fed by the bootstrap. */
@@ -335,4 +365,137 @@ declare global {
   var __XRAY__: CaptureHook | undefined;
 }
 //#endregion
-export { PlateNode as a, emptyPlate as c, PlateFile as i, MergedPlate as n, RenderNode as o, Plate as r, ViewCapture as s, LeafKind as t };
+//#region src/serialize.d.ts
+/**
+ * Browser-side capture: walk a live rendered subtree into a Plate — one node
+ * tree plus one self-contained, scoped CSS string (ADR 0003). The CSS is
+ * lifted from the author rules that matched each node, rewritten to
+ * plate-local selectors — it carries `@media` for free and keeps layout live
+ * (the M1 bake-off winner; ADR 0005).
+ */
+interface CaptureOptions {
+  /** Plate name; comes from the virtual-module specifier. */
+  name: string;
+  /** Collect limits (ADR 0022): refuse a capture whose measured tree exceeds any axis. */
+  collect?: CollectLimits;
+  /**
+   * Optional programmable capture walker (ADR 0018). The declarative `data-xr-*`
+   * annotations cover the 90%; this is the escape hatch for the 10% a markup
+   * attribute cannot express. Capture-only: it shapes the resulting `PlateNode`
+   * tree but is never persisted into the Plate, and the production adapter never
+   * captures so it ignores this entirely.
+   */
+  walker?: XrayCaptureWalker;
+  /**
+   * Whether the top-level capture roots ARE this plate's own boundary, so the
+   * stitch guard must be SKIPPED for them (ADR 0006/0014, finding #6). True ONLY
+   * for a MANUAL root: there `site.el` is the consumer's own element and its
+   * `data-xr-boundary` marks the boundary of THIS plate, so the root must be
+   * serialized as a real Entry (its box/classes/padding/border) rather than a
+   * stitch-to-itself. Defaults to `false` — the auto path, where the top-level
+   * roots are the wrapper's CHILDREN and any boundary marker on a direct-child
+   * root is a NESTED `<Skeleton>` that MUST stitch (the capture-leak guard).
+   */
+  captureRootIsBoundary?: boolean;
+}
+/**
+ * What a capture walker decides for one element (ADR 0018; ADR 0022 §5). The
+ * `applyWalker` PASS reads the decision and applies it to the measured IR node —
+ * a walker NEVER hand-builds a `PlateNode`, so xray keeps ownership of the Plate
+ * format. `ignore` drops the element + its subtree; `bone` collapses it to one
+ * Bone leaf (inferring the kind when omitted); `keep` defers to the default
+ * classifier (`markInk`).
+ */
+type WalkerDecision = {
+  type: 'ignore';
+} | {
+  type: 'bone';
+  kind?: LeafKind;
+} | {
+  type: 'keep';
+};
+/**
+ * The context handed to a capture walker's `element` hook (ADR 0018). The
+ * helpers are PURE — each returns a `WalkerDecision` the `applyWalker` pass
+ * applies; they do NOT mutate. `el` is the element under consideration.
+ */
+interface CaptureWalkerContext {
+  /** The element currently being classified. */
+  el: Element;
+  /** Drop this element AND its whole subtree (no bone). */
+  ignore(): WalkerDecision;
+  /**
+   * Collapse this element's subtree into ONE Bone leaf. `kind` omitted shares
+   * the default classifier's kind-inference heuristic (`inferLeafKind`; ADR 0018,
+   * Q4 — ONE code path).
+   */
+  bone(opts?: {
+    kind?: LeafKind;
+  }): WalkerDecision;
+  /** Defer to the default classifier (`markInk`) — recurse into the subtree. */
+  keep(): WalkerDecision;
+}
+/**
+ * The programmable capture walker (ADR 0018; ADR 0022 §5). `element` is offered
+ * each non-boundary element TOP-DOWN over the measured IR (the `applyWalker`
+ * pass, NOT the DOM walk) and returns a `WalkerDecision` the pass applies. The
+ * declarative `data-xr-*` annotations cover the 90%; this is the 10% escape
+ * hatch for what a markup attribute cannot express.
+ */
+interface XrayCaptureWalker {
+  /**
+   * Called for every non-boundary element node (a stitch carries no element and
+   * is skipped — ADR 0006 — so a boundary never reaches here). Return one of
+   * `ctx.ignore()`, `ctx.bone()`, or `ctx.keep()`. An `ignore`/`bone` decision
+   * stops the descent (the subtree lowers); `keep` recurses.
+   */
+  element?(ctx: CaptureWalkerContext): WalkerDecision;
+}
+/**
+ * Typed identity wrapper for authoring a capture walker (ADR 0018) — the
+ * `defineConfig` pattern. It returns its argument unchanged at runtime; its only
+ * job is to infer and check the `XrayCaptureWalker` shape at the call site so an
+ * author gets completion and a typo in a hook name is caught.
+ */
+declare function defineXrayCaptureWalker(walker: XrayCaptureWalker): XrayCaptureWalker;
+/**
+ * Thrown when a subtree has more nodes than the capture limit — almost always
+ * a `<Skeleton>` sitting too high in the tree. Raised after the cheap walk and
+ * before the O(rules × nodes) CSS extraction, so an oversized capture is
+ * refused without freezing the main thread on it.
+ */
+/** The measured size of a capture's surviving tree, one number per Collect axis (ADR 0022). */
+type CaptureSize = {
+  nodes: number;
+  breadth: number;
+  depth: number;
+};
+/** Which Collect axis a too-large capture tripped. */
+type CollectAxis = 'nodes' | 'breadth' | 'depth';
+declare class CaptureTooLargeError extends Error {
+  /** The full measured size of the surviving tree that tripped the gate. */
+  readonly size: CaptureSize;
+  /** Which axis exceeded its cap, and the cap it exceeded. */
+  readonly axis: CollectAxis;
+  readonly max: number;
+  /** Back-compat alias for `size.nodes` (the sole axis before breadth/depth). */
+  readonly nodeCount: number;
+  /** Folds the oversized-capture warning into the shared diagnostics vocabulary (diagnostics.ts). */
+  readonly code: "too-large";
+  constructor(size: CaptureSize, axis: CollectAxis, max: number);
+}
+/**
+ * Collect-stage size limits (ADR 0022): refuse to capture a boundary whose
+ * measured tree exceeds any axis. `maxNodes` caps the total surviving-node count;
+ * `maxBreadth` the widest level (most nodes at any one depth); `maxDepth` the
+ * nesting depth. Each axis is enforced only when its cap is defined. The defaults
+ * and the `maxNodes = round(maxBreadth × maxDepth / 4)` derivation live in the
+ * client (where the other defaults live); this core only enforces what it is handed.
+ */
+type CollectLimits = {
+  maxNodes?: number;
+  maxBreadth?: number;
+  maxDepth?: number;
+};
+//#endregion
+export { emptyPlate as _, CollectAxis as a, XrayCaptureWalker as c, MergedPlate as d, Plate as f, ViewCapture as g, StoredPlate as h, CaptureWalkerContext as i, defineXrayCaptureWalker as l, RenderNode as m, CaptureSize as n, CollectLimits as o, PlateNode as p, CaptureTooLargeError as r, WalkerDecision as s, CaptureOptions as t, LeafKind as u, CaptureDiagnostic as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hueest/xray",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Auto-captured skeleton loading screens for Vite — capture the structure, ship the plate.",
   "keywords": [
     "loading",
@@ -58,6 +58,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@chenglou/pretext": "0.0.8",
     "devalue": "5.8.1",
     "valibot": "1.4.1"
   },