@glissade/scene 0.18.0-pre.3 → 0.18.0-pre.5

package/dist/describe.d.ts

@@ -0,0 +1,67 @@
+//#region src/describe.d.ts
+/**
+ * `describe()` — a machine-readable API manifest (0.18), the structural antidote
+ * to discoverability: an AI consumer reads GROUND TRUTH from the artifact instead
+ * of reverse-engineering the surface. PURE INTROSPECTION — it instantiates each
+ * built-in node once, reads its registered track targets, and enumerates the core
+ * registries; it never touches `evaluate()` or any cross-frame state, so it has
+ * zero determinism impact.
+ *
+ * The whole point is NO-DRIFT: every section is GENERATED from the live registry
+ * it documents (`Node.listTargets()` → the real `registerTarget` calls,
+ * `listValueTypes()` → the ValueType registry, `easings` → the easing registry),
+ * so the manifest can't fall out of sync with what the framework actually does.
+ * The builder method list and the subpath map are the lone curated parts (runtime
+ * signatures aren't introspectable); a test pins the builder names to the
+ * `TimelineBuilder` interface so even those can't silently drift.
+ *
+ * Tree-shakeable: this lives on its OWN module (re-exported on the
+ * `@glissade/scene/describe` subpath / the `@glissade/browser` bundle), so it is
+ * never pulled onto the base embed path — a scene that never calls `describe()`
+ * pays zero bytes for it.
+ */
+/** One animatable / settable prop in the manifest. */
+interface DescribedProp {
+  /** The §2.2 value-type id this prop accepts (e.g. `'vec2'`, `'number'`, `'color'`). */
+  type: string;
+  /** Whether a Track can drive it (every registered target is animatable). */
+  animatable: boolean;
+  /** The track-target template, `'<id>/<path>'` — substitute the node's real id. */
+  target?: string;
+  /** Component count of the value (`vec2` → 2, scalar → 1); omitted for non-numeric reprs. */
+  arity?: number;
+}
+interface DescribedNode {
+  props: {
+    [prop: string]: DescribedProp;
+  };
+}
+interface DescribedBuilderMethod {
+  name: string;
+  signature: string;
+}
+/** The full machine-readable manifest `describe()` returns. */
+interface ApiManifest {
+  version: string;
+  nodes: {
+    [typeName: string]: DescribedNode;
+  };
+  valueTypes: string[];
+  easings: string[];
+  builder: {
+    methods: DescribedBuilderMethod[];
+  };
+  createScene: string;
+  subpaths: {
+    [entry: string]: string;
+  };
+}
+/**
+ * Build the machine-readable API manifest from the live registries (§4.4). Pure
+ * introspection: instantiate each built-in node once to read its registered track
+ * targets, enumerate the ValueType + easing registries, and curate the builder /
+ * subpath surface. JSON-serializable; safe to call any number of times.
+ */
+declare function describe(): ApiManifest;
+//#endregion
+export { ApiManifest, DescribedBuilderMethod, DescribedNode, DescribedProp, describe };

package/dist/describe.js

@@ -0,0 +1,153 @@
+import { a as Path, c as Video, i as ImageNode, o as Rect, r as Group, s as Text, t as Circle } from "./nodes.js";
+import { easings, listValueTypes } from "@glissade/core";
+//#region src/describe.ts
+/**
+* `describe()` — a machine-readable API manifest (0.18), the structural antidote
+* to discoverability: an AI consumer reads GROUND TRUTH from the artifact instead
+* of reverse-engineering the surface. PURE INTROSPECTION — it instantiates each
+* built-in node once, reads its registered track targets, and enumerates the core
+* registries; it never touches `evaluate()` or any cross-frame state, so it has
+* zero determinism impact.
+*
+* The whole point is NO-DRIFT: every section is GENERATED from the live registry
+* it documents (`Node.listTargets()` → the real `registerTarget` calls,
+* `listValueTypes()` → the ValueType registry, `easings` → the easing registry),
+* so the manifest can't fall out of sync with what the framework actually does.
+* The builder method list and the subpath map are the lone curated parts (runtime
+* signatures aren't introspectable); a test pins the builder names to the
+* `TimelineBuilder` interface so even those can't silently drift.
+*
+* Tree-shakeable: this lives on its OWN module (re-exported on the
+* `@glissade/scene/describe` subpath / the `@glissade/browser` bundle), so it is
+* never pulled onto the base embed path — a scene that never calls `describe()`
+* pays zero bytes for it.
+*/
+const RAW_VERSION = "0.18.0-pre.5";
+const PACKAGE_VERSION = RAW_VERSION.includes("GLISSADE_".concat("VERSION")) ? "0.0.0-dev" : RAW_VERSION;
+/** Arity of a value type's numeric repr: vec2/vec2-arc → 2, number → 1; others (color/paint/path/string/boolean) carry no scalar arity. */
+function arityOf(type) {
+	if (type === "number") return 1;
+	if (type === "vec2" || type === "vec2-arc") return 2;
+}
+/**
+* Render a target's `expects` stamp to a single manifest type string. A
+* polymorphic prop (e.g. `fill` is `['color','paint']`) joins with `|`; an
+* untagged target (the 0.13 back-compat 2-arg `registerTarget`) reports
+* `'unknown'`.
+*/
+function expectsToType(expects) {
+	if (expects === void 0) return "unknown";
+	return Array.isArray(expects) ? expects.join("|") : expects;
+}
+/** Introspect one freshly-instantiated node into its prop manifest, reading the
+* REAL `registerTarget` calls via `listTargets()` (so it can't drift). */
+function describeNode(node) {
+	const props = {};
+	for (const { path, expects } of node.listTargets()) {
+		const type = expectsToType(expects);
+		const arity = arityOf(type);
+		props[path] = {
+			type,
+			animatable: true,
+			target: `<id>/${path}`,
+			...arity !== void 0 ? { arity } : {}
+		};
+	}
+	return { props };
+}
+const NODE_FACTORIES = {
+	Group: () => new Group(),
+	Rect: () => new Rect(),
+	Circle: () => new Circle(),
+	Path: () => new Path(),
+	Text: () => new Text(),
+	Image: () => new ImageNode({ assetId: "~describe" }),
+	Video: () => new Video({ assetId: "~describe" })
+};
+/**
+* The curated `TimelineBuilder` surface (§2.6). Runtime signatures aren't
+* introspectable, so this is hand-kept — `describe.test.ts` pins every name here
+* to the `TimelineBuilder` interface so it can't silently drift from the API.
+*/
+const BUILDER_METHODS = [
+	{
+		name: "to",
+		signature: "to<T>(target, value, opts?: { duration?, ease?, at?, from? }): TimelineBuilder"
+	},
+	{
+		name: "fromTo",
+		signature: "fromTo<T>(target, from, to, opts?: { duration?, ease?, at? }): TimelineBuilder"
+	},
+	{
+		name: "stagger",
+		signature: "stagger<T>(targets, { to, from?, duration?, ease? }, { each, anchor?, at? }): TimelineBuilder"
+	},
+	{
+		name: "set",
+		signature: "set<T>(target, value, opts?: { at? }): TimelineBuilder"
+	},
+	{
+		name: "label",
+		signature: "label(name, at?): TimelineBuilder"
+	},
+	{
+		name: "add",
+		signature: "add(child, at?, opts?: { mode?: 'add'|'sync', timeScale? }): TimelineBuilder"
+	},
+	{
+		name: "sequence",
+		signature: "sequence(subs, opts?: { gap? }): TimelineBuilder"
+	},
+	{
+		name: "at",
+		signature: "at(time, sub): TimelineBuilder"
+	},
+	{
+		name: "call",
+		signature: "call(fn, at?): TimelineBuilder"
+	},
+	{
+		name: "cue",
+		signature: "cue(at, name, data?): TimelineBuilder"
+	},
+	{
+		name: "adBreak",
+		signature: "adBreak(at, opts?: { id?, duration? }): TimelineBuilder"
+	},
+	{
+		name: "editable",
+		signature: "editable(): TimelineBuilder"
+	},
+	{
+		name: "editableDuration",
+		signature: "editableDuration(): TimelineBuilder"
+	}
+];
+/** One-line "what's there" for each documented tree-shakeable subpath entry. */
+const SUBPATHS = {
+	"@glissade/core/clips": "motion clips: clip/clipList + the popIn/slideIn/pulse/driftLoop literals, presence (enter/exit) and morph (box-FLIP) build-time sugar.",
+	"@glissade/core/i18n": "localization: requireParity (id-set diff), localize (doc→doc resolver), t() ambient-table sugar.",
+	"@glissade/scene/layout": "flexbox: the Yoga-backed Layout node + LayoutEngine (the only entry that ships Yoga wasm).",
+	"@glissade/scene/path": "SVG geometry: pathFromSvg / parseSvgPathData — parse an SVG `d` string into a PathValue for Path.data."
+};
+/**
+* Build the machine-readable API manifest from the live registries (§4.4). Pure
+* introspection: instantiate each built-in node once to read its registered track
+* targets, enumerate the ValueType + easing registries, and curate the builder /
+* subpath surface. JSON-serializable; safe to call any number of times.
+*/
+function describe() {
+	const nodes = {};
+	for (const [name, factory] of Object.entries(NODE_FACTORIES)) nodes[name] = describeNode(factory());
+	return {
+		version: PACKAGE_VERSION,
+		nodes,
+		valueTypes: listValueTypes(),
+		easings: Object.keys(easings),
+		builder: { methods: BUILDER_METHODS },
+		createScene: "createScene({ size: { w, h }, children: Node[] }): Scene",
+		subpaths: SUBPATHS
+	};
+}
+//#endregion
+export { describe };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as segmentGraphemes, B as collapseReplacer, C as Node, D as estimatingMeasurer, E as breakLines, F as filtersToCanvasFilter, G as IDENTITY, H as formatDisplayDiff, I as glow, J as invert, K as applyToPoint, L as validateFilters, M as setDefaultMeasurer, N as FilterValidationError, O as fallbackMeasurer, P as createDisplayListBuilder, R as DL_SNAPSHOT_VERSION, S as validateSketch, T as MEASURE_QUANTUM_PX, U as parseDisplaySnapshot, V as diffDisplayLists, W as serializeDisplayList, X as multiply, Y as matEquals, _ as hashStr, a as Path, b as sketchStrokes, c as Video, d as revealSchedule, f as roundedRectSegs, g as hachureLines, h as flatten, i as ImageNode, j as segmentWords, k as quantize, l as coercePathData, m as arcLength, n as Custom, o as Rect, p as SketchValidationError, q as fromTRS, r as Group, s as Text, t as Circle, u as pathFromSegs, v as resolveSketch, w as resolveAnchor, x as validateHachure, y as roughen, z as DlSnapshotError } from "./nodes.js";
+import { A as sketchStrokes, B as collapseReplacer, C as SketchValidationError, D as hashStr, E as hachureLines, F as filtersToCanvasFilter, G as IDENTITY, H as formatDisplayDiff, I as glow, J as invert, K as applyToPoint, L as validateFilters, M as validateSketch, N as FilterValidationError, O as resolveSketch, P as createDisplayListBuilder, R as DL_SNAPSHOT_VERSION, S as setDefaultMeasurer, T as flatten, U as parseDisplaySnapshot, V as diffDisplayLists, W as serializeDisplayList, X as multiply, Y as matEquals, _ as estimatingMeasurer, a as Path, b as segmentGraphemes, c as Video, d as revealSchedule, f as roundedRectSegs, g as breakLines, h as MEASURE_QUANTUM_PX, i as ImageNode, j as validateHachure, k as roughen, l as coercePathData, m as resolveAnchor, n as Custom, o as Rect, p as Node, q as fromTRS, r as Group, s as Text, t as Circle, u as pathFromSegs, v as fallbackMeasurer, w as arcLength, x as segmentWords, y as quantize, z as DlSnapshotError } from "./nodes.js";
 import { i as setLayoutEngine, n as getLayoutEngine, r as requireLayoutEngine, t as LayoutEngineMissingError } from "./layoutEngine.js";
 import { bindTimeline, buildFontRegistry, compileTimeline, createPlayhead, emitDevWarning, evaluateAt, key, lerpColor, oklabToRgba, parseCmap, parseColor, random, rgbaToOklab, signal, stagger, track, validateFonts, vec2Signal } from "@glissade/core";
 //#region src/taxonomy.ts

package/dist/layout.d.ts

@@ -77,7 +77,24 @@ interface StackProps extends LayoutProps {}
  * Every other prop passes straight through to `Layout`.
  */
 declare function Stack(props?: StackProps): Layout;
+/**
+ * `Row`/`Column` props — `Stack`'s surface MINUS `direction` (the alias pins it).
+ * Omitting `direction` from the type means an explicit one can't even be passed,
+ * so `Row({...})` is unambiguously a row and `Column({...})` a column.
+ */
+interface RowProps extends Omit<StackProps, 'direction'> {}
+/**
+ * `Stack({ direction: 'row' })` read as a name — a horizontal stack. Inherits
+ * Stack's `align:'start'` default and Layout's pure memoized resolve; the only
+ * difference from `Stack` is the pinned `direction`.
+ */
+declare function Row(props?: RowProps): Layout;
+/**
+ * `Stack({ direction: 'column' })` read as a name — a vertical stack (the same
+ * direction `Stack` already defaults to, made explicit at the call site).
+ */
+declare function Column(props?: RowProps): Layout;
 /** Load Yoga (wasm) and register it as the active LayoutEngine. Idempotent. */
 declare function loadYogaLayoutEngine(): Promise<LayoutEngine>;
 //#endregion
-export { Layout, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, LayoutProps, type LayoutResult, Stack, StackProps, getLayoutEngine, loadYogaLayoutEngine, setLayoutEngine };
+export { Column, Layout, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, LayoutProps, type LayoutResult, Row, RowProps, Stack, StackProps, getLayoutEngine, loadYogaLayoutEngine, setLayoutEngine };

package/dist/layout.js

@@ -1,4 +1,4 @@
-import { O as fallbackMeasurer, r as Group } from "./nodes.js";
+import { r as Group, v as fallbackMeasurer } from "./nodes.js";
 import { i as setLayoutEngine, n as getLayoutEngine, r as requireLayoutEngine, t as LayoutEngineMissingError } from "./layoutEngine.js";
 import { computed, signal } from "@glissade/core";
 //#region src/layout.ts
@@ -170,6 +170,27 @@ function Stack(props = {}) {
 		align: props.align ?? "start"
 	});
 }
+/**
+* `Stack({ direction: 'row' })` read as a name — a horizontal stack. Inherits
+* Stack's `align:'start'` default and Layout's pure memoized resolve; the only
+* difference from `Stack` is the pinned `direction`.
+*/
+function Row(props = {}) {
+	return Stack({
+		...props,
+		direction: "row"
+	});
+}
+/**
+* `Stack({ direction: 'column' })` read as a name — a vertical stack (the same
+* direction `Stack` already defaults to, made explicit at the call site).
+*/
+function Column(props = {}) {
+	return Stack({
+		...props,
+		direction: "column"
+	});
+}
 function initProp(sig, init) {
 	if (typeof init === "function") sig.bindSource(init);
 	else if (init !== void 0) sig.set(init);
@@ -234,4 +255,4 @@ async function loadYogaLayoutEngine() {
 	return engine;
 }
 //#endregion
-export { Layout, LayoutEngineMissingError, Stack, getLayoutEngine, loadYogaLayoutEngine, setLayoutEngine };
+export { Column, Layout, LayoutEngineMissingError, Row, Stack, getLayoutEngine, loadYogaLayoutEngine, setLayoutEngine };

package/dist/layoutEngine.d.ts

@@ -182,6 +182,18 @@ declare abstract class Node {
     unbindSource(): void;
   }, expects?: ValueTypeId | readonly ValueTypeId[]): void;
   resolveTarget(path: string): BindablePropTarget | undefined;
+  /**
+   * Enumerate this node's registered track-target paths and the value type each
+   * accepts — the introspection seam `describe()` reads to build the API
+   * manifest from the REAL `registerTarget` calls (so it can't drift). Returns
+   * `[path, expects]` pairs in registration order; `expects` is the §2.2 type
+   * stamp (a `ValueTypeId`, an array for a polymorphic prop like `fill`, or
+   * `undefined` for an untagged target).
+   */
+  listTargets(): {
+    path: string;
+    expects: ValueTypeId | readonly ValueTypeId[] | undefined;
+  }[];
   /** Subclass drawing: emit own commands (and children for containers). */
   protected abstract draw(out: DisplayListBuilder, ctx: EvalContext): void;
   /**

package/dist/nodes.js

@@ -373,117 +373,404 @@ function createDisplayListBuilder(size) {
 	};
 }
 //#endregion
-//#region src/text.ts
-/**
-* §3.6 measurement quantum (px). Scene-owned pre-measure quantizes every
-* layout-feeding advance to this grid ONCE, then hands Yoga frozen integers —
-* so sub-pixel measureText drift between Skia/HarfBuzz versions cannot move a
-* whole layout. The single source of truth for the grid; `quantize` rounds to
-* it. (Yoga's `setMeasureFunc` was considered and rejected — see DESIGN.md §3.6.)
-*/
-const MEASURE_QUANTUM_PX = .5;
-/** §3.6 measurement quantum — round to the MEASURE_QUANTUM_PX grid. */
-function quantize(v) {
-	return Math.round(v / MEASURE_QUANTUM_PX) * MEASURE_QUANTUM_PX;
-}
-/**
-* Estimating fallback measurer — used only when no backend has been injected
-* (e.g. evaluating for IR-level tests). Deterministic but not metrically
-* faithful; mount(), the CLI, and exporters always inject the real one.
-*/
-let defaultMeasurer = null;
-/**
-* Process-wide fallback measurer for FACTORY-TIME measurement — component
-* factories run before any scene exists, so Text pulls (measuredSize,
-* lineBoxes, wordBoxes) and createScene fall back here before the estimator.
-* Node consumers: `setDefaultMeasurer(createMeasurer({ fonts }))` from
-* @glissade/backend-skia gives factory code the rasterizer's real metrics.
-* Scene-injected measurers (mount/CLI/golden harness) always win.
-*/
-function setDefaultMeasurer(m) {
-	defaultMeasurer = m;
-}
-/** The default-or-estimating chain end; internal fallback for measurer pulls. */
-function fallbackMeasurer() {
-	return defaultMeasurer ?? estimatingMeasurer;
-}
-const estimatingMeasurer = { measureText(text, font) {
-	return {
-		width: text.length * font.size * .52,
-		ascent: font.size * .8,
-		descent: font.size * .2
-	};
-} };
-let wordSegmenter;
+//#region src/sketch.ts
 /**
-* The draw-path word segmentation (Intl.Segmenter boundaries, punctuation
-* glued to its predecessor) — exported so Text.wordBoxes() boxes EXACTLY the
-* units the breaker flows.
+* Hand-drawn stroke styles via GEOMETRIC roughening — not raster textures. A
+* shape's outline is flattened to polylines, then each segment is redrawn as a
+* slightly jittered, bowed stroke, overlaid in a few passes. Because it's pure
+* path math seeded by a stable per-shape seed, the result is byte-identical on
+* both backends and re-evaluates deterministically (the seed is consumed fresh
+* each draw, never as a shared stateful stream).
 */
-function segmentWords(text) {
-	if (wordSegmenter === void 0) wordSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "word" }) : null;
-	if (wordSegmenter) {
-		const raw = [...wordSegmenter.segment(text)].map((s) => s.segment);
-		const glued = [];
-		for (const seg of raw) if (glued.length > 0 && /^[^\p{L}\p{N}\s]+$/u.test(seg)) glued[glued.length - 1] += seg;
-		else glued.push(seg);
-		return glued;
+const KINDS = [
+	"marker",
+	"crayon",
+	"pencil",
+	"ink",
+	"chalk"
+];
+var SketchValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SketchValidationError";
 	}
-	return text.split(/(\s+)/).filter((w) => w.length > 0);
+};
+/** Reject unknown kinds / out-of-range params at construction (like validateFilters). */
+function validateSketch(s) {
+	if (!KINDS.includes(s.kind)) throw new SketchValidationError(`unknown sketch kind '${String(s.kind)}' (have: ${KINDS.join(", ")})`);
+	if (s.width !== void 0 && !(s.width > 0)) throw new SketchValidationError(`sketch width must be > 0, got ${String(s.width)}`);
+	if (s.roughness !== void 0 && !(s.roughness >= 0)) throw new SketchValidationError(`sketch roughness must be ≥ 0, got ${String(s.roughness)}`);
+	if ((s.kind === "crayon" || s.kind === "pencil") && s.passes !== void 0 && !(s.passes >= 1)) throw new SketchValidationError(`sketch passes must be ≥ 1, got ${String(s.passes)}`);
+	if (s.kind === "chalk" && s.dash !== void 0 && (!Array.isArray(s.dash) || s.dash.some((d) => !(d >= 0)))) throw new SketchValidationError("sketch chalk dash must be an array of non-negative numbers");
 }
-let graphemeSegmenter;
-/**
-* Split text into graphemes (user-perceived characters). Exported so Text.draw
-* (reveal masking), Text.graphemes() (authoring), and revealSchedule() (the SFX
-* keystroke contract) all count the SAME units.
-*/
-function segmentGraphemes(text) {
-	if (graphemeSegmenter === void 0) graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
-	if (graphemeSegmenter) return [...graphemeSegmenter.segment(text)].map((s) => s.segment);
-	return Array.from(text);
+/** Per-kind defaults — the character of each look. */
+function resolveSketch(s) {
+	switch (s.kind) {
+		case "marker": return {
+			width: s.width ?? 8,
+			roughness: s.roughness ?? 1.2,
+			passes: 2
+		};
+		case "crayon": return {
+			width: s.width ?? 4,
+			roughness: s.roughness ?? 2.4,
+			passes: s.passes ?? 3
+		};
+		case "pencil": return {
+			width: s.width ?? 1.5,
+			roughness: s.roughness ?? 1,
+			passes: s.passes ?? 2
+		};
+		case "ink": return {
+			width: s.width ?? 2.5,
+			roughness: s.roughness ?? .8,
+			passes: 1
+		};
+		case "chalk": return {
+			width: s.width ?? 3,
+			roughness: s.roughness ?? 1.6,
+			passes: 1,
+			dash: s.dash ?? [6, 5]
+		};
+	}
 }
+const cubic = (p0, c1, c2, p1, t) => {
+	const mt = 1 - t;
+	const a = mt * mt * mt;
+	const b = 3 * mt * mt * t;
+	const c = 3 * mt * t * t;
+	const d = t * t * t;
+	return [a * p0[0] + b * c1[0] + c * c2[0] + d * p1[0], a * p0[1] + b * c1[1] + c * c2[1] + d * p1[1]];
+};
+const quad = (p0, c, p1, t) => {
+	const mt = 1 - t;
+	return [mt * mt * p0[0] + 2 * mt * t * c[0] + t * t * p1[0], mt * mt * p0[1] + 2 * mt * t * c[1] + t * t * p1[1]];
+};
+const ellipse = (cx, cy, rx, ry, rot, ang) => {
+	const ex = rx * Math.cos(ang);
+	const ey = ry * Math.sin(ang);
+	const cos = Math.cos(rot);
+	const sin = Math.sin(rot);
+	return [cx + ex * cos - ey * sin, cy + ex * sin + ey * cos];
+};
 /**
-* Greedy line breaking: explicit '\n' always breaks; otherwise word segments
-* flow until maxWidth is exceeded (Intl.Segmenter boundaries, so CJK wraps
-* without spaces). A segment wider than maxWidth gets its own line (no
-* intra-word breaking in v1).
+* Flatten a path to polylines — de Casteljau for C/Q, arc sampling for E
+* (Circle and rounded-rect corners are 'E' segments, so this MUST handle them
+* or those shapes roughen wrong). `steps` is the samples per curved segment.
 */
-function breakLines(text, font, maxWidth, measurer) {
-	const paragraphs = text.split("\n");
-	if (maxWidth === void 0 || maxWidth <= 0) return paragraphs;
-	const lines = [];
-	for (const para of paragraphs) {
-		const words = segmentWords(para);
-		let line = "";
-		for (const word of words) {
-			const candidate = line + word;
-			if (line !== "" && quantize(measurer.measureText(candidate.trimEnd(), font).width) > maxWidth) {
-				lines.push(line.trimEnd());
-				line = word.trimStart() === "" ? "" : word;
-			} else line = candidate;
+function flatten(segs, steps = 16) {
+	const polys = [];
+	let cur = null;
+	let px = 0;
+	let py = 0;
+	let sx = 0;
+	let sy = 0;
+	const ensure = (x, y) => {
+		if (!cur) {
+			cur = {
+				points: [[x, y]],
+				closed: false
+			};
+			polys.push(cur);
+			sx = x;
+			sy = y;
 		}
-		lines.push(line.trimEnd());
+		return cur;
+	};
+	for (const s of segs) switch (s[0]) {
+		case "M":
+			cur = {
+				points: [[s[1], s[2]]],
+				closed: false
+			};
+			polys.push(cur);
+			px = sx = s[1];
+			py = sy = s[2];
+			break;
+		case "L":
+			ensure(px, py).points.push([s[1], s[2]]);
+			px = s[1];
+			py = s[2];
+			break;
+		case "C": {
+			const c = ensure(px, py);
+			for (let k = 1; k <= steps; k++) c.points.push(cubic([px, py], [s[1], s[2]], [s[3], s[4]], [s[5], s[6]], k / steps));
+			px = s[5];
+			py = s[6];
+			break;
+		}
+		case "Q": {
+			const c = ensure(px, py);
+			for (let k = 1; k <= steps; k++) c.points.push(quad([px, py], [s[1], s[2]], [s[3], s[4]], k / steps));
+			px = s[3];
+			py = s[4];
+			break;
+		}
+		case "E": {
+			const [, cx, cy, rx, ry, rot, a0, a1] = s;
+			const begin = ellipse(cx, cy, rx, ry, rot, a0);
+			const c = ensure(begin[0], begin[1]);
+			for (let k = 1; k <= steps; k++) c.points.push(ellipse(cx, cy, rx, ry, rot, a0 + (a1 - a0) * (k / steps)));
+			const end = ellipse(cx, cy, rx, ry, rot, a1);
+			px = end[0];
+			py = end[1];
+			break;
+		}
+		case "Z":
+			if (cur) {
+				cur.points.push([sx, sy]);
+				cur.closed = true;
+				px = sx;
+				py = sy;
+			}
+			break;
 	}
-	return lines;
+	return polys.filter((p) => p.points.length > 0);
+}
+/** Total length of a flattened polyline (for draw-on dashing). */
+function arcLength(poly) {
+	let len = 0;
+	for (let i = 1; i < poly.points.length; i++) len += Math.hypot(poly.points[i][0] - poly.points[i - 1][0], poly.points[i][1] - poly.points[i - 1][1]);
+	return len;
+}
+function validateHachure(h) {
+	if (!(h.gap > 0)) throw new SketchValidationError(`hachure gap must be > 0, got ${String(h.gap)}`);
+	if (h.roughness !== void 0 && !(h.roughness >= 0)) throw new SketchValidationError(`hachure roughness must be ≥ 0, got ${String(h.roughness)}`);
 }
-//#endregion
-//#region src/node.ts
 /**
-* Scene-graph node base (DESIGN.md §3.1): every animatable property is a
-* signal; transforms are computed matrix signals; emit() is pure — it reads
-* signals and ctx only, and produces IR commands, never canvas calls.
+* Parallel hatch lines covering a path's bounding box at `angleRad`, spaced
+* `gap`, lightly jittered. Returned as `M/L` segments to be stroked INSIDE a
+* clip of the shape (the caller emits the clip). Pure; `rng` reseeded per draw.
 */
-const ANCHOR_PRESETS = {
-	"center": [.5, .5],
-	"top-left": [0, 0],
-	"top": [.5, 0],
-	"top-right": [1, 0],
-	"left": [0, .5],
-	"right": [1, .5],
-	"bottom-left": [0, 1],
-	"bottom": [.5, 1],
-	"bottom-right": [1, 1]
-};
+function hachureLines(segs, spec, rng) {
+	const polys = flatten(segs);
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const p of polys) for (const [x, y] of p.points) {
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+	}
+	if (!Number.isFinite(minX)) return [];
+	const cx = (minX + maxX) / 2;
+	const cy = (minY + maxY) / 2;
+	const ca = Math.cos(spec.angleRad);
+	const sa = Math.sin(spec.angleRad);
+	const toRot = (x, y) => [(x - cx) * ca + (y - cy) * sa, -(x - cx) * sa + (y - cy) * ca];
+	const fromRot = (x, y) => [cx + x * ca - y * sa, cy + x * sa + y * ca];
+	let rMinX = Infinity;
+	let rMinY = Infinity;
+	let rMaxX = -Infinity;
+	let rMaxY = -Infinity;
+	const corners = [
+		[minX, minY],
+		[maxX, minY],
+		[maxX, maxY],
+		[minX, maxY]
+	];
+	for (const [x, y] of corners) {
+		const [rx, ry] = toRot(x, y);
+		if (rx < rMinX) rMinX = rx;
+		if (ry < rMinY) rMinY = ry;
+		if (rx > rMaxX) rMaxX = rx;
+		if (ry > rMaxY) rMaxY = ry;
+	}
+	const rough = spec.roughness ?? 1;
+	const jit = () => (rng() * 2 - 1) * rough;
+	const out = [];
+	for (let y = rMinY + spec.gap / 2; y < rMaxY; y += spec.gap) {
+		const a = fromRot(rMinX, y + jit());
+		const b = fromRot(rMaxX, y + jit());
+		out.push([
+			"M",
+			a[0],
+			a[1]
+		], [
+			"L",
+			b[0],
+			b[1]
+		]);
+	}
+	return out;
+}
+/**
+* Roughen a path into hand-drawn stroke passes. Each segment becomes a bowed,
+* jittered quadratic; `passes` overlay slightly different jitters for the
+* built-up look. `rng` must be a freshly seeded generator (the caller reseeds
+* per draw from a stable seed, so evaluate() stays pure).
+*/
+function roughen(segs, style, rng) {
+	const resolved = resolveSketch(style);
+	const polys = flatten(segs);
+	const jit = () => (rng() * 2 - 1) * resolved.roughness;
+	const strokes = [];
+	for (let pass = 0; pass < resolved.passes; pass++) {
+		const out = [];
+		for (const poly of polys) {
+			const pts = poly.points;
+			if (pts.length < 2) continue;
+			let ax = pts[0][0] + jit();
+			let ay = pts[0][1] + jit();
+			out.push([
+				"M",
+				ax,
+				ay
+			]);
+			for (let i = 1; i < pts.length; i++) {
+				const bx = pts[i][0] + jit();
+				const by = pts[i][1] + jit();
+				const dx = bx - ax;
+				const dy = by - ay;
+				const len = Math.hypot(dx, dy) || 1;
+				const bow = jit() * .5;
+				const mx = (ax + bx) / 2 + -dy / len * bow;
+				const my = (ay + by) / 2 + dx / len * bow;
+				out.push([
+					"Q",
+					mx,
+					my,
+					bx,
+					by
+				]);
+				ax = bx;
+				ay = by;
+			}
+		}
+		strokes.push(out);
+	}
+	return {
+		strokes,
+		resolved
+	};
+}
+/** FNV-1a 32-bit — a stable per-shape sketch seed from its id. */
+function hashStr(s) {
+	let h = 2166136261;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+/** Convenience: the rough stroke passes for a path at a given seed. */
+function sketchStrokes(segs, style, seed) {
+	return roughen(segs, style, random(seed >>> 0)).strokes;
+}
+//#endregion
+//#region src/text.ts
+/**
+* §3.6 measurement quantum (px). Scene-owned pre-measure quantizes every
+* layout-feeding advance to this grid ONCE, then hands Yoga frozen integers —
+* so sub-pixel measureText drift between Skia/HarfBuzz versions cannot move a
+* whole layout. The single source of truth for the grid; `quantize` rounds to
+* it. (Yoga's `setMeasureFunc` was considered and rejected — see DESIGN.md §3.6.)
+*/
+const MEASURE_QUANTUM_PX = .5;
+/** §3.6 measurement quantum — round to the MEASURE_QUANTUM_PX grid. */
+function quantize(v) {
+	return Math.round(v / MEASURE_QUANTUM_PX) * MEASURE_QUANTUM_PX;
+}
+/**
+* Estimating fallback measurer — used only when no backend has been injected
+* (e.g. evaluating for IR-level tests). Deterministic but not metrically
+* faithful; mount(), the CLI, and exporters always inject the real one.
+*/
+let defaultMeasurer = null;
+/**
+* Process-wide fallback measurer for FACTORY-TIME measurement — component
+* factories run before any scene exists, so Text pulls (measuredSize,
+* lineBoxes, wordBoxes) and createScene fall back here before the estimator.
+* Node consumers: `setDefaultMeasurer(createMeasurer({ fonts }))` from
+* @glissade/backend-skia gives factory code the rasterizer's real metrics.
+* Scene-injected measurers (mount/CLI/golden harness) always win.
+*/
+function setDefaultMeasurer(m) {
+	defaultMeasurer = m;
+}
+/** The default-or-estimating chain end; internal fallback for measurer pulls. */
+function fallbackMeasurer() {
+	return defaultMeasurer ?? estimatingMeasurer;
+}
+const estimatingMeasurer = { measureText(text, font) {
+	return {
+		width: text.length * font.size * .52,
+		ascent: font.size * .8,
+		descent: font.size * .2
+	};
+} };
+let wordSegmenter;
+/**
+* The draw-path word segmentation (Intl.Segmenter boundaries, punctuation
+* glued to its predecessor) — exported so Text.wordBoxes() boxes EXACTLY the
+* units the breaker flows.
+*/
+function segmentWords(text) {
+	if (wordSegmenter === void 0) wordSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "word" }) : null;
+	if (wordSegmenter) {
+		const raw = [...wordSegmenter.segment(text)].map((s) => s.segment);
+		const glued = [];
+		for (const seg of raw) if (glued.length > 0 && /^[^\p{L}\p{N}\s]+$/u.test(seg)) glued[glued.length - 1] += seg;
+		else glued.push(seg);
+		return glued;
+	}
+	return text.split(/(\s+)/).filter((w) => w.length > 0);
+}
+let graphemeSegmenter;
+/**
+* Split text into graphemes (user-perceived characters). Exported so Text.draw
+* (reveal masking), Text.graphemes() (authoring), and revealSchedule() (the SFX
+* keystroke contract) all count the SAME units.
+*/
+function segmentGraphemes(text) {
+	if (graphemeSegmenter === void 0) graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+	if (graphemeSegmenter) return [...graphemeSegmenter.segment(text)].map((s) => s.segment);
+	return Array.from(text);
+}
+/**
+* Greedy line breaking: explicit '\n' always breaks; otherwise word segments
+* flow until maxWidth is exceeded (Intl.Segmenter boundaries, so CJK wraps
+* without spaces). A segment wider than maxWidth gets its own line (no
+* intra-word breaking in v1).
+*/
+function breakLines(text, font, maxWidth, measurer) {
+	const paragraphs = text.split("\n");
+	if (maxWidth === void 0 || maxWidth <= 0) return paragraphs;
+	const lines = [];
+	for (const para of paragraphs) {
+		const words = segmentWords(para);
+		let line = "";
+		for (const word of words) {
+			const candidate = line + word;
+			if (line !== "" && quantize(measurer.measureText(candidate.trimEnd(), font).width) > maxWidth) {
+				lines.push(line.trimEnd());
+				line = word.trimStart() === "" ? "" : word;
+			} else line = candidate;
+		}
+		lines.push(line.trimEnd());
+	}
+	return lines;
+}
+//#endregion
+//#region src/node.ts
+/**
+* Scene-graph node base (DESIGN.md §3.1): every animatable property is a
+* signal; transforms are computed matrix signals; emit() is pure — it reads
+* signals and ctx only, and produces IR commands, never canvas calls.
+*/
+const ANCHOR_PRESETS = {
+	"center": [.5, .5],
+	"top-left": [0, 0],
+	"top": [.5, 0],
+	"top-right": [1, 0],
+	"left": [0, .5],
+	"right": [1, .5],
+	"bottom-left": [0, 1],
+	"bottom": [.5, 1],
+	"bottom-right": [1, 1]
+};
 function resolveAnchor(spec) {
 	if (typeof spec === "string") {
 		const preset = ANCHOR_PRESETS[spec];
@@ -591,6 +878,20 @@ var Node = class {
 		return this.targets.get(path);
 	}
 	/**
+	* Enumerate this node's registered track-target paths and the value type each
+	* accepts — the introspection seam `describe()` reads to build the API
+	* manifest from the REAL `registerTarget` calls (so it can't drift). Returns
+	* `[path, expects]` pairs in registration order; `expects` is the §2.2 type
+	* stamp (a `ValueTypeId`, an array for a polymorphic prop like `fill`, or
+	* `undefined` for an untagged target).
+	*/
+	listTargets() {
+		return [...this.targets].map(([path, sig]) => ({
+			path,
+			expects: sig.expects
+		}));
+	}
+	/**
 	* Natural size for flex flow (§3.2); null = not flowable (a Layout parent
 	* emits such children absolutely, untouched).
 	*/
@@ -698,293 +999,6 @@ var Node = class {
 	}
 };
 //#endregion
-//#region src/sketch.ts
-/**
-* Hand-drawn stroke styles via GEOMETRIC roughening — not raster textures. A
-* shape's outline is flattened to polylines, then each segment is redrawn as a
-* slightly jittered, bowed stroke, overlaid in a few passes. Because it's pure
-* path math seeded by a stable per-shape seed, the result is byte-identical on
-* both backends and re-evaluates deterministically (the seed is consumed fresh
-* each draw, never as a shared stateful stream).
-*/
-const KINDS = [
-	"marker",
-	"crayon",
-	"pencil",
-	"ink",
-	"chalk"
-];
-var SketchValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "SketchValidationError";
-	}
-};
-/** Reject unknown kinds / out-of-range params at construction (like validateFilters). */
-function validateSketch(s) {
-	if (!KINDS.includes(s.kind)) throw new SketchValidationError(`unknown sketch kind '${String(s.kind)}' (have: ${KINDS.join(", ")})`);
-	if (s.width !== void 0 && !(s.width > 0)) throw new SketchValidationError(`sketch width must be > 0, got ${String(s.width)}`);
-	if (s.roughness !== void 0 && !(s.roughness >= 0)) throw new SketchValidationError(`sketch roughness must be ≥ 0, got ${String(s.roughness)}`);
-	if ((s.kind === "crayon" || s.kind === "pencil") && s.passes !== void 0 && !(s.passes >= 1)) throw new SketchValidationError(`sketch passes must be ≥ 1, got ${String(s.passes)}`);
-	if (s.kind === "chalk" && s.dash !== void 0 && (!Array.isArray(s.dash) || s.dash.some((d) => !(d >= 0)))) throw new SketchValidationError("sketch chalk dash must be an array of non-negative numbers");
-}
-/** Per-kind defaults — the character of each look. */
-function resolveSketch(s) {
-	switch (s.kind) {
-		case "marker": return {
-			width: s.width ?? 8,
-			roughness: s.roughness ?? 1.2,
-			passes: 2
-		};
-		case "crayon": return {
-			width: s.width ?? 4,
-			roughness: s.roughness ?? 2.4,
-			passes: s.passes ?? 3
-		};
-		case "pencil": return {
-			width: s.width ?? 1.5,
-			roughness: s.roughness ?? 1,
-			passes: s.passes ?? 2
-		};
-		case "ink": return {
-			width: s.width ?? 2.5,
-			roughness: s.roughness ?? .8,
-			passes: 1
-		};
-		case "chalk": return {
-			width: s.width ?? 3,
-			roughness: s.roughness ?? 1.6,
-			passes: 1,
-			dash: s.dash ?? [6, 5]
-		};
-	}
-}
-const cubic = (p0, c1, c2, p1, t) => {
-	const mt = 1 - t;
-	const a = mt * mt * mt;
-	const b = 3 * mt * mt * t;
-	const c = 3 * mt * t * t;
-	const d = t * t * t;
-	return [a * p0[0] + b * c1[0] + c * c2[0] + d * p1[0], a * p0[1] + b * c1[1] + c * c2[1] + d * p1[1]];
-};
-const quad = (p0, c, p1, t) => {
-	const mt = 1 - t;
-	return [mt * mt * p0[0] + 2 * mt * t * c[0] + t * t * p1[0], mt * mt * p0[1] + 2 * mt * t * c[1] + t * t * p1[1]];
-};
-const ellipse = (cx, cy, rx, ry, rot, ang) => {
-	const ex = rx * Math.cos(ang);
-	const ey = ry * Math.sin(ang);
-	const cos = Math.cos(rot);
-	const sin = Math.sin(rot);
-	return [cx + ex * cos - ey * sin, cy + ex * sin + ey * cos];
-};
-/**
-* Flatten a path to polylines — de Casteljau for C/Q, arc sampling for E
-* (Circle and rounded-rect corners are 'E' segments, so this MUST handle them
-* or those shapes roughen wrong). `steps` is the samples per curved segment.
-*/
-function flatten(segs, steps = 16) {
-	const polys = [];
-	let cur = null;
-	let px = 0;
-	let py = 0;
-	let sx = 0;
-	let sy = 0;
-	const ensure = (x, y) => {
-		if (!cur) {
-			cur = {
-				points: [[x, y]],
-				closed: false
-			};
-			polys.push(cur);
-			sx = x;
-			sy = y;
-		}
-		return cur;
-	};
-	for (const s of segs) switch (s[0]) {
-		case "M":
-			cur = {
-				points: [[s[1], s[2]]],
-				closed: false
-			};
-			polys.push(cur);
-			px = sx = s[1];
-			py = sy = s[2];
-			break;
-		case "L":
-			ensure(px, py).points.push([s[1], s[2]]);
-			px = s[1];
-			py = s[2];
-			break;
-		case "C": {
-			const c = ensure(px, py);
-			for (let k = 1; k <= steps; k++) c.points.push(cubic([px, py], [s[1], s[2]], [s[3], s[4]], [s[5], s[6]], k / steps));
-			px = s[5];
-			py = s[6];
-			break;
-		}
-		case "Q": {
-			const c = ensure(px, py);
-			for (let k = 1; k <= steps; k++) c.points.push(quad([px, py], [s[1], s[2]], [s[3], s[4]], k / steps));
-			px = s[3];
-			py = s[4];
-			break;
-		}
-		case "E": {
-			const [, cx, cy, rx, ry, rot, a0, a1] = s;
-			const begin = ellipse(cx, cy, rx, ry, rot, a0);
-			const c = ensure(begin[0], begin[1]);
-			for (let k = 1; k <= steps; k++) c.points.push(ellipse(cx, cy, rx, ry, rot, a0 + (a1 - a0) * (k / steps)));
-			const end = ellipse(cx, cy, rx, ry, rot, a1);
-			px = end[0];
-			py = end[1];
-			break;
-		}
-		case "Z":
-			if (cur) {
-				cur.points.push([sx, sy]);
-				cur.closed = true;
-				px = sx;
-				py = sy;
-			}
-			break;
-	}
-	return polys.filter((p) => p.points.length > 0);
-}
-/** Total length of a flattened polyline (for draw-on dashing). */
-function arcLength(poly) {
-	let len = 0;
-	for (let i = 1; i < poly.points.length; i++) len += Math.hypot(poly.points[i][0] - poly.points[i - 1][0], poly.points[i][1] - poly.points[i - 1][1]);
-	return len;
-}
-function validateHachure(h) {
-	if (!(h.gap > 0)) throw new SketchValidationError(`hachure gap must be > 0, got ${String(h.gap)}`);
-	if (h.roughness !== void 0 && !(h.roughness >= 0)) throw new SketchValidationError(`hachure roughness must be ≥ 0, got ${String(h.roughness)}`);
-}
-/**
-* Parallel hatch lines covering a path's bounding box at `angleRad`, spaced
-* `gap`, lightly jittered. Returned as `M/L` segments to be stroked INSIDE a
-* clip of the shape (the caller emits the clip). Pure; `rng` reseeded per draw.
-*/
-function hachureLines(segs, spec, rng) {
-	const polys = flatten(segs);
-	let minX = Infinity;
-	let minY = Infinity;
-	let maxX = -Infinity;
-	let maxY = -Infinity;
-	for (const p of polys) for (const [x, y] of p.points) {
-		if (x < minX) minX = x;
-		if (y < minY) minY = y;
-		if (x > maxX) maxX = x;
-		if (y > maxY) maxY = y;
-	}
-	if (!Number.isFinite(minX)) return [];
-	const cx = (minX + maxX) / 2;
-	const cy = (minY + maxY) / 2;
-	const ca = Math.cos(spec.angleRad);
-	const sa = Math.sin(spec.angleRad);
-	const toRot = (x, y) => [(x - cx) * ca + (y - cy) * sa, -(x - cx) * sa + (y - cy) * ca];
-	const fromRot = (x, y) => [cx + x * ca - y * sa, cy + x * sa + y * ca];
-	let rMinX = Infinity;
-	let rMinY = Infinity;
-	let rMaxX = -Infinity;
-	let rMaxY = -Infinity;
-	const corners = [
-		[minX, minY],
-		[maxX, minY],
-		[maxX, maxY],
-		[minX, maxY]
-	];
-	for (const [x, y] of corners) {
-		const [rx, ry] = toRot(x, y);
-		if (rx < rMinX) rMinX = rx;
-		if (ry < rMinY) rMinY = ry;
-		if (rx > rMaxX) rMaxX = rx;
-		if (ry > rMaxY) rMaxY = ry;
-	}
-	const rough = spec.roughness ?? 1;
-	const jit = () => (rng() * 2 - 1) * rough;
-	const out = [];
-	for (let y = rMinY + spec.gap / 2; y < rMaxY; y += spec.gap) {
-		const a = fromRot(rMinX, y + jit());
-		const b = fromRot(rMaxX, y + jit());
-		out.push([
-			"M",
-			a[0],
-			a[1]
-		], [
-			"L",
-			b[0],
-			b[1]
-		]);
-	}
-	return out;
-}
-/**
-* Roughen a path into hand-drawn stroke passes. Each segment becomes a bowed,
-* jittered quadratic; `passes` overlay slightly different jitters for the
-* built-up look. `rng` must be a freshly seeded generator (the caller reseeds
-* per draw from a stable seed, so evaluate() stays pure).
-*/
-function roughen(segs, style, rng) {
-	const resolved = resolveSketch(style);
-	const polys = flatten(segs);
-	const jit = () => (rng() * 2 - 1) * resolved.roughness;
-	const strokes = [];
-	for (let pass = 0; pass < resolved.passes; pass++) {
-		const out = [];
-		for (const poly of polys) {
-			const pts = poly.points;
-			if (pts.length < 2) continue;
-			let ax = pts[0][0] + jit();
-			let ay = pts[0][1] + jit();
-			out.push([
-				"M",
-				ax,
-				ay
-			]);
-			for (let i = 1; i < pts.length; i++) {
-				const bx = pts[i][0] + jit();
-				const by = pts[i][1] + jit();
-				const dx = bx - ax;
-				const dy = by - ay;
-				const len = Math.hypot(dx, dy) || 1;
-				const bow = jit() * .5;
-				const mx = (ax + bx) / 2 + -dy / len * bow;
-				const my = (ay + by) / 2 + dx / len * bow;
-				out.push([
-					"Q",
-					mx,
-					my,
-					bx,
-					by
-				]);
-				ax = bx;
-				ay = by;
-			}
-		}
-		strokes.push(out);
-	}
-	return {
-		strokes,
-		resolved
-	};
-}
-/** FNV-1a 32-bit — a stable per-shape sketch seed from its id. */
-function hashStr(s) {
-	let h = 2166136261;
-	for (let i = 0; i < s.length; i++) {
-		h ^= s.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return h >>> 0;
-}
-/** Convenience: the rough stroke passes for a path at a given seed. */
-function sketchStrokes(segs, style, seed) {
-	return roughen(segs, style, random(seed >>> 0)).strokes;
-}
-//#endregion
 //#region src/nodes.ts
 /**
 * Built-in nodes for M1 (DESIGN.md §3.1): Group, Rect, Circle, Text.
@@ -2032,4 +2046,4 @@ function revealSchedule(text, reveal, measurer) {
 	return marks;
 }
 //#endregion
-export { segmentGraphemes as A, collapseReplacer as B, Node as C, estimatingMeasurer as D, breakLines as E, filtersToCanvasFilter as F, IDENTITY as G, formatDisplayDiff as H, glow as I, invert as J, applyToPoint as K, validateFilters as L, setDefaultMeasurer as M, FilterValidationError as N, fallbackMeasurer as O, createDisplayListBuilder as P, DL_SNAPSHOT_VERSION as R, validateSketch as S, MEASURE_QUANTUM_PX as T, parseDisplaySnapshot as U, diffDisplayLists as V, serializeDisplayList as W, multiply as X, matEquals as Y, hashStr as _, Path as a, sketchStrokes as b, Video as c, revealSchedule as d, roundedRectSegs as f, hachureLines as g, flatten as h, ImageNode as i, segmentWords as j, quantize as k, coercePathData as l, arcLength as m, Custom as n, Rect as o, SketchValidationError as p, fromTRS as q, Group as r, Text as s, Circle as t, pathFromSegs as u, resolveSketch as v, resolveAnchor as w, validateHachure as x, roughen as y, DlSnapshotError as z };
+export { sketchStrokes as A, collapseReplacer as B, SketchValidationError as C, hashStr as D, hachureLines as E, filtersToCanvasFilter as F, IDENTITY as G, formatDisplayDiff as H, glow as I, invert as J, applyToPoint as K, validateFilters as L, validateSketch as M, FilterValidationError as N, resolveSketch as O, createDisplayListBuilder as P, DL_SNAPSHOT_VERSION as R, setDefaultMeasurer as S, flatten as T, parseDisplaySnapshot as U, diffDisplayLists as V, serializeDisplayList as W, multiply as X, matEquals as Y, estimatingMeasurer as _, Path as a, segmentGraphemes as b, Video as c, revealSchedule as d, roundedRectSegs as f, breakLines as g, MEASURE_QUANTUM_PX as h, ImageNode as i, validateHachure as j, roughen as k, coercePathData as l, resolveAnchor as m, Custom as n, Rect as o, Node as p, fromTRS as q, Group as r, Text as s, Circle as t, pathFromSegs as u, fallbackMeasurer as v, arcLength as w, segmentWords as x, quantize as y, DlSnapshotError as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/scene",
-  "version": "0.18.0-pre.3",
+  "version": "0.18.0-pre.5",
   "description": "glissade scene graph: nodes, transforms, DisplayList emission. Renderer-agnostic; zero DOM/Node dependencies.",
   "license": "Apache-2.0",
   "engines": {
@@ -20,6 +20,10 @@
     "./path": {
       "types": "./dist/path.d.ts",
       "default": "./dist/path.js"
+    },
+    "./describe": {
+      "types": "./dist/describe.d.ts",
+      "default": "./dist/describe.js"
     }
   },
   "files": [
@@ -27,7 +31,7 @@
   ],
   "dependencies": {
     "yoga-layout": "^3.2.1",
-    "@glissade/core": "0.18.0-pre.3"
+    "@glissade/core": "0.18.0-pre.5"
   },
   "repository": {
     "type": "git",