@glissade/scene 0.58.1 → 0.59.0-pre.0

package/dist/describe.d.ts

@@ -46,6 +46,14 @@ interface DescribedProp {
   arity?: number;
   /** Construction-only props: `true` when the constructor REQUIRES it (e.g. Image/Video `assetId`). */
   required?: boolean;
+  /**
+   * 0.59 F "manifest conventions": the physical UNIT of the value, when one
+   * applies — e.g. `'degrees'` for rotation, `'seconds'` for a Video time offset.
+   * ADDITIVE + curated (a small per-prop table, like `positionAnchor`), present
+   * ONLY where a unit is meaningful; absent for unitless/px props. Lets a
+   * consumer stop guessing whether `rotation` is degrees or radians.
+   */
+  unit?: string;
 }
 interface DescribedNode {
   props: {
@@ -65,6 +73,17 @@ interface DescribedNode {
    * shape-vs-Text anchor mismatch by pixel-measuring.
    */
   positionAnchor: string;
+  /**
+   * 0.59 F ride-along "type-level bindable discovery aid": the prop names on this
+   * node a Track CAN drive (i.e. the animatable ones) — a flat, at-a-glance list
+   * so a consumer sees the bindable surface without filtering `props`. GENERATED
+   * from the same `listTargets()` the animatable props are, so it can't drift.
+   * This is the TYPE-level "can be animated" aid; the INSTANCE-level "is CURRENTLY
+   * bound on THIS node" truth (the anti-false-conclusion guard) is
+   * `instanceProps(node).bound` on `@glissade/scene/diagnostics`. Optional so a
+   * manifest captured before 0.59 (no `bindable`) still type-checks.
+   */
+  bindable?: string[];
   /**
    * The tree-shakeable subpath this node is imported from, when not the base
    * `@glissade/scene` index (e.g. the Layout family lives on
@@ -113,6 +132,14 @@ interface DescribedHelper {
   usage: string;
   /** Runnable example snippets — see {@link DescribedNode.examples}. */
   examples?: readonly string[];
+  /**
+   * 0.59 F/E "manifest conventions": `true` when this helper needs a real text
+   * MEASURER for correct geometry (splitText/fitText/…). Without one it degrades
+   * to a rough per-character estimate (or, with `{ requireMeasurer: true }`,
+   * throws) — so a consumer knows to pass `{ measurer }` / call setTextMeasurer()
+   * first. Absent (⇒ not measurer-dependent) for every other helper.
+   */
+  requiresMeasurer?: boolean;
 }
 /**
  * One entry in the {@link ApiManifest.surface} taxonomy (0.47 "verifiable

package/dist/describe.js

@@ -23,7 +23,7 @@ import { easings, listValueTypes } from "@glissade/core";
 * never pulled onto the base embed path — a scene that never calls `describe()`
 * pays zero bytes for it.
 */
-const RAW_VERSION = "0.58.1";
+const RAW_VERSION = "0.59.0-pre.0";
 const PACKAGE_VERSION = RAW_VERSION.includes("GLISSADE_".concat("VERSION")) ? "0.0.0-dev" : RAW_VERSION;
 /**
 * Parse the documented positional-arg count from a helper `usage` string — the
@@ -336,6 +336,33 @@ const BASE_CONSTRUCTION_PROP_META = {
 * coords. Surfaced per node so a consumer aligning a card + its label stops
 * pixel-measuring the mismatch — and knows `anchor` (above) overrides it.
 */
+/**
+* 0.59 F "manifest conventions" — the curated per-prop UNIT table (the
+* POSITION_ANCHOR precedent applied to units). Keyed by prop NAME; a prop absent
+* here carries no `unit` (unitless or px). Deliberately minimal: rotation is the
+* classic degrees-vs-radians ambiguity, Video's time offsets are seconds.
+*/
+const PROP_UNITS = {
+	rotation: "degrees",
+	at: "seconds",
+	trimStart: "seconds",
+	clipDuration: "seconds",
+	sourceFps: "fps"
+};
+/**
+* 0.59 F/E — helpers that need a real text measurer for correct geometry (they
+* snapshot part/fit geometry through it). Surfaced as `requiresMeasurer:true`.
+*/
+const MEASURER_HELPERS = new Set([
+	"measureWrappedText",
+	"splitText",
+	"fitText",
+	"fitTextSize",
+	"fitTextGroup",
+	"revealWords",
+	"revealLines",
+	"emphasizeWords"
+]);
 const POSITION_ANCHOR = {
 	Rect: "center",
 	Circle: "center",
@@ -358,7 +385,8 @@ function describeNode(node, typeName) {
 			type,
 			animatable: true,
 			target: `<id>/${path}`,
-			...arity !== void 0 ? { arity } : {}
+			...arity !== void 0 ? { arity } : {},
+			...PROP_UNITS[path] !== void 0 ? { unit: PROP_UNITS[path] } : {}
 		};
 	}
 	const ownNames = NODE_CONSTRUCTION_PROP_NAMES[typeName] ?? [];
@@ -372,14 +400,21 @@ function describeNode(node, typeName) {
 		props[prop] = {
 			type: spec.type,
 			animatable: false,
-			...spec.required ? { required: true } : {}
+			...spec.required ? { required: true } : {},
+			...PROP_UNITS[prop] !== void 0 ? { unit: PROP_UNITS[prop] } : {}
 		};
 	}
 	return {
 		props,
-		positionAnchor: POSITION_ANCHOR[typeName] ?? "center"
+		positionAnchor: POSITION_ANCHOR[typeName] ?? "center",
+		bindable: bindableProps(props)
 	};
 }
+/** The animatable (Track-drivable) prop names of a manifest — the generated
+*  0.59 `DescribedNode.bindable` discovery aid (can't drift from `props`). */
+function bindableProps(props) {
+	return Object.entries(props).filter(([, p]) => p.animatable).map(([name]) => name);
+}
 /**
 * The Layout family — `Layout` and its `Stack`/`Row`/`Column` ergonomic
 * factories — lives on the budgeted `@glissade/scene/layout` entry (it ships
@@ -436,6 +471,7 @@ function describeLayoutNode() {
 	return {
 		props,
 		positionAnchor: "top-left",
+		bindable: bindableProps(props),
 		subpath: LAYOUT_SUBPATH
 	};
 }
@@ -844,10 +880,11 @@ function describe(opts = {}) {
 			...m,
 			...ex(m.name)
 		})) : BUILDER_METHODS },
-		helpers: withEx ? HELPERS.map((h) => ({
+		helpers: HELPERS.map((h) => ({
 			...h,
-			...ex(h.name)
-		})) : HELPERS,
+			...MEASURER_HELPERS.has(h.name) ? { requiresMeasurer: true } : {},
+			...withEx ? ex(h.name) : void 0
+		})),
 		components: listComponents().map((c) => ({
 			name: c.name,
 			props: mapComponentProps(c.props)

package/dist/diagnostics.d.ts

@@ -1,7 +1,8 @@
 import { i as DrawCommand, m as Resource, n as DisplayList } from "./displayList.js";
+import { B as Node } from "./nodes.js";
 import { t as collapseReplacer } from "./collapseReplacer.js";
-import { r as Scene } from "./scene.js";
-import { CoverageReport, FontMode, FontUsage, Timeline } from "@glissade/core";
+import { i as Scene } from "./scene.js";
+import { CoverageReport, FontMode, FontUsage, Timeline, ValueTypeId } from "@glissade/core";
 
 //#region src/displayDiff.d.ts
 
@@ -142,4 +143,110 @@ interface ValidateSceneFontsOptions {
  */
 declare function validateSceneFonts(scene: Scene, doc: Timeline, loadBytes: FontByteLoader, options?: ValidateSceneFontsOptions): Promise<CoverageReport>;
 //#endregion
-export { type CacheColdResult, type CommandDelta, DL_SNAPSHOT_VERSION, type DisplayDiff, type DlSnapshot, DlSnapshotError, type FieldChange, type FontByteLoader, type ValidateSceneFontsOptions, auditCacheCold, collapseReplacer, collectLocalizedTextUsages, collectTextUsages, diffDisplayLists, formatDisplayDiff, parseDisplaySnapshot, serializeDisplayList, validateSceneFonts };
+//#region src/validate.d.ts
+/**
+ * Bumped ONLY on a breaking change to the diagnostic shape. New CODES and new
+ * OPTIONAL fields are additive and do NOT bump it — a consumer keys on `code`
+ * and tolerates unknown ones.
+ */
+declare const DIAGNOSTIC_SCHEMA_VERSION: 1;
+/** Closed severity ladder. `error` = a build error (unbound target); `warning`
+ *  = a probable-mistake (position of a flow child); `info` = a valid-but-notable
+ *  observation (off-canvas, estimating measurer). */
+type DiagnosticSeverity = 'error' | 'warning' | 'info';
+/**
+ * Stable, ADDITIVE-ONLY diagnostic codes (never renamed/removed — the wire
+ * contract). Chosen with BOTH `validateScene` and the future
+ * `gs parity --semantic` surface in mind.
+ * - `UNKNOWN_TARGET` — a track targets an id/prop that resolves to no signal.
+ * - `ID_COLLISION` — reserved: a duplicate node id (a built Scene rejects these
+ *   at assembly, so it is unreachable here today; kept for the shared contract).
+ * - `OFF_CANVAS` — a node's static position places its box fully outside the
+ *   viewport (valid, but usually a mistake).
+ * - `YOGA_CHILD_POSITION` — a track drives `position`/`position.*` of a FLOWABLE
+ *   child of a Layout, whose flex slot overrides/confounds that position.
+ * - `MEASURER_FALLBACK` — the scene carries Text but no real measurer is
+ *   injected, so layout uses the rough per-character estimate.
+ */
+type DiagnosticCode = 'UNKNOWN_TARGET' | 'ID_COLLISION' | 'OFF_CANVAS' | 'YOGA_CHILD_POSITION' | 'MEASURER_FALLBACK';
+/** One diagnostic. The `{schemaVersion, code, severity, message, node?, track?}`
+ *  core shape is PINNED; future fields are ADDITIVE only. */
+interface SceneDiagnostic {
+  schemaVersion: typeof DIAGNOSTIC_SCHEMA_VERSION;
+  code: DiagnosticCode;
+  severity: DiagnosticSeverity;
+  message: string;
+  /** The node id the diagnostic concerns, when applicable. */
+  node?: string;
+  /** The track target string the diagnostic concerns, when applicable. */
+  track?: string;
+}
+/** `validateScene` result — the CLI-lint `{ hasErrors, diagnostics }` shape,
+ *  plus a top-level `schemaVersion`. */
+interface ValidateSceneResult {
+  schemaVersion: typeof DIAGNOSTIC_SCHEMA_VERSION;
+  /** true iff any diagnostic has severity `error`. */
+  hasErrors: boolean;
+  /** Every diagnostic found — AGGREGATED, never throw-on-first, stable order. */
+  diagnostics: SceneDiagnostic[];
+}
+/** Classic edit distance (iterative two-row DP). Small strings only (ids). */
+declare function levenshtein(a: string, b: string): number;
+/**
+ * The nearest candidate to `name` within a reasonable edit budget (≤ 2, or a
+ * third of the length for longer names), or undefined if none is close enough —
+ * so a wildly-different typo doesn't get a misleading "did you mean" tail.
+ */
+declare function nearestId(name: string, candidates: Iterable<string>): string | undefined;
+/**
+ * Eagerly validate a scene (+ optional timeline) and AGGREGATE every problem —
+ * the static belt that surfaces at the AUTHORING site what the render-time
+ * `UnboundTargetError` backstop only shows one-at-a-time from deep in the render
+ * loop. Pure read (see the module header): calling it never changes a subsequent
+ * render's bytes.
+ *
+ * With a `doc`, every track target is walked through the existing
+ * `scene.resolveTarget`; an unresolved one becomes an `UNKNOWN_TARGET` error
+ * with a Levenshtein nearest-id / nearest-prop suggestion, and a
+ * `position`/`position.*` track on a flowable Layout child becomes a
+ * `YOGA_CHILD_POSITION` warning. Scene-only checks (off-canvas, measurer
+ * fallback) run regardless.
+ */
+declare function validateScene(scene: Scene, doc?: Timeline): ValidateSceneResult;
+/**
+ * Read a node's RESOLVED prop value at time `t` — the always-truthful read, the
+ * anti-false-conclusion primitive for inspection tooling (and load-bearing for
+ * 0.60 `critique()`). A BOUND prop returns its REAL bound value at `t` (not the
+ * misleading static default); an unbound prop returns its static value at any
+ * `t`; an unresolvable target returns `undefined`.
+ *
+ * Thin wrapper over the existing `scene.resolveTarget` + core's `evaluateAt`
+ * (read inside a read phase). NOTE: the scene must be BOUND (`bindScene`/
+ * `evaluate` already ran for the doc) for a track-driven value to appear —
+ * `resolveAt` reads the live signal, it does not itself bind. Render-neutral:
+ * the scene playhead is restored after the read.
+ */
+declare function resolveAt(scene: Scene, target: string, t: number): unknown;
+/** One prop's live binding state on a SPECIFIC node instance. */
+interface InstancePropState {
+  /** The track-target path (e.g. `position`, `opacity`). */
+  path: string;
+  /** The §2.2 value type(s) the prop accepts. */
+  expects: ValueTypeId | readonly ValueTypeId[] | undefined;
+  /**
+   * TRUE when THIS instance's signal currently has a bound source (a timeline
+   * track OR a computed `() => …` initializer) — so a static read of it is a
+   * LIE; use `resolveAt` to read its real value over time. This is the
+   * anti-false-conclusion guard (the cursorFill trap): type-level "bindable"
+   * says the prop CAN be animated; this says it currently IS.
+   */
+  bound: boolean;
+}
+/**
+ * Announce which props are CURRENTLY bound on THIS node instance (not just
+ * type-level bindable). Reads `signal.isBound` per registered target — a pure
+ * inspection read. Pair with `resolveAt` to read a bound prop's real value.
+ */
+declare function instanceProps(node: Node): InstancePropState[];
+//#endregion
+export { type CacheColdResult, type CommandDelta, DIAGNOSTIC_SCHEMA_VERSION, DL_SNAPSHOT_VERSION, type DiagnosticCode, type DiagnosticSeverity, type DisplayDiff, type DlSnapshot, DlSnapshotError, type FieldChange, type FontByteLoader, type InstancePropState, type SceneDiagnostic, type ValidateSceneFontsOptions, type ValidateSceneResult, auditCacheCold, collapseReplacer, collectLocalizedTextUsages, collectTextUsages, diffDisplayLists, formatDisplayDiff, instanceProps, levenshtein, nearestId, parseDisplaySnapshot, resolveAt, serializeDisplayList, validateScene, validateSceneFonts };

package/dist/diagnostics.js

@@ -1,6 +1,6 @@
-import { U as createDisplayListBuilder, q as collapseReplacer, r as Group, s as Text } from "./nodes.js";
+import { I as isEstimatingMeasurer, J as collapseReplacer, P as estimatingMeasurer, W as createDisplayListBuilder, r as Group, s as Text } from "./nodes.js";
 import { a as evaluate } from "./scene.js";
-import { buildFontRegistry, parseCmap, validateFonts } from "@glissade/core";
+import { buildFontRegistry, evaluateAt, parseCmap, untracked, validateFonts } from "@glissade/core";
 //#region src/displayDiff.ts
 /** A flat, stable JSON value for one command with its resource ids INLINED to content. */
 function commandView(cmd, resources) {
@@ -272,4 +272,216 @@ async function validateSceneFonts(scene, doc, loadBytes, options = {}) {
 	return validateFonts(usages, registry, cmaps, mode, { ...options.osFamilies !== void 0 ? { osFamilies: options.osFamilies } : {} });
 }
 //#endregion
-export { DL_SNAPSHOT_VERSION, DlSnapshotError, auditCacheCold, collapseReplacer, collectLocalizedTextUsages, collectTextUsages, diffDisplayLists, formatDisplayDiff, parseDisplaySnapshot, serializeDisplayList, validateSceneFonts };
+//#region src/validate.ts
+/**
+* 0.59 "fail-loud ground floor" — the eager, render-NEUTRAL scene validator plus
+* the truthful read primitive (`resolveAt`) and the instance-level bound
+* indicator (`instanceProps`). All DIAGNOSTIC surface: it lives on the
+* tree-shakeable `@glissade/scene/diagnostics` subpath (re-exported from
+* `diagnostics.ts`), NEVER on the base scene index — the base embed pays zero
+* bytes for it, exactly like the diff/audit/fontUsage cluster.
+*
+* THE THREE INVARIANTS THIS MODULE UPHOLDS:
+*  - `validateScene(scene, doc)` is a PURE READ: it walks track targets through
+*    the EXISTING `scene.resolveTarget` (no new resolution machinery), reads node
+*    bounds/flow-flags, and reports. It NEVER draws RNG, warms a signal memo,
+*    populates a measurer/font cache, or mutates a node — so `render(scene)` is
+*    byte-identical whether or not `validateScene` ran first. (Flowable-ness is
+*    probed with the STATELESS estimating measurer, not the scene's injected one,
+*    so no backend font cache is touched.)
+*  - It AGGREGATES every failure (never throw-on-first) and returns them.
+*  - The schema is PINNED: a closed `severity` enum + stable, additive-only
+*    string `code`s + a `schemaVersion` — the shared contract with the CLI lint
+*    JSON shape and the future `gs parity --semantic`.
+*/
+/**
+* Bumped ONLY on a breaking change to the diagnostic shape. New CODES and new
+* OPTIONAL fields are additive and do NOT bump it — a consumer keys on `code`
+* and tolerates unknown ones.
+*/
+const DIAGNOSTIC_SCHEMA_VERSION = 1;
+/** Classic edit distance (iterative two-row DP). Small strings only (ids). */
+function levenshtein(a, b) {
+	if (a === b) return 0;
+	if (a.length === 0) return b.length;
+	if (b.length === 0) return a.length;
+	let prev = new Array(b.length + 1);
+	let curr = new Array(b.length + 1);
+	for (let j = 0; j <= b.length; j++) prev[j] = j;
+	for (let i = 1; i <= a.length; i++) {
+		curr[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+		}
+		[prev, curr] = [curr, prev];
+	}
+	return prev[b.length];
+}
+/**
+* The nearest candidate to `name` within a reasonable edit budget (≤ 2, or a
+* third of the length for longer names), or undefined if none is close enough —
+* so a wildly-different typo doesn't get a misleading "did you mean" tail.
+*/
+function nearestId(name, candidates) {
+	const budget = Math.max(2, Math.floor(name.length / 3));
+	let best;
+	let bestD = Infinity;
+	for (const c of candidates) {
+		const d = levenshtein(name, c);
+		if (d < bestD && d <= budget) {
+			bestD = d;
+			best = c;
+		}
+	}
+	return best;
+}
+/** Resolve the OWNING node + remaining prop path for a `'<id>/<prop>'` target,
+*  by the same longest-registered-id-prefix walk `scene.resolveTarget` uses. */
+function owningNode(scene, target) {
+	for (let slash = target.lastIndexOf("/"); slash > 0; slash = target.lastIndexOf("/", slash - 1)) {
+		const node = scene.nodes.get(target.slice(0, slash));
+		if (node) return {
+			node,
+			prop: target.slice(slash + 1)
+		};
+	}
+}
+/** True when `node` is a FLOWABLE child of a Layout — i.e. its parent is a
+*  Layout (duck-typed via the `isLayoutNode` static marker, so this stays off
+*  the Yoga import) AND it has an intrinsic box (Layout flow-positions exactly
+*  these; non-flowable children emit absolutely, untouched). Flowable-ness is
+*  probed with the STATELESS estimating measurer — never the scene's injected
+*  one — so no backend font cache is warmed (render-neutrality). */
+function isFlowableLayoutChild(node) {
+	const parent = node.parent;
+	if (!parent) return false;
+	if (parent.constructor?.isLayoutNode !== true) return false;
+	return node.intrinsicSize(estimatingMeasurer) !== null;
+}
+/**
+* Eagerly validate a scene (+ optional timeline) and AGGREGATE every problem —
+* the static belt that surfaces at the AUTHORING site what the render-time
+* `UnboundTargetError` backstop only shows one-at-a-time from deep in the render
+* loop. Pure read (see the module header): calling it never changes a subsequent
+* render's bytes.
+*
+* With a `doc`, every track target is walked through the existing
+* `scene.resolveTarget`; an unresolved one becomes an `UNKNOWN_TARGET` error
+* with a Levenshtein nearest-id / nearest-prop suggestion, and a
+* `position`/`position.*` track on a flowable Layout child becomes a
+* `YOGA_CHILD_POSITION` warning. Scene-only checks (off-canvas, measurer
+* fallback) run regardless.
+*/
+function validateScene(scene, doc) {
+	const diagnostics = [];
+	const push = (code, severity, message, extra) => {
+		diagnostics.push({
+			schemaVersion: 1,
+			code,
+			severity,
+			message,
+			...extra?.node !== void 0 ? { node: extra.node } : {},
+			...extra?.track !== void 0 ? { track: extra.track } : {}
+		});
+	};
+	untracked(() => {
+		if (doc) for (const tr of doc.tracks) {
+			const target = tr.target;
+			const owner = owningNode(scene, target);
+			if (!scene.resolveTarget(target)) {
+				push("UNKNOWN_TARGET", "error", unknownTargetMessage(scene, target, owner), {
+					track: target,
+					...owner?.node.id !== void 0 ? { node: owner.node.id } : {}
+				});
+				continue;
+			}
+			if (owner && /^position(\.[xy])?$/.test(owner.prop) && isFlowableLayoutChild(owner.node)) push("YOGA_CHILD_POSITION", "warning", `track '${target}' drives the position of a flowable child of a Layout — the flex slot overrides it, so the keyframes are confounded. Animate the Layout (gap/padding/width) or wrap the child in a Group and drive THAT, or make the child absolute (non-flowable).`, {
+				track: target,
+				...owner.node.id !== void 0 ? { node: owner.node.id } : {}
+			});
+		}
+		const animatedPos = /* @__PURE__ */ new Set();
+		if (doc) for (const tr of doc.tracks) {
+			const m = /^(.+)\/position(?:\.[xy])?$/.exec(tr.target);
+			if (m) animatedPos.add(m[1]);
+		}
+		const { w, h } = scene.size;
+		let sawText = false;
+		const visit = (node) => {
+			if (isTextNode(node)) sawText = true;
+			const pos = node.position;
+			if (node.id !== void 0 && !animatedPos.has(node.id) && typeof pos === "function") {
+				const [px, py] = pos();
+				if (Number.isFinite(px) && Number.isFinite(py) && (px < 0 || py < 0 || px > w || py > h)) push("OFF_CANVAS", "info", `node '${node.id}' has a static position [${px}, ${py}] outside the ${w}×${h} viewport — it may not be visible (fine if intentional, e.g. an off-screen start).`, { node: node.id });
+			}
+			const children = node.children;
+			if (Array.isArray(children)) for (const c of children) visit(c);
+		};
+		visit(scene.root);
+		if (sawText && isEstimatingMeasurer(scene.textMeasurer)) push("MEASURER_FALLBACK", "info", "the scene contains Text but no real text measurer is injected — line breaking uses a rough per-character estimate. Call setTextMeasurer(backend) / setDefaultMeasurer(...) for exact layout.");
+	});
+	return {
+		schemaVersion: 1,
+		hasErrors: diagnostics.some((d) => d.severity === "error"),
+		diagnostics
+	};
+}
+/** Build the friendliest UNKNOWN_TARGET message: nearest-PROP when the node
+*  exists (a typo'd prop), else nearest node-ID (a typo'd id). */
+function unknownTargetMessage(scene, target, owner) {
+	if (owner) {
+		const props = owner.node.listTargets().map((t) => t.path);
+		const near = nearestId(owner.prop, props);
+		return `track targets '${target}' but node '${owner.node.id}' has no animatable prop '${owner.prop}'` + (near ? ` — did you mean '${owner.node.id}/${near}'?` : "");
+	}
+	const slash = target.indexOf("/");
+	const idPart = slash >= 0 ? target.slice(0, slash) : target;
+	const near = nearestId(idPart, scene.nodes.keys());
+	return `track targets '${target}' but no node '${idPart}' exists in the scene` + (near ? ` — did you mean '${near}'?` : "");
+}
+/** Duck-typed Text detection (avoids importing nodes.ts / dragging its
+*  construction surface onto the diagnostics bundle): Text overrides
+*  `describeType` to `'Text'`. */
+function isTextNode(node) {
+	return node.describeType === "Text";
+}
+/**
+* Read a node's RESOLVED prop value at time `t` — the always-truthful read, the
+* anti-false-conclusion primitive for inspection tooling (and load-bearing for
+* 0.60 `critique()`). A BOUND prop returns its REAL bound value at `t` (not the
+* misleading static default); an unbound prop returns its static value at any
+* `t`; an unresolvable target returns `undefined`.
+*
+* Thin wrapper over the existing `scene.resolveTarget` + core's `evaluateAt`
+* (read inside a read phase). NOTE: the scene must be BOUND (`bindScene`/
+* `evaluate` already ran for the doc) for a track-driven value to appear —
+* `resolveAt` reads the live signal, it does not itself bind. Render-neutral:
+* the scene playhead is restored after the read.
+*/
+function resolveAt(scene, target, t) {
+	const sig = scene.resolveTarget(target);
+	if (typeof sig !== "function") return void 0;
+	const prev = scene.playhead.peek();
+	try {
+		return evaluateAt(scene.playhead, t, () => sig());
+	} finally {
+		scene.playhead.forceSet(prev);
+	}
+}
+/**
+* Announce which props are CURRENTLY bound on THIS node instance (not just
+* type-level bindable). Reads `signal.isBound` per registered target — a pure
+* inspection read. Pair with `resolveAt` to read a bound prop's real value.
+*/
+function instanceProps(node) {
+	return node.listTargets().map(({ path, expects }) => {
+		return {
+			path,
+			expects,
+			bound: node.resolveTarget(path)?.isBound === true
+		};
+	});
+}
+//#endregion
+export { DIAGNOSTIC_SCHEMA_VERSION, DL_SNAPSHOT_VERSION, DlSnapshotError, auditCacheCold, collapseReplacer, collectLocalizedTextUsages, collectTextUsages, diffDisplayLists, formatDisplayDiff, instanceProps, levenshtein, nearestId, parseDisplaySnapshot, resolveAt, serializeDisplayList, validateScene, validateSceneFonts };

package/dist/identity.d.ts

@@ -1,5 +1,5 @@
 import { n as DisplayList } from "./displayList.js";
-import { r as Scene } from "./scene.js";
+import { i as Scene } from "./scene.js";
 import { Timeline } from "@glissade/core";
 
 //#region src/identity.d.ts

package/dist/identity.js

@@ -1,4 +1,4 @@
-import { U as createDisplayListBuilder } from "./nodes.js";
+import { W as createDisplayListBuilder } from "./nodes.js";
 import { r as bindScene } from "./scene.js";
 import { evaluateAt } from "@glissade/core";
 //#region src/identity.ts

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { C as Mat2x3, D as matEquals, E as invert, O as multiply, S as IDENTITY, T as fromTRS, _ as StrokeStyle, a as FilterSpec, b as glow, c as MeshInterpolation, d as Paint, f as PathSeg, g as ShaderRef, h as ResourceId, i as DrawCommand, l as MeshPaint, m as Resource, n as DisplayList, o as FilterValidationError, p as Rect$1, r as DisplayListBuilder, s as FontSpec, t as BlendMode, u as MeshPoint, v as createDisplayListBuilder, w as applyToPoint, x as validateFilters, y as filtersToCanvasFilter } from "./displayList.js";
-import { $ as isEstimatingMeasurer, A as hachureLines, B as Node, C as HachureSpec, D as SketchValidationError, E as SketchStyle, F as validateSketch, G as MEASURE_QUANTUM_PX, H as NodeProps, I as AnchorSpec, J as WrappedTextMetrics, K as TextMeasurer, L as BindablePropTarget, M as roughen, N as sketchStrokes, O as arcLength, P as validateHachure, Q as estimatingMeasurer, R as EvalContext, S as roundedRectSegs, T as ResolvedSketch, U as PropInit, V as NodeConstructionError, W as resolveAnchor, X as assertFiniteFontSize, Y as __resetEstimateWarnings, Z as breakLines, _ as VideoProps, a as Group, b as pathFromSegs, c as LineBox, d as Rect, et as measureWrappedText, f as RevealMark, g as Video, h as TextProps, i as GraphemeBox, it as setDefaultMeasurer, j as resolveSketch, k as flatten, l as Path, m as Text, n as ClipRegion, nt as segmentGraphemes, o as ImageNode, p as ShapeProps, q as TextMetricsLite, r as Custom, rt as segmentWords, s as ImageProps, t as Circle, tt as quantize, u as PathProps, v as WordBox, w as Polyline, x as revealSchedule, y as coercePathData, z as HitArea } from "./nodes.js";
+import { $ as estimatingMeasurer, A as hachureLines, B as Node, C as HachureSpec, D as SketchValidationError, E as SketchStyle, F as validateSketch, G as MEASURE_QUANTUM_PX, H as NodeProps, I as AnchorSpec, J as TextMetricsLite, L as BindablePropTarget, M as roughen, N as sketchStrokes, O as arcLength, P as validateHachure, Q as breakLines, R as EvalContext, S as roundedRectSegs, T as ResolvedSketch, U as PropInit, V as NodeConstructionError, W as resolveAnchor, X as __resetEstimateWarnings, Y as WrappedTextMetrics, Z as assertFiniteFontSize, _ as VideoProps, a as Group, at as setDefaultMeasurer, b as pathFromSegs, c as LineBox, d as Rect, et as isEstimatingMeasurer, f as RevealMark, g as Video, h as TextProps, i as GraphemeBox, it as segmentWords, j as resolveSketch, k as flatten, l as Path, m as Text, n as ClipRegion, nt as quantize, o as ImageNode, p as ShapeProps, q as TextMeasurer, r as Custom, rt as segmentGraphemes, s as ImageProps, t as Circle, tt as measureWrappedText, u as PathProps, v as WordBox, w as Polyline, x as revealSchedule, y as coercePathData, z as HitArea } from "./nodes.js";
 import { t as collapseReplacer } from "./collapseReplacer.js";
-import { a as SceneModule, c as evaluate, i as SceneInit, n as ReservedNodeIdError, o as bindScene, r as Scene, s as createScene, t as DuplicateNodeIdError } from "./scene.js";
+import { a as SceneInit, c as createScene, i as Scene, l as evaluate, n as DuplicateNodeIdError, o as SceneModule, r as ReservedNodeIdError, s as bindScene, t as BindSceneOptions } from "./scene.js";
 import { a as typewriter, c as textCursor, i as TypewriterResult, n as StepMark, o as TextCursor, r as TypeEdit, s as TextCursorProps, t as EditMark } from "./typewriter.js";
 import { a as EachLayout, c as EachResult, i as EachError, l as Place, n as EachContext, o as EachMotion, r as EachDistribute, s as EachOpts, t as EachBox, u as each } from "./each.js";
 import { a as LayoutEngineMissingError, c as requireLayoutEngine, i as LayoutEngine, l as setLayoutEngine, n as LayoutChildSpec, r as LayoutContainerSpec, s as getLayoutEngine, t as LayoutBox } from "./layoutEngine.js";
@@ -493,4 +493,4 @@ declare function meshRasterSize(bw: number, bh: number): {
   h: number;
 };
 //#endregion
-export { ALL_FILTER_KINDS, type AnchorSpec, type BackendCaps, type BindablePropTarget, type BlendMode, type Bounds, type CanvasLike, Circle, type ClipRegion, ColdAssetError, type Ctx2DLike, Custom, DeterminismViolationError, type DisplayList, type DisplayListBuilder, type DrawCommand, type DrawOnEachOptions, type DrawOnOptions, DuplicateNodeIdError, type EachBox, type EachContext, type EachDistribute, EachError, type EachLayout, type EachMotion, type EachOpts, type EachResult, Echo, type EchoProps, type EditMark, type EvalContext, type FilterKind, type FilterSpec, FilterValidationError, type FontSpec, type GraphemeBox, Group, type GuardMode, type HachureSpec, Highlight, type HighlightProps, type HitArea, IDENTITY, ImageNode as Image, ImageNode, type ImageDataLike, type ImageHandle, type ImageProps, type LayerCacheEntry, type LayerStore, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, MEASURE_QUANTUM_PX, MESH_DOWNSCALE, MESH_SHEPARD_POWER, MESH_SIGMA, type Mat2x3, type MeshInterpolation, type MeshPaint, type MeshPoint, MotionBlur, type MotionBlurProps, NODE_TAXONOMY, Node, NodeConstructionError, type NodeProps, type NodeTypeName, type Paint, Path, type PathLike, type PathProps, type PathSeg, type Place, type Polyline, type PropInit, Raster2D, type Raster2DHost, Rect, type Rect$1 as RectShape, type RenderBackend, ReservedNodeIdError, type ResolvedSketch, type Resource, type ResourceId, type RevealMark, type Scene, type SceneInit, type SceneModule, type ShaderCaps, ShaderEffect, type ShaderEffectProps, type ShaderRef, type ShapeProps, type SketchStyle, SketchValidationError, type StepMark, type StrokeStyle, Text, TextCursor, type TextCursorProps, type TextMeasurer, type TextMetricsLite, type TextProps, TrackMatte, type TrackMatteProps, type TypeEdit, type TypewriterResult, Video, type VideoFrameSource, type VideoProps, type WordBox, type WrappedTextMetrics, __resetEstimateWarnings, applyToPoint, arcLength, assertFiniteFontSize, bindScene, breakLines, coercePathData, collapseReplacer, createDisplayListBuilder, createScene, drawOn, drawOnEach, each, echo, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, fontString, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, isEstimatingMeasurer, matEquals, measureWrappedText, meshRasterSize, motionBlur, multiply, pathFromSegs, quantize, rasterizeMesh, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, trackMatte, typewriter, validateFilters, validateHachure, validateSketch, withDeterminismGuards };
+export { ALL_FILTER_KINDS, type AnchorSpec, type BackendCaps, type BindSceneOptions, type BindablePropTarget, type BlendMode, type Bounds, type CanvasLike, Circle, type ClipRegion, ColdAssetError, type Ctx2DLike, Custom, DeterminismViolationError, type DisplayList, type DisplayListBuilder, type DrawCommand, type DrawOnEachOptions, type DrawOnOptions, DuplicateNodeIdError, type EachBox, type EachContext, type EachDistribute, EachError, type EachLayout, type EachMotion, type EachOpts, type EachResult, Echo, type EchoProps, type EditMark, type EvalContext, type FilterKind, type FilterSpec, FilterValidationError, type FontSpec, type GraphemeBox, Group, type GuardMode, type HachureSpec, Highlight, type HighlightProps, type HitArea, IDENTITY, ImageNode as Image, ImageNode, type ImageDataLike, type ImageHandle, type ImageProps, type LayerCacheEntry, type LayerStore, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, MEASURE_QUANTUM_PX, MESH_DOWNSCALE, MESH_SHEPARD_POWER, MESH_SIGMA, type Mat2x3, type MeshInterpolation, type MeshPaint, type MeshPoint, MotionBlur, type MotionBlurProps, NODE_TAXONOMY, Node, NodeConstructionError, type NodeProps, type NodeTypeName, type Paint, Path, type PathLike, type PathProps, type PathSeg, type Place, type Polyline, type PropInit, Raster2D, type Raster2DHost, Rect, type Rect$1 as RectShape, type RenderBackend, ReservedNodeIdError, type ResolvedSketch, type Resource, type ResourceId, type RevealMark, type Scene, type SceneInit, type SceneModule, type ShaderCaps, ShaderEffect, type ShaderEffectProps, type ShaderRef, type ShapeProps, type SketchStyle, SketchValidationError, type StepMark, type StrokeStyle, Text, TextCursor, type TextCursorProps, type TextMeasurer, type TextMetricsLite, type TextProps, TrackMatte, type TrackMatteProps, type TypeEdit, type TypewriterResult, Video, type VideoFrameSource, type VideoProps, type WordBox, type WrappedTextMetrics, __resetEstimateWarnings, applyToPoint, arcLength, assertFiniteFontSize, bindScene, breakLines, coercePathData, collapseReplacer, createDisplayListBuilder, createScene, drawOn, drawOnEach, each, echo, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, fontString, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, isEstimatingMeasurer, matEquals, measureWrappedText, meshRasterSize, motionBlur, multiply, pathFromSegs, quantize, rasterizeMesh, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, trackMatte, typewriter, validateFilters, validateHachure, validateSketch, withDeterminismGuards };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as multiply, A as __resetEstimateWarnings, B as setDefaultMeasurer, C as Node, F as isEstimatingMeasurer, G as glow, H as FilterValidationError, I as measureWrappedText, J as IDENTITY, K as validateFilters, L as quantize, M as breakLines, N as estimatingMeasurer, Q as matEquals, R as segmentGraphemes, S as validateSketch, T as resolveAnchor, U as createDisplayListBuilder, W as filtersToCanvasFilter, X as fromTRS, Y as applyToPoint, Z as invert, 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 assertFiniteFontSize, k as MEASURE_QUANTUM_PX, l as coercePathData, m as arcLength, n as Custom, o as Rect, p as SketchValidationError, q as collapseReplacer, r as Group, s as Text, t as Circle, u as pathFromSegs, v as resolveSketch, w as NodeConstructionError, x as validateHachure, y as roughen, z as segmentWords } from "./nodes.js";
+import { $ as matEquals, B as segmentWords, C as Node, G as filtersToCanvasFilter, I as isEstimatingMeasurer, J as collapseReplacer, K as glow, L as measureWrappedText, M as assertFiniteFontSize, N as breakLines, P as estimatingMeasurer, Q as invert, R as quantize, S as validateSketch, T as resolveAnchor, U as FilterValidationError, V as setDefaultMeasurer, W as createDisplayListBuilder, X as applyToPoint, Y as IDENTITY, Z as fromTRS, a as Path, b as sketchStrokes, c as Video, d as revealSchedule, et as multiply, f as roundedRectSegs, g as hachureLines, h as flatten, i as ImageNode, j as __resetEstimateWarnings, k as MEASURE_QUANTUM_PX, l as coercePathData, m as arcLength, n as Custom, o as Rect, p as SketchValidationError, q as validateFilters, r as Group, s as Text, t as Circle, u as pathFromSegs, v as resolveSketch, w as NodeConstructionError, x as validateHachure, y as roughen, z as segmentGraphemes } from "./nodes.js";
 import { a as evaluate, i as createScene, n as ReservedNodeIdError, r as bindScene, t as DuplicateNodeIdError } from "./scene.js";
 import { i as setLayoutEngine, n as getLayoutEngine, r as requireLayoutEngine, t as LayoutEngineMissingError } from "./layoutEngine.js";
 import { n as TextCursor, r as textCursor, t as typewriter } from "./typewriter.js";

package/dist/layoutCtors.d.ts

@@ -1,5 +1,5 @@
 import { r as DisplayListBuilder } from "./displayList.js";
-import { B as Node, H as NodeProps, K as TextMeasurer, R as EvalContext, U as PropInit, a as Group } from "./nodes.js";
+import { B as Node, H as NodeProps, R as EvalContext, U as PropInit, a as Group, q as TextMeasurer } from "./nodes.js";
 import { r as LayoutContainerSpec } from "./layoutEngine.js";
 import { BindableSignal } from "@glissade/core";
 

package/dist/layoutCtors.js

@@ -1,4 +1,4 @@
-import { P as fallbackMeasurer, r as Group } from "./nodes.js";
+import { F as fallbackMeasurer, r as Group } from "./nodes.js";
 import { r as requireLayoutEngine } from "./layoutEngine.js";
 import { computed, signal } from "@glissade/core";
 //#region src/layoutCtors.ts

package/dist/motion.js

@@ -1,4 +1,4 @@
-import { $ as multiply, C as Node, X as fromTRS, _ as hashStr, r as Group, s as Text, t as Circle } from "./nodes.js";
+import { C as Node, Z as fromTRS, _ as hashStr, et as multiply, r as Group, s as Text, t as Circle } from "./nodes.js";
 import { a as FollowPath, c as pathLength, i as orientToPath, l as pointAtLength, n as OrientToPath, o as followPath, r as lookAt, s as motionPath, t as LookAt } from "./orient.js";
 import { n as each } from "./each.js";
 import { bake, signal, valueNoise, vec2Signal } from "@glissade/core";

package/dist/nodes.d.ts

@@ -51,11 +51,26 @@ declare const estimatingMeasurer: TextMeasurer;
  * registered measurer never trips it.
  */
 declare function isEstimatingMeasurer(m: TextMeasurer): boolean;
+/**
+ * Thrown by a measurer-requiring helper (`splitText`/`fitText`) when it resolved
+ * to the estimating fallback AND the caller opted into fail-loud
+ * (`requireMeasurer: true`, 0.59 measurer fail-loud). The default stays
+ * warn-once (below) — this is the opt-in that turns the silent geometry
+ * DEGRADATION into a hard error for pipelines that need exact layout.
+ */
+declare class MeasurerRequiredError extends Error {
+  constructor(site: string);
+}
 /**
  * One-shot dev-warning when a build-time geometry getter resolved its measurer
  * to the rough per-character estimate (no backend, no `setDefaultMeasurer`).
  * `site` keys the de-dupe so each distinct caller warns at most once. Silent
  * when a real measurer is in play — the estimate is the only footgun here.
+ *
+ * 0.59: pass `strict` to make the same fallback FAIL LOUD ({@link
+ * MeasurerRequiredError}) instead of warn-once — the `requireMeasurer` opt-in on
+ * splitText/fitText. Default (`strict` falsy) preserves the exact prior
+ * warn-once behavior (byte/behavior-neutral).
  */
 
 /**
@@ -961,4 +976,4 @@ interface RevealMark {
  */
 declare function revealSchedule(text: Text, reveal: Track<number>, measurer?: TextMeasurer): RevealMark[];
 //#endregion
-export { isEstimatingMeasurer as $, hachureLines as A, Node as B, HachureSpec as C, SketchValidationError as D, SketchStyle as E, validateSketch as F, MEASURE_QUANTUM_PX as G, NodeProps as H, AnchorSpec as I, WrappedTextMetrics as J, TextMeasurer as K, BindablePropTarget as L, roughen as M, sketchStrokes as N, arcLength as O, validateHachure as P, estimatingMeasurer as Q, EvalContext as R, roundedRectSegs as S, ResolvedSketch as T, PropInit as U, NodeConstructionError as V, resolveAnchor as W, assertFiniteFontSize as X, __resetEstimateWarnings as Y, breakLines as Z, VideoProps as _, Group as a, pathFromSegs as b, LineBox as c, Rect as d, measureWrappedText as et, RevealMark as f, Video as g, TextProps as h, GraphemeBox as i, setDefaultMeasurer as it, resolveSketch as j, flatten as k, Path as l, Text as m, ClipRegion as n, segmentGraphemes as nt, ImageNode as o, ShapeProps as p, TextMetricsLite as q, Custom as r, segmentWords as rt, ImageProps as s, Circle as t, quantize as tt, PathProps as u, WordBox as v, Polyline as w, revealSchedule as x, coercePathData as y, HitArea as z };
+export { estimatingMeasurer as $, hachureLines as A, Node as B, HachureSpec as C, SketchValidationError as D, SketchStyle as E, validateSketch as F, MEASURE_QUANTUM_PX as G, NodeProps as H, AnchorSpec as I, TextMetricsLite as J, MeasurerRequiredError as K, BindablePropTarget as L, roughen as M, sketchStrokes as N, arcLength as O, validateHachure as P, breakLines as Q, EvalContext as R, roundedRectSegs as S, ResolvedSketch as T, PropInit as U, NodeConstructionError as V, resolveAnchor as W, __resetEstimateWarnings as X, WrappedTextMetrics as Y, assertFiniteFontSize as Z, VideoProps as _, Group as a, setDefaultMeasurer as at, pathFromSegs as b, LineBox as c, Rect as d, isEstimatingMeasurer as et, RevealMark as f, Video as g, TextProps as h, GraphemeBox as i, segmentWords as it, resolveSketch as j, flatten as k, Path as l, Text as m, ClipRegion as n, quantize as nt, ImageNode as o, ShapeProps as p, TextMeasurer as q, Custom as r, segmentGraphemes as rt, ImageProps as s, Circle as t, measureWrappedText as tt, PathProps as u, WordBox as v, Polyline as w, revealSchedule as x, coercePathData as y, HitArea as z };

package/dist/nodes.js

@@ -324,13 +324,32 @@ function isEstimatingMeasurer(m) {
 }
 const warnedEstimate = /* @__PURE__ */ new Set();
 /**
+* Thrown by a measurer-requiring helper (`splitText`/`fitText`) when it resolved
+* to the estimating fallback AND the caller opted into fail-loud
+* (`requireMeasurer: true`, 0.59 measurer fail-loud). The default stays
+* warn-once (below) — this is the opt-in that turns the silent geometry
+* DEGRADATION into a hard error for pipelines that need exact layout.
+*/
+var MeasurerRequiredError = class extends Error {
+	constructor(site) {
+		super(`${site}: no real text measurer available and { requireMeasurer: true } was set — part geometry would use a rough per-character estimate. Pass { measurer } or call setTextMeasurer()/setDefaultMeasurer() first.`);
+		this.name = "MeasurerRequiredError";
+	}
+};
+/**
 * One-shot dev-warning when a build-time geometry getter resolved its measurer
 * to the rough per-character estimate (no backend, no `setDefaultMeasurer`).
 * `site` keys the de-dupe so each distinct caller warns at most once. Silent
 * when a real measurer is in play — the estimate is the only footgun here.
+*
+* 0.59: pass `strict` to make the same fallback FAIL LOUD ({@link
+* MeasurerRequiredError}) instead of warn-once — the `requireMeasurer` opt-in on
+* splitText/fitText. Default (`strict` falsy) preserves the exact prior
+* warn-once behavior (byte/behavior-neutral).
 */
-function warnIfEstimating(m, site) {
+function warnIfEstimating(m, site, strict = false) {
 	if (!isEstimatingMeasurer(m)) return;
+	if (strict) throw new MeasurerRequiredError(site);
 	if (warnedEstimate.has(site)) return;
 	warnedEstimate.add(site);
 	emitDevWarning(`${site}: no text measurer available — using a rough per-character estimate; pass { measurer } or call after setTextMeasurer()/setDefaultMeasurer() for exact layout.`);
@@ -2358,4 +2377,4 @@ function revealSchedule(text, reveal, measurer) {
 	return marks;
 }
 //#endregion
-export { multiply as $, __resetEstimateWarnings as A, setDefaultMeasurer as B, Node as C, NODE_CONSTRUCTION_PROP_NAMES as D, BASE_CONSTRUCTION_PROP_NAMES as E, isEstimatingMeasurer as F, glow as G, FilterValidationError as H, measureWrappedText as I, IDENTITY as J, validateFilters as K, quantize as L, breakLines as M, estimatingMeasurer as N, isConstructionProp as O, fallbackMeasurer as P, matEquals as Q, segmentGraphemes as R, validateSketch as S, resolveAnchor as T, createDisplayListBuilder as U, warnIfEstimating as V, filtersToCanvasFilter as W, fromTRS as X, applyToPoint as Y, invert as Z, 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, assertFiniteFontSize as j, MEASURE_QUANTUM_PX as k, coercePathData as l, arcLength as m, Custom as n, Rect as o, SketchValidationError as p, collapseReplacer as q, Group as r, Text as s, Circle as t, pathFromSegs as u, resolveSketch as v, NodeConstructionError as w, validateHachure as x, roughen as y, segmentWords as z };
+export { matEquals as $, MeasurerRequiredError as A, segmentWords as B, Node as C, NODE_CONSTRUCTION_PROP_NAMES as D, BASE_CONSTRUCTION_PROP_NAMES as E, fallbackMeasurer as F, filtersToCanvasFilter as G, warnIfEstimating as H, isEstimatingMeasurer as I, collapseReplacer as J, glow as K, measureWrappedText as L, assertFiniteFontSize as M, breakLines as N, isConstructionProp as O, estimatingMeasurer as P, invert as Q, quantize as R, validateSketch as S, resolveAnchor as T, FilterValidationError as U, setDefaultMeasurer as V, createDisplayListBuilder as W, applyToPoint as X, IDENTITY as Y, fromTRS as Z, hashStr as _, Path as a, sketchStrokes as b, Video as c, revealSchedule as d, multiply as et, roundedRectSegs as f, hachureLines as g, flatten as h, ImageNode as i, __resetEstimateWarnings as j, MEASURE_QUANTUM_PX as k, coercePathData as l, arcLength as m, Custom as n, Rect as o, SketchValidationError as p, validateFilters as q, Group as r, Text as s, Circle as t, pathFromSegs as u, resolveSketch as v, NodeConstructionError as w, validateHachure as x, roughen as y, segmentGraphemes as z };

package/dist/orient.js

@@ -1,4 +1,4 @@
-import { C as Node, Y as applyToPoint, a as Path } from "./nodes.js";
+import { C as Node, X as applyToPoint, a as Path } from "./nodes.js";
 import { signal } from "@glissade/core";
 //#region src/motionPath.ts
 /**

package/dist/scene.d.ts

@@ -1,5 +1,5 @@
 import { n as DisplayList, s as FontSpec } from "./displayList.js";
-import { B as Node, J as WrappedTextMetrics, K as TextMeasurer, L as BindablePropTarget, a as Group } from "./nodes.js";
+import { B as Node, L as BindablePropTarget, Y as WrappedTextMetrics, a as Group, q as TextMeasurer } from "./nodes.js";
 import { BoundTimeline, CompiledTimeline, Playhead, Timeline } from "@glissade/core";
 
 //#region src/scene.d.ts
@@ -55,7 +55,18 @@ interface BindingCacheEntry {
   compiled: CompiledTimeline;
   bound: BoundTimeline;
 }
-declare function bindScene(scene: Scene, doc: Timeline): BindingCacheEntry;
+/** Options for {@link bindScene}. */
+interface BindSceneOptions {
+  /**
+   * 0.59 mode gate (threaded to {@link BindOptions.onUnbound}): `'throw'`
+   * (default, loud) vs `'warn'` (prod embeds — downgrade an unresolved target to
+   * a dev-warning and skip the track). `mount({ production: true })` passes
+   * `'warn'` here on its first (memo-warming) bind, so the whole render loop runs
+   * in the chosen mode. Byte-neutral for every valid scene (see BindOptions).
+   */
+  onUnbound?: 'throw' | 'warn';
+}
+declare function bindScene(scene: Scene, doc: Timeline, opts?: BindSceneOptions): BindingCacheEntry;
 /**
  * The non-negotiable contract (§2.5): same (scene, timeline, t) → identical
  * DisplayList, in any call order. Never awaits; asset readiness is the
@@ -76,4 +87,4 @@ declare function evaluate(scene: Scene, doc: Timeline, t: number): DisplayList;
  */
 declare function evaluate(scene: Scene): DisplayList;
 //#endregion
-export { SceneModule as a, evaluate as c, SceneInit as i, ReservedNodeIdError as n, bindScene as o, Scene as r, createScene as s, DuplicateNodeIdError as t };
+export { SceneInit as a, createScene as c, Scene as i, evaluate as l, DuplicateNodeIdError as n, SceneModule as o, ReservedNodeIdError as r, bindScene as s, BindSceneOptions as t };

package/dist/scene.js

@@ -1,4 +1,4 @@
-import { I as measureWrappedText, O as isConstructionProp, P as fallbackMeasurer, U as createDisplayListBuilder, r as Group } from "./nodes.js";
+import { F as fallbackMeasurer, L as measureWrappedText, O as isConstructionProp, W as createDisplayListBuilder, r as Group } from "./nodes.js";
 import { bindTimeline, compileTimeline, createPlayhead, evaluateAt, signal } from "@glissade/core";
 //#region src/scene.ts
 /**
@@ -75,7 +75,7 @@ function constructionPropMessage(nodes, target) {
 		return;
 	}
 }
-function bindScene(scene, doc) {
+function bindScene(scene, doc, opts = {}) {
 	let perScene = bindings.get(scene);
 	if (!perScene) {
 		perScene = /* @__PURE__ */ new WeakMap();
@@ -86,7 +86,10 @@ function bindScene(scene, doc) {
 		const compiled = compileTimeline(doc);
 		entry = {
 			compiled,
-			bound: bindTimeline(compiled, scene.resolveTarget, scene.playhead, { unboundMessage: (target) => constructionPropMessage(scene.nodes, target) })
+			bound: bindTimeline(compiled, scene.resolveTarget, scene.playhead, {
+				unboundMessage: (target) => constructionPropMessage(scene.nodes, target),
+				...opts.onUnbound !== void 0 ? { onUnbound: opts.onUnbound } : {}
+			})
 		};
 		perScene.set(doc, entry);
 	}

package/dist/tokens.js

@@ -1,4 +1,4 @@
-import { C as Node, J as IDENTITY, Q as matEquals, f as roundedRectSegs } from "./nodes.js";
+import { $ as matEquals, C as Node, Y as IDENTITY, f as roundedRectSegs } from "./nodes.js";
 import { signal, vec2Signal } from "@glissade/core";
 //#region src/tokenHighlight.ts
 /**

package/dist/type.d.ts

@@ -1,4 +1,4 @@
-import { K as TextMeasurer, a as Group, c as LineBox, h as TextProps, i as GraphemeBox, m as Text, v as WordBox } from "./nodes.js";
+import { K as MeasurerRequiredError, a as Group, c as LineBox, h as TextProps, i as GraphemeBox, m as Text, q as TextMeasurer, v as WordBox } from "./nodes.js";
 import { o as TextCursor, s as TextCursorProps, t as EditMark } from "./typewriter.js";
 import { EaseSpec, Track } from "@glissade/core";
 
@@ -20,6 +20,14 @@ interface SplitTextOpts {
    * Text geometry getters use.
    */
   measurer?: TextMeasurer;
+  /**
+   * 0.59 measurer fail-loud OPT-IN. By default a split with no real measurer
+   * warns once and degrades to the rough per-character estimate. Set
+   * `requireMeasurer: true` to instead THROW `MeasurerRequiredError` — for a
+   * pipeline that must not silently ship estimated geometry. Default false
+   * (warn) — behavior-neutral.
+   */
+  requireMeasurer?: boolean;
 }
 /** One part of a split, in the source Text's draw space (group-local coords). */
 interface SplitPart {
@@ -89,6 +97,11 @@ interface FitTextOpts {
   /** measurer for exact fit — pass one (or call setTextMeasurer first), else the
    *  estimating fallback is used with a one-time dev warning (the splitText footgun). */
   measurer?: TextMeasurer;
+  /**
+   * 0.59 measurer fail-loud OPT-IN (as splitText): `true` THROWs
+   * `MeasurerRequiredError` when no real measurer is available instead of
+   * warn-once + estimate. Default false. */
+  requireMeasurer?: boolean;
 }
 /**
  * The largest integer-px fontSize ≤ the text's current size at which it fits the
@@ -238,4 +251,4 @@ interface EmphasizeOpts {
  */
 declare function emphasizeWords(source: Text | TextProps, indices: readonly number[], opts?: EmphasizeOpts): RevealResult;
 //#endregion
-export { EmphasizeOpts, FitTextOpts, type GraphemeBox, KineticTypeError, type LineBox, RevealFrom, RevealOpts, RevealResult, SplitBy, SplitPart, SplitTextError, SplitTextOpts, SplitTextResult, TypeOnOpts, TypeOnResult, type WordBox, emphasizeWords, fitText, fitTextGroup, fitTextSize, revealLines, revealWords, splitText, typeOn };
+export { EmphasizeOpts, FitTextOpts, type GraphemeBox, KineticTypeError, type LineBox, MeasurerRequiredError, RevealFrom, RevealOpts, RevealResult, SplitBy, SplitPart, SplitTextError, SplitTextOpts, SplitTextResult, TypeOnOpts, TypeOnResult, type WordBox, emphasizeWords, fitText, fitTextGroup, fitTextSize, revealLines, revealWords, splitText, typeOn };

package/dist/type.js

@@ -1,4 +1,4 @@
-import { I as measureWrappedText, L as quantize, P as fallbackMeasurer, R as segmentGraphemes, V as warnIfEstimating, r as Group, s as Text } from "./nodes.js";
+import { A as MeasurerRequiredError, F as fallbackMeasurer, H as warnIfEstimating, L as measureWrappedText, R as quantize, r as Group, s as Text, z as segmentGraphemes } from "./nodes.js";
 import { r as textCursor, t as typewriter } from "./typewriter.js";
 import { key, timeline, track } from "@glissade/core";
 //#region src/type.ts
@@ -54,7 +54,7 @@ function splitText(source, opts = {}) {
 		"grapheme"
 	].includes(by)) throw new SplitTextError(`splitText() got an unknown { by: ${JSON.stringify(by)} } — valid values are 'word', 'line', 'grapheme'.`);
 	const m = opts.measurer ?? text.measurerSource?.() ?? fallbackMeasurer();
-	warnIfEstimating(m, "splitText");
+	warnIfEstimating(m, "splitText", opts.requireMeasurer === true);
 	const font = {
 		fontFamily: text.fontFamily,
 		fontSize: text.fontSize(),
@@ -160,7 +160,7 @@ function fits(text, size, opts, m) {
 */
 function fitTextSize(text, opts) {
 	const m = opts.measurer ?? text.measurerSource?.() ?? fallbackMeasurer();
-	warnIfEstimating(m, "fitText");
+	warnIfEstimating(m, "fitText", opts.requireMeasurer === true);
 	const minPx = opts.minPx ?? 6;
 	const hi = Math.max(minPx, Math.floor(text.fontSize()));
 	if (fits(text, hi, opts, m)) return hi;
@@ -357,4 +357,4 @@ function emphasizeWords(source, indices, opts = {}) {
 	};
 }
 //#endregion
-export { KineticTypeError, SplitTextError, emphasizeWords, fitText, fitTextGroup, fitTextSize, revealLines, revealWords, splitText, typeOn };
+export { KineticTypeError, MeasurerRequiredError, SplitTextError, emphasizeWords, fitText, fitTextGroup, fitTextSize, revealLines, revealWords, splitText, typeOn };

package/dist/typewriter.js

@@ -1,4 +1,4 @@
-import { C as Node, J as IDENTITY, Q as matEquals, R as segmentGraphemes, f as roundedRectSegs } from "./nodes.js";
+import { $ as matEquals, C as Node, Y as IDENTITY, f as roundedRectSegs, z as segmentGraphemes } from "./nodes.js";
 import { key, signal, track } from "@glissade/core";
 //#region src/textCursor.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/scene",
-  "version": "0.58.1",
+  "version": "0.59.0-pre.0",
   "description": "glissade scene graph: nodes, transforms, DisplayList emission. Renderer-agnostic; zero DOM/Node dependencies.",
   "license": "Apache-2.0",
   "engines": {
@@ -81,7 +81,7 @@
   ],
   "dependencies": {
     "yoga-layout": "^3.2.1",
-    "@glissade/core": "0.58.1"
+    "@glissade/core": "0.59.0-pre.0"
   },
   "repository": {
     "type": "git",