@hueest/xray 0.1.0 → 0.3.0

package/dist/serialize-Cs7hUxmK.d.ts

@@ -0,0 +1,107 @@
+import { t as LeafKind } from "./plate-BIr62u7l.js";
+
+//#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;
+  /**
+   * 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.
+ */
+declare class CaptureTooLargeError extends Error {
+  readonly nodeCount: number;
+  /** Folds the oversized-capture warning into the shared diagnostics vocabulary (diagnostics.ts). */
+  readonly code: "too-large";
+  constructor(nodeCount: number);
+}
+//#endregion
+export { XrayCaptureWalker as a, WalkerDecision as i, CaptureTooLargeError as n, defineXrayCaptureWalker as o, CaptureWalkerContext as r, CaptureOptions as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hueest/xray",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Auto-captured skeleton loading screens for Vite — capture the structure, ship the plate.",
   "keywords": [
     "loading",
@@ -42,15 +42,11 @@
       "types": "./dist/react.dev.d.ts",
       "import": "./dist/react.dev.js"
     },
-    "./serialize": {
-      "types": "./dist/serialize.d.ts",
-      "import": "./dist/serialize.js"
-    },
-    "./client": {
+    "./internal/client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.js"
     },
-    "./hud": {
+    "./internal/hud": {
       "types": "./dist/hud.d.ts",
       "import": "./dist/hud.js"
     },
@@ -61,6 +57,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@chenglou/pretext": "0.0.8",
+    "devalue": "5.8.1",
+    "valibot": "1.4.1"
+  },
   "devDependencies": {
     "@types/node": "25.9.3",
     "@types/react": "19.2.17",

package/virtual.d.ts

@@ -16,6 +16,12 @@
  * imported Plate. Pass the imported Plate to `<Skeleton>`; do not repeat the
  * name in props.
  *
+ * A name is one or more `/`-separated path segments, each `\w+(-\w+)*` — word
+ * chars with single interior hyphens. A segment may not contain `--` or a
+ * leading/trailing hyphen: the generated class prefix renders `/` as `--` to
+ * keep nested names readable, and banning those forms keeps the encoding
+ * collision-free (it is the isolation boundary across stitched Plates).
+ *
  * If the file does not exist yet, the Vite plugin resolves an empty Plate with
  * the same name so `<Skeleton fallback={...}>` can render until the first
  * Capture writes the file. Nested `<Skeleton>` boundaries become Stitches; the

package/dist/breakpoints-CBNlh7lQ.js

@@ -1,47 +0,0 @@
-//#region src/breakpoints.ts
-/**
-* Per-plate breakpoint derivation (ADR 0004): the width thresholds that could
-* change this plate come from the `@media` conditions on its own copied rules
-* plus the queries the app evaluated through `matchMedia` during capture.
-* Thresholds partition the width axis into views; identical captures in
-* adjacent views collapse at merge time.
-*/
-const FONT_SIZE_PX = 16;
-/** A breakpoint is the first integer px width of the view ABOVE the boundary. */
-function thresholdsOf(condition) {
-	const out = [];
-	const toPx = (value, unit) => Number.parseFloat(value) * (unit === "px" ? 1 : FONT_SIZE_PX);
-	const push = (raw, exclusiveBelow) => {
-		const bp = exclusiveBelow ? Number.isInteger(raw) ? raw + 1 : Math.ceil(raw) : Math.ceil(raw);
-		if (Number.isFinite(bp) && bp > 0) out.push(bp);
-	};
-	for (const m of condition.matchAll(/min-width:\s*([\d.]+)(px|em|rem)/g)) push(toPx(m[1] ?? "", m[2] ?? "px"), false);
-	for (const m of condition.matchAll(/max-width:\s*([\d.]+)(px|em|rem)/g)) push(toPx(m[1] ?? "", m[2] ?? "px"), true);
-	for (const m of condition.matchAll(/width\s*>=?\s*([\d.]+)(px|em|rem)/g)) push(toPx(m[1] ?? "", m[2] ?? "px"), false);
-	for (const m of condition.matchAll(/width\s*<=?\s*([\d.]+)(px|em|rem)/g)) push(toPx(m[1] ?? "", m[2] ?? "px"), true);
-	for (const m of condition.matchAll(/([\d.]+)(px|em|rem)\s*<=?\s*width/g)) push(toPx(m[1] ?? "", m[2] ?? "px"), false);
-	return out;
-}
-/** Width thresholds for this plate: its rules' media conditions + the app's matchMedia queries. */
-function deriveBreakpoints(rules, matchMediaQueries = []) {
-	const set = /* @__PURE__ */ new Set();
-	for (const rule of rules) for (const condition of rule.media ?? []) for (const bp of thresholdsOf(condition)) set.add(bp);
-	for (const query of matchMediaQueries) for (const bp of thresholdsOf(query)) set.add(bp);
-	return [...set].toSorted((a, b) => a - b);
-}
-/** The view interval `[min, max)` a given viewport width falls into. */
-function regimeFor(width, breakpoints) {
-	let min;
-	let max;
-	for (const bp of breakpoints) if (bp <= width) min = bp;
-	else {
-		max = bp;
-		break;
-	}
-	return {
-		...min === void 0 ? {} : { min },
-		...max === void 0 ? {} : { max }
-	};
-}
-//#endregion
-export { regimeFor as n, deriveBreakpoints as t };

package/dist/plate-BuzRMPx4.js

@@ -1,94 +0,0 @@
-/** Marks the rendered skeleton root; carries the plate name. Also a dev capture marker. */
-const ROOT_ATTR = "data-xr-root";
-/**
-* Marks a `<Content>` capture boundary in dev; carries the plate name. A parent
-* capture treats it as a stitch — it references the child plate by name instead of
-* re-serializing the child's subtree (ADR 0006).
-*/
-const BOUNDARY_ATTR = "data-xr-boundary";
-const SPEC_LEAF = 9e6;
-const SPEC_INLINE = 1e7;
-const SPEC_GATE = 2e7;
-/** Fixed renderer-owned classes every rendered node carries. */
-const ROOT_CLASS = "xr-root";
-const NODE_CLASS = "xr-node";
-const LEAF_CLASS = "xr-leaf";
-/**
-* Renderer-owned base styles, emitted once by the outermost view (ADR 0007),
-* before a plate's node rules so a node's captured class wins by source order.
-* Everything visual is driven by inheritable custom properties, so consumers
-* theme by setting `--xr-*` in `:root` or on any ancestor — and per-plate via
-* `[data-xr-root="name"]` (the root carries its plate name). See ADR 0011 and
-* docs/architecture.md. Class-based and unlayered — `@layer` was rejected
-* (unlayered app CSS would beat layered skeleton rules, and it inverts
-* `!important`).
-*
-* Progressive enhancement (ADR 0011): the plain bone fill + opacity pulse use
-* only universally-supported CSS and are the floor. `light-dark()` is guarded
-* by `@supports` because an unsupported VALUE drops the whole declaration (an
-* invisible bone), and it is not Baseline-widely-available until 2026-11-13 —
-* drop the guard then. Features that merely no-op when absent (`@property`,
-* `prefers-contrast`, relative-color-as-fallback) carry no hard guard.
-*
-* Tokens: `--xr-bone` (fill), `--xr-bone-highlight` (sheen), `--xr-radius`
-* (+ `--xr-radius-text` / `--xr-radius-media`), `--xr-duration`, the pulse range
-* `--xr-pulse-min`/`--xr-pulse-max`, `--xr-anim` (mode: `xr-pulse` | `none` | a
-* custom keyframe), and `--xr-fill` (override the leaf paint, e.g. a sheen
-* gradient built from the two bone tokens).
-*/
-const BASE_CSS = `
-/* One timeline per skeleton, not per leaf: the root animates one inherited
-   opacity property and every leaf reads it. Hundreds of independent infinite
-   opacity animations would pin the compositor and cook the CPU. */
-@property --xr-o { syntax: "<number>"; inherits: true; initial-value: 1 }
-.${ROOT_CLASS} {
-  --xr-bone-highlight: #f4f4f5;
-  display: contents;
-  animation: var(--xr-anim, xr-pulse) var(--xr-duration, 1.2s) ease-in-out infinite alternate;
-}
-/* No pointer-events:none — it blocks inspecting bones in devtools and buys
-   nothing (no real content to click). border-color: a node may capture
-   border-width for layout; its paint stays out. list-style: suppress a ::marker
-   a captured display:list-item would otherwise paint. */
-.${NODE_CLASS} { border-color: transparent; list-style: none }
-.${LEAF_CLASS} {
-  background: var(--xr-fill, var(--xr-bone, #e4e4e7));
-  border-radius: var(--xr-radius, 4px);
-  opacity: var(--xr-o);
-}
-/* Per-kind defaults: text reads as rounded bars, media as blocks. Re-theme any
-   kind via [data-xr-root] .${LEAF_CLASS}-text { ... }. */
-.${LEAF_CLASS}-text { border-radius: var(--xr-radius-text, 999px) }
-.${LEAF_CLASS}-media { border-radius: var(--xr-radius-media, var(--xr-radius, 4px)) }
-@keyframes xr-pulse {
-  from { --xr-o: var(--xr-pulse-max, 1) }
-  to { --xr-o: var(--xr-pulse-min, 0.5) }
-}
-@media (prefers-reduced-motion: reduce) { .${ROOT_CLASS} { animation: none } }
-/* Dark + high-contrast bone defaults. Guarded: light-dark() is an invalid value
-   without support and would drop the declaration — see the note above; remove
-   this @supports once widely available (2026-11-13). */
-@supports (color: light-dark(#000, #fff)) {
-  .${ROOT_CLASS} { --xr-bone-highlight: light-dark(#f4f4f5, #52525b) }
-  .${LEAF_CLASS} { background: var(--xr-fill, var(--xr-bone, light-dark(#e4e4e7, #3f3f46))) }
-  @media (prefers-contrast: more) {
-    .${LEAF_CLASS} { background: var(--xr-fill, var(--xr-bone, light-dark(#d4d4d8, #52525b))) }
-  }
-}
-/* Derive the sheen highlight from --xr-bone so re-theming one token updates both.
-   Relative color isn't widely available yet; the static highlight above is the
-   fallback (sheen just looks flatter), so no hard guard is needed. */
-@supports (color: oklch(from red l c h)) {
-  .${ROOT_CLASS} { --xr-bone-highlight: oklch(from var(--xr-bone, #e4e4e7) calc(l + 0.08) c h) }
-}`.trim();
-/** The (unserialized) plate an import resolves to before anything has been captured. */
-function emptyPlate(name) {
-	return {
-		v: 1,
-		name,
-		tree: null,
-		css: ""
-	};
-}
-//#endregion
-export { ROOT_ATTR as a, SPEC_INLINE as c, NODE_CLASS as i, SPEC_LEAF as l, BOUNDARY_ATTR as n, ROOT_CLASS as o, LEAF_CLASS as r, SPEC_GATE as s, BASE_CSS as t, emptyPlate as u };

package/dist/plate-DboxMKg-.d.ts

@@ -1,196 +0,0 @@
-//#region src/plate.d.ts
-type LeafKind = 'text' | '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
- * plus one scoped CSS string; depends on nothing in the consumer's build (ADR
- * 0003). Built from the RenderNode tree at plugin load (see chunk.ts), so the
- * adapter injects strings instead of walking a tree on the latency-critical
- * first paint — and no per-framework serializer ships to the client (ADR 0008).
- */
-interface Plate {
-  v: number;
-  /** Capture name; comes from the virtual-module specifier, never typed at a call site. */
-  name: string;
-  /**
-   * The root's children, pre-serialized (ADR 0008): a stitch-free run is one
-   * HTML `string`; a stitch is `{ r: name }`; a stitch-bearing element is
-   * `{ c: className, k: chunk[] }`. Null until first capture.
-   */
-  chunks: Chunk[] | null;
-  /** The root node's own content classes (its inherited font context), if any. */
-  rootCls?: string;
-  /** Layout-relevant CSS (incl. `@media`) scoped under the plate root, paint stripped. */
-  css: string;
-  /**
-   * Child plates named by the chunks' `{ r }` stitches, resolved through the
-   * import graph (ADR 0006). Populated by the loader's generated imports, never
-   * serialized into the plates JSON; absent in production when there are no
-   * stitches. In dev the live store takes precedence, so this need not be present.
-   */
-  refs?: Record<string, 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).
- */
-type Chunk = string | {
-  r: string;
-} | {
-  c: string;
-  k: Chunk[];
-};
-/**
- * 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.
- */
-interface MergedPlate {
-  v: number;
-  name: string;
-  tree: RenderNode | null;
-  css: string;
-}
-interface PlateNode {
-  /** Plate-local id; rules reference it pre-classify. Stripped from the shipped tree. */
-  id: number;
-  /** Present on paint leaves; absent on layout containers. */
-  leaf?: LeafKind;
-  /**
-   * A stitch: render the named child plate's skeleton here instead of own
-   * structure (ADR 0006). Mutually exclusive with `leaf`/`kids`. Resolved
-   * against `Plate.refs` (prod) or the live store (dev).
-   */
-  ref?: string;
-  kids?: PlateNode[];
-}
-/**
- * A node in the shipped tree, after classify (ADR 0007). Carries the
- * content-addressed style classes it needs instead of an id — the CSS targets
- * those classes, not a per-node `data-xr` value, so node scoping (the old
- * `nodeKey`) is gone. `cls` is a space-joined class-token list.
- */
-interface RenderNode {
-  leaf?: LeafKind;
-  ref?: string;
-  cls?: string;
-  kids?: RenderNode[];
-}
-/**
- * A captured style rule in id form — selectors are generated at render time,
- * so view merging can remap node ids without string surgery. `ids: []`
- * targets the plate root.
- */
-interface PlateRule {
-  ids: number[];
-  decls: string[];
-  /** Media-condition stack, outermost first; conditions AND together. */
-  media?: string[];
-  /** `@container`-condition stack, outermost first; conditions AND together. Absent when none. */
-  container?: string[];
-  layered?: boolean;
-  spec: number;
-  order: number;
-}
-/**
- * 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).
- */
-interface ViewCapture {
-  /** Viewport width at capture time. */
-  width: number;
-  min?: number;
-  max?: number;
-  tree: PlateNode;
-  rules: PlateRule[];
-}
-/** The committed `plates/<name>.json`: per-view captures, merged at load. */
-interface PlateFile {
-  v: number;
-  name: string;
-  /** Width thresholds (view boundaries) derived so far. */
-  breakpoints: number[];
-  views: ViewCapture[];
-}
-/** The (unserialized) plate an import resolves to before anything has been captured. */
-declare function emptyPlate(name: string): MergedPlate;
-/**
- * A dev-only sticky boolean toggle (get/set/subscribe), persisted per tab.
- * Used for both "light box" (render every `<Skeleton>` regardless of readiness)
- * and "capture" (whether browsing re-captures plates).
- */
-interface ToggleStore {
-  get: () => boolean;
-  set: (value: boolean) => void;
-  subscribe: (onChange: () => void) => () => void;
-}
-/**
- * Dev-only store of the freshest plate per name, updated in place when a
- * capture lands. `<Skeleton>` reads through it so a new plate re-renders the
- * site rather than reloading the module — which would remount the capture
- * boundary and re-fire the capture, a feedback loop.
- */
-interface PlateStore {
-  get: (name: string) => Plate | undefined;
-  subscribe: (name: string, onChange: () => void) => () => void;
-  /**
-   * Register a plate imported via the ref graph if the store has none yet — so a
-   * stitch resolves even before its child is re-captured, and survives a parent
-   * hot-swap (whose pushed plate carries no resolved `refs`). Never overwrites a
-   * live capture.
-   */
-  seed: (name: string, plate: Plate) => void;
-}
-/** A view interval `[min, max)`; an open end is undefined (ADR 0004). */
-interface Span {
-  min?: number;
-  max?: number;
-}
-/** A plate's detected width thresholds and the spans actually captured, from disk. */
-interface PlateCoverage {
-  breakpoints: number[];
-  spans: Span[];
-}
-/**
- * Dev-only per-plate coverage, sourced from the committed plate files (not the
- * session): the breakpoints detected so far and which view spans are captured.
- * The HUD renders every band — covered ones lit, the rest dim — and the
- * capture-all sweep derives its target widths from the breakpoints.
- */
-interface CoverageStore {
-  get: () => ReadonlyMap<string, PlateCoverage>;
-  set: (name: string, coverage: PlateCoverage) => void;
-  subscribe: (onChange: () => void) => () => void;
-}
-/**
- * Dev-only capture hook, installed by the dev client before the app boots.
- * Absent in production builds, so `<Skeleton>` carries zero capture weight.
- * `captured` returns a dispose callback (stop observing this site).
- */
-interface CaptureHook {
-  captured: (name: string, el: Element, opts?: {
-    delay?: number;
-  }) => (() => void) | undefined;
-  /** Light Box toggle: force every `<Skeleton>` to its skeleton, read by `<Skeleton>`. */
-  lightbox?: ToggleStore;
-  /** Capture toggle: whether browsing re-captures plates, flipped from the HUD. */
-  capture?: ToggleStore;
-  /** Read side for `<Skeleton>`. */
-  plates?: PlateStore;
-  /** Write side for the dev client's HMR-event handler. */
-  updatePlate?: (name: string, plate: Plate) => void;
-  /** 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. */
-  coverage?: CoverageStore;
-}
-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 };

package/dist/react.core-CqnDjfAJ.js

@@ -1,59 +0,0 @@
-import { a as ROOT_ATTR, o as ROOT_CLASS, t as BASE_CSS } from "./plate-BuzRMPx4.js";
-import { Fragment } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-//#region src/react.core.tsx
-/** Layout-neutral wrapper for an HTML island sitting beside React stitch nodes —
-* its children participate in the grandparent's flow, so grid/flex item counts
-* are unchanged. */
-const DISPLAY_CONTENTS = { display: "contents" };
-/**
-* Render a shipped plate's skeleton. `resolveStitch` turns a child plate name
-* into the node that mounts it (static `refs` in prod, a store-subscribed
-* component in dev). `nested` is true for a stitch-mounted child, which skips
-* BASE_CSS — the outermost view already emitted it (ADR 0007). Returns null
-* when the plate has no capture yet; the caller renders the fallback.
-*/
-function renderPlate(plate, resolveStitch, nested) {
-	if (!plate.chunks) return null;
-	const className = plate.rootCls ? `${ROOT_CLASS} ${plate.rootCls}` : ROOT_CLASS;
-	const rootAttrs = {
-		[ROOT_ATTR]: plate.name,
-		className,
-		"aria-hidden": true,
-		"aria-busy": true
-	};
-	const css = nested ? plate.css : `${BASE_CSS}\n${plate.css}`;
-	const chunks = plate.chunks;
-	if (chunks.length === 1 && typeof chunks[0] === "string") {
-		const html = `<style>${css}</style>${chunks[0]}`;
-		return /* @__PURE__ */ jsx("div", {
-			...rootAttrs,
-			dangerouslySetInnerHTML: { __html: html }
-		});
-	}
-	return /* @__PURE__ */ jsxs("div", {
-		...rootAttrs,
-		children: [/* @__PURE__ */ jsx("style", { children: css }), renderChunks(chunks, resolveStitch)]
-	});
-}
-/**
-* Each `string` chunk is injected as a display:contents innerHTML island; each
-* `{ r }` stitch resolves through `resolveStitch`; a `{ c, k }` node stays a
-* real element and recurses (it holds a stitch deeper). No per-node tree walk —
-* the strings are already serialized.
-*/
-function renderChunks(chunks, resolveStitch) {
-	return chunks.map((chunk, i) => {
-		if (typeof chunk === "string") return /* @__PURE__ */ jsx("div", {
-			style: DISPLAY_CONTENTS,
-			dangerouslySetInnerHTML: { __html: chunk }
-		}, i);
-		if ("r" in chunk) return /* @__PURE__ */ jsx(Fragment, { children: resolveStitch(chunk.r) }, i);
-		return /* @__PURE__ */ jsx("div", {
-			className: chunk.c,
-			children: renderChunks(chunk.k, resolveStitch)
-		}, i);
-	});
-}
-//#endregion
-export { renderPlate as t };

package/dist/react.core-fgWG_svU.d.ts

@@ -1,21 +0,0 @@
-import { r as Plate } from "./plate-DboxMKg-.js";
-import { ReactNode } from "react";
-
-//#region src/react.core.d.ts
-/** Props accepted by the React `<Skeleton>` component. */
-interface SkeletonProps {
-  /** The plate to render while loading, imported from `virtual:xray/plates/<name>`. */
-  plate: Plate;
-  /** Explicit readiness mode: render the Skeleton while true, then render children and capture them in dev when false. */
-  loading?: boolean;
-  /** Suspense mode: make `<Skeleton>` the Suspense boundary and use the Plate as the fallback until children resolve. */
-  suspense?: boolean;
-  /** Shown while loading when the plate has no capture yet. */
-  fallback?: ReactNode;
-  /** Override the plugin's settle delay before this site is captured (dev only). */
-  delay?: number;
-  /** Real content. In dev, these children are also the capture source once ready. */
-  children?: ReactNode;
-}
-//#endregion
-export { SkeletonProps as t };