@glissade/scene 0.5.0-pre.2 → 0.5.0-pre.4

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { $ as ResourceId, A as HitArea, B as segmentWords, C as VideoProps, D as AnchorSpec, E as roundedRectSegs, F as TextMeasurer, G as DrawCommand, H as BlendMode, I as TextMetricsLite, J as FontSpec, K as FilterSpec, L as breakLines, M as NodeProps, N as PropInit, O as BindablePropTarget, P as resolveAnchor, Q as Resource, R as estimatingMeasurer, S as Video, T as revealSchedule, U as DisplayList, V as setDefaultMeasurer, W as DisplayListBuilder, X as PathSeg, Y as Paint, Z as Rect$1, _ as Rect, a as LayoutEngineMissingError, at as validateFilters, b as Text, c as requireLayoutEngine, ct as applyToPoint, d as Group, dt as matEquals, et as ShaderRef, f as ImageNode, ft as multiply, g as PathProps, h as Path, i as LayoutEngine, it as glow, j as Node, k as EvalContext, l as setLayoutEngine, lt as fromTRS, m as LineBox, n as LayoutChildSpec, nt as createDisplayListBuilder, ot as IDENTITY, p as ImageProps, q as FilterValidationError, r as LayoutContainerSpec, rt as filtersToCanvasFilter, s as getLayoutEngine, st as Mat2x3, t as LayoutBox, tt as StrokeStyle, u as Circle, ut as invert, v as RevealMark, w as WordBox, x as TextProps, y as ShapeProps, z as quantize } from "./layoutEngine.js";
-import { BindableSignal, BoundTimeline, CompiledTimeline, Playhead, Timeline, Vec2 } from "@glissade/core";
+import { $ as Resource, A as HitArea, B as segmentGraphemes, C as VideoProps, D as AnchorSpec, E as roundedRectSegs, F as TextMeasurer, G as DisplayListBuilder, H as setDefaultMeasurer, I as TextMetricsLite, J as FilterValidationError, K as DrawCommand, L as breakLines, M as NodeProps, N as PropInit, O as BindablePropTarget, P as resolveAnchor, Q as Rect$1, R as estimatingMeasurer, S as Video, T as revealSchedule, U as BlendMode, V as segmentWords, W as DisplayList, X as Paint, Y as FontSpec, Z as PathSeg, _ as Rect, a as LayoutEngineMissingError, at as glow, b as Text, c as requireLayoutEngine, ct as Mat2x3, d as Group, dt as invert, et as ResourceId, f as ImageNode, ft as matEquals, g as PathProps, h as Path, i as LayoutEngine, it as filtersToCanvasFilter, j as Node, k as EvalContext, l as setLayoutEngine, lt as applyToPoint, m as LineBox, n as LayoutChildSpec, nt as StrokeStyle, ot as validateFilters, p as ImageProps, pt as multiply, q as FilterSpec, r as LayoutContainerSpec, rt as createDisplayListBuilder, s as getLayoutEngine, st as IDENTITY, t as LayoutBox, tt as ShaderRef, u as Circle, ut as fromTRS, v as RevealMark, w as WordBox, x as TextProps, y as ShapeProps, z as quantize } from "./layoutEngine.js";
+import { BindableSignal, BoundTimeline, CompiledTimeline, PathValue, Playhead, Timeline, Track, Vec2 } from "@glissade/core";
 
 //#region src/highlight.d.ts
 
@@ -56,6 +56,109 @@ declare class TextCursor extends Node {
 /** `children: [title, textCursor(title)]` — a caret riding the reveal head. */
 declare function textCursor(text: Text, props?: Omit<TextCursorProps, 'text'>): TextCursor;
 //#endregion
+//#region src/typewriter.d.ts
+/** One step of a typewriter performance. */
+interface TypeEdit {
+  /** graphemes to type in, one keystroke at a time */
+  type?: string;
+  /** graphemes to backspace, one keystroke at a time */
+  delete?: number;
+  /** seconds to hold the current text before the next step (a pause beat) */
+  hold?: number;
+  /** seconds per keystroke for THIS step; overrides the global perChar */
+  perChar?: number;
+}
+/** One keystroke in the compiled schedule — the keystroke-SFX contract,
+ * extended with `kind` so a backspace can take a different sample. */
+interface EditMark {
+  /** keystroke time, absolute timeline seconds */
+  time: number;
+  /** a character appeared (insert) or was removed (delete/backspace) */
+  kind: 'insert' | 'delete';
+  /** the grapheme inserted, or the one removed */
+  grapheme: string;
+  /** the full visible string AFTER this keystroke */
+  value: string;
+}
+interface TypewriterResult {
+  /** hold-key string track for the Text node's `<id>/text` target */
+  track: Track<string>;
+  /** every keystroke (insert + delete), for keystroke SFX */
+  marks: EditMark[];
+  /** time of the last keystroke or hold — the performance's end */
+  duration: number;
+}
+/**
+ * Compile an edit script into a string track + keystroke schedule.
+ *
+ *   const tw = typewriter('prompt/text', [
+ *     { type: 'make it pop' },
+ *     { hold: 0.4 },
+ *     { delete: 3 },            // backspace 'pop'
+ *     { type: 'sing' },
+ *   ]);
+ *   // tracks: [tw.track, ...]; keystroke SFX: keystrokeClips(tw.marks, ...)
+ */
+declare function typewriter(target: string, edits: readonly TypeEdit[], opts?: {
+  start?: number;
+  perChar?: number;
+}): TypewriterResult;
+//#endregion
+//#region src/motionPath.d.ts
+/** An arc-length-parameterized sampler over a path. */
+interface PathSampler {
+  /** total arc length */
+  readonly length: number;
+  /** point at arc-length s (clamped to [0, length]) */
+  at(s: number): Vec2;
+  /** unit tangent at arc-length s (forward direction of travel) */
+  tangentAt(s: number): Vec2;
+  /** point at normalized progress u in [0, 1] */
+  atProgress(u: number): Vec2;
+  /** unit tangent at normalized progress u in [0, 1] */
+  tangentAtProgress(u: number): Vec2;
+}
+/**
+ * Build a reusable arc-length sampler. Densely samples each cubic into a
+ * cumulative-length polyline (samplesPerSegment, default 32) so `at`/`tangent`
+ * are simple span lerps — smooth enough for motion, no per-call bezier solve.
+ */
+declare function motionPath(path: PathValue, opts?: {
+  samplesPerSegment?: number;
+}): PathSampler;
+/** Total arc length of a path. */
+declare function pathLength(path: PathValue): number;
+/** Point at arc-length s along a path (clamped to [0, length]). */
+declare function pointAtLength(path: PathValue, s: number): Vec2;
+interface FollowPathProps extends NodeProps {
+  /** the node to move along the path; its position (and rotation, if orient) is owned by this */
+  target: Node;
+  /** a static PathValue, or a Path node followed LIVE (re-sampled as its `data` morphs) */
+  path: PathValue | Path;
+  /** 0→1 position along the path's arc length; default 1 (the end). Track `<id>/progress`. */
+  progress?: PropInit<number>;
+  /** rotate the target to the path tangent — a cursor that points where it heads; default false */
+  orient?: boolean;
+  /** degrees added to the orient angle (e.g. if the sprite points up at rest) */
+  orientOffset?: number;
+  samplesPerSegment?: number;
+}
+/**
+ * A companion node that drives `target` along `path` as `progress` animates.
+ * Owns the target's `position` (and `rotation` when `orient`) via pull-based
+ * binding, so there's no eval-order side effect. Add it to the scene (its
+ * `progress` is the animatable target); it draws nothing itself.
+ */
+declare class FollowPath extends Node {
+  readonly target: Node;
+  readonly progress: BindableSignal<number>;
+  constructor(props: FollowPathProps);
+  protected draw(): void;
+}
+/** `children: [route, cursor, followPath(cursor, route, { orient: true })]` — cursor traces the route.
+ * Pass the Path *node* to follow it as it morphs; pass a PathValue for a fixed route. */
+declare function followPath(target: Node, path: PathValue | Path, props?: Omit<FollowPathProps, 'target' | 'path'>): FollowPath;
+//#endregion
 //#region src/tokenHighlight.d.ts
 interface TokenRange {
   /** token text (whitespace-insensitive run match) or inclusive [from, to] wordBoxes indices */
@@ -298,4 +401,4 @@ declare function bindScene(scene: Scene, doc: Timeline): BindingCacheEntry;
  */
 declare function evaluate(scene: Scene, doc: Timeline, t: number): DisplayList;
 //#endregion
-export { type AnchorSpec, type BindablePropTarget, type BlendMode, type CanvasLike, Circle, ColdAssetError, type Ctx2DLike, type DisplayList, type DisplayListBuilder, type DrawCommand, DuplicateNodeIdError, type EvalContext, type FilterSpec, FilterValidationError, type FontSpec, Group, Highlight, type HighlightProps, type HitArea, IDENTITY, type ImageHandle, ImageNode, type ImageProps, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, type Mat2x3, Node, type NodeProps, type Paint, Path, type PathLike, type PathProps, type PathSeg, type PropInit, Raster2D, type Raster2DHost, Rect, type Rect$1 as RectShape, type Resource, type ResourceId, type RevealMark, type Scene, type SceneInit, type SceneModule, type ShaderCaps, ShaderEffect, type ShaderEffectProps, type ShaderRef, type ShapeProps, type StrokeStyle, Text, TextCursor, type TextCursorProps, type TextMeasurer, type TextMetricsLite, type TextProps, TokenHighlight, type TokenHighlightProps, TokenMatchError, type TokenRange, Video, type VideoFrameSource, type VideoProps, type WordBox, applyToPoint, bindScene, breakLines, createDisplayListBuilder, createScene, estimatingMeasurer, evaluate, filtersToCanvasFilter, fontString, fromTRS, getLayoutEngine, glow, highlight, invert, matEquals, matchTokenRun, multiply, quantize, requireLayoutEngine, resolveAnchor, revealSchedule, roundedRectSegs, segmentWords, setDefaultMeasurer, setLayoutEngine, textCursor, tokenHighlight, validateFilters };
+export { type AnchorSpec, type BindablePropTarget, type BlendMode, type CanvasLike, Circle, ColdAssetError, type Ctx2DLike, type DisplayList, type DisplayListBuilder, type DrawCommand, DuplicateNodeIdError, type EditMark, type EvalContext, type FilterSpec, FilterValidationError, FollowPath, type FollowPathProps, type FontSpec, Group, Highlight, type HighlightProps, type HitArea, IDENTITY, type ImageHandle, ImageNode, type ImageProps, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, type Mat2x3, Node, type NodeProps, type Paint, Path, type PathLike, type PathProps, type PathSampler, type PathSeg, type PropInit, Raster2D, type Raster2DHost, Rect, type Rect$1 as RectShape, type Resource, type ResourceId, type RevealMark, type Scene, type SceneInit, type SceneModule, type ShaderCaps, ShaderEffect, type ShaderEffectProps, type ShaderRef, type ShapeProps, type StrokeStyle, Text, TextCursor, type TextCursorProps, type TextMeasurer, type TextMetricsLite, type TextProps, TokenHighlight, type TokenHighlightProps, TokenMatchError, type TokenRange, type TypeEdit, type TypewriterResult, Video, type VideoFrameSource, type VideoProps, type WordBox, applyToPoint, bindScene, breakLines, createDisplayListBuilder, createScene, estimatingMeasurer, evaluate, filtersToCanvasFilter, followPath, fontString, fromTRS, getLayoutEngine, glow, highlight, invert, matEquals, matchTokenRun, motionPath, multiply, pathLength, pointAtLength, quantize, requireLayoutEngine, resolveAnchor, revealSchedule, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, textCursor, tokenHighlight, typewriter, validateFilters };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { A as invert, C as createDisplayListBuilder, D as IDENTITY, E as validateFilters, M as multiply, O as applyToPoint, S as FilterValidationError, T as glow, _ as estimatingMeasurer, a as Circle, b as segmentWords, c as Path, d as Video, f as revealSchedule, g as breakLines, h as resolveAnchor, i as setLayoutEngine, j as matEquals, k as fromTRS, l as Rect, m as Node, n as getLayoutEngine, o as Group, p as roundedRectSegs, r as requireLayoutEngine, s as ImageNode, t as LayoutEngineMissingError, u as Text, v as fallbackMeasurer, w as filtersToCanvasFilter, x as setDefaultMeasurer, y as quantize } from "./layoutEngine.js";
-import { bindTimeline, compileTimeline, createPlayhead, emitDevWarning, evaluateAt, signal, vec2Signal } from "@glissade/core";
+import { A as fromTRS, C as FilterValidationError, D as validateFilters, E as glow, M as matEquals, N as multiply, O as IDENTITY, S as setDefaultMeasurer, T as filtersToCanvasFilter, _ as estimatingMeasurer, a as Circle, b as segmentGraphemes, c as Path, d as Video, f as revealSchedule, g as breakLines, h as resolveAnchor, i as setLayoutEngine, j as invert, k as applyToPoint, l as Rect, m as Node, n as getLayoutEngine, o as Group, p as roundedRectSegs, r as requireLayoutEngine, s as ImageNode, t as LayoutEngineMissingError, u as Text, v as fallbackMeasurer, w as createDisplayListBuilder, x as segmentWords, y as quantize } from "./layoutEngine.js";
+import { bindTimeline, compileTimeline, createPlayhead, emitDevWarning, evaluateAt, key, signal, track, vec2Signal } from "@glissade/core";
 //#region src/highlight.ts
 /**
 * Marker-style text highlight: per-line rounded rects behind a Text node's
@@ -153,6 +153,241 @@ function init$1(sig, v) {
 	return sig;
 }
 //#endregion
+//#region src/typewriter.ts
+/**
+* Edit-event-aware typewriter authoring. `Text.reveal` is monotonic sugar for
+* the type-only case; real terminal cold-opens type, delete, and retype. Since
+* `Text.text` is itself a signal, the honest substrate is a hold-key STRING
+* track that carries the visible text after every keystroke — including
+* backspaces. This compiles a compact edit script into that track plus a
+* per-keystroke schedule (deletes included) for keystroke SFX.
+*
+* Drive `Text.text` with the returned track and leave `reveal` at its default
+* (Infinity): the whole current string shows, so deletion just works, and
+* `textCursor` rides the end of the live text with no extra wiring.
+*/
+const DEFAULT_PER_CHAR = .06;
+/**
+* Compile an edit script into a string track + keystroke schedule.
+*
+*   const tw = typewriter('prompt/text', [
+*     { type: 'make it pop' },
+*     { hold: 0.4 },
+*     { delete: 3 },            // backspace 'pop'
+*     { type: 'sing' },
+*   ]);
+*   // tracks: [tw.track, ...]; keystroke SFX: keystrokeClips(tw.marks, ...)
+*/
+function typewriter(target, edits, opts = {}) {
+	const start = opts.start ?? 0;
+	const globalPer = opts.perChar ?? DEFAULT_PER_CHAR;
+	let t = start;
+	const shown = [];
+	const keys = [key(start, "", { interp: "hold" })];
+	const marks = [];
+	for (const edit of edits) {
+		const per = edit.perChar ?? globalPer;
+		if (edit.type !== void 0) for (const g of segmentGraphemes(edit.type)) {
+			t += per;
+			shown.push(g);
+			const value = shown.join("");
+			keys.push(key(t, value, { interp: "hold" }));
+			marks.push({
+				time: t,
+				kind: "insert",
+				grapheme: g,
+				value
+			});
+		}
+		if (edit.delete !== void 0) for (let i = 0; i < edit.delete && shown.length > 0; i++) {
+			t += per;
+			const removed = shown.pop();
+			const value = shown.join("");
+			keys.push(key(t, value, { interp: "hold" }));
+			marks.push({
+				time: t,
+				kind: "delete",
+				grapheme: removed,
+				value
+			});
+		}
+		if (edit.hold !== void 0) t += edit.hold;
+	}
+	return {
+		track: track(target, "string", keys),
+		marks,
+		duration: t
+	};
+}
+//#endregion
+//#region src/motionPath.ts
+/**
+* Motion along a path: sample a point (and tangent) at an arc-length position on
+* a PathValue, and drive a node along it over time. The Path node draws/morphs
+* geometry; this is the companion that makes another node — a cursor, a dot, an
+* arrow — *travel* that geometry.
+*
+* Sampling is arc-length parameterized (constant speed), so progress 0→1 moves
+* evenly instead of bunching at the control points. Pure and deterministic: the
+* table is built once from a static PathValue and `atProgress` is a pure
+* function of progress, so evaluate() stays pure and goldens are byte-stable.
+*/
+const clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function cubicPoint(p0, p1, p2, p3, 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 * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]];
+}
+/** PathValue contours → cubic segments, same v/in/out math as Path.pathSegs. */
+function toCubics(path) {
+	const out = [];
+	for (const ct of path) {
+		const n = ct.v.length;
+		for (let i = 0; i < n - 1; i++) out.push([
+			ct.v[i],
+			[ct.v[i][0] + ct.out[i][0], ct.v[i][1] + ct.out[i][1]],
+			[ct.v[i + 1][0] + ct.in[i + 1][0], ct.v[i + 1][1] + ct.in[i + 1][1]],
+			ct.v[i + 1]
+		]);
+		if (ct.closed && n > 1) out.push([
+			ct.v[n - 1],
+			[ct.v[n - 1][0] + ct.out[n - 1][0], ct.v[n - 1][1] + ct.out[n - 1][1]],
+			[ct.v[0][0] + ct.in[0][0], ct.v[0][1] + ct.in[0][1]],
+			ct.v[0]
+		]);
+	}
+	return out;
+}
+/**
+* Build a reusable arc-length sampler. Densely samples each cubic into a
+* cumulative-length polyline (samplesPerSegment, default 32) so `at`/`tangent`
+* are simple span lerps — smooth enough for motion, no per-call bezier solve.
+*/
+function motionPath(path, opts = {}) {
+	const steps = Math.max(1, Math.floor(opts.samplesPerSegment ?? 32));
+	const cubics = toCubics(path);
+	const pts = [];
+	const cum = [];
+	if (cubics.length > 0) {
+		let prev = cubicPoint(...cubics[0], 0);
+		pts.push(prev);
+		cum.push(0);
+		let acc = 0;
+		for (const cub of cubics) for (let k = 1; k <= steps; k++) {
+			const p = cubicPoint(...cub, k / steps);
+			acc += Math.hypot(p[0] - prev[0], p[1] - prev[1]);
+			pts.push(p);
+			cum.push(acc);
+			prev = p;
+		}
+	} else {
+		const first = path[0]?.v[0];
+		pts.push(first ? [first[0], first[1]] : [0, 0]);
+		cum.push(0);
+	}
+	const total = cum[cum.length - 1];
+	const locate = (s) => {
+		if (total <= 0 || s <= 0) return {
+			i: 0,
+			f: 0
+		};
+		if (s >= total) return {
+			i: pts.length - 2,
+			f: 1
+		};
+		let i = 0;
+		while (i < cum.length - 1 && cum[i + 1] < s) i++;
+		const span = cum[i + 1] - cum[i];
+		return {
+			i,
+			f: span > 0 ? (s - cum[i]) / span : 0
+		};
+	};
+	const at = (s) => {
+		if (pts.length === 1) return [pts[0][0], pts[0][1]];
+		const { i, f } = locate(s);
+		const a = pts[i];
+		const b = pts[i + 1];
+		return [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f];
+	};
+	const tangentAt = (s) => {
+		if (pts.length === 1) return [1, 0];
+		const { i } = locate(s);
+		const a = pts[i];
+		const b = pts[i + 1];
+		const dx = b[0] - a[0];
+		const dy = b[1] - a[1];
+		const len = Math.hypot(dx, dy);
+		return len > 0 ? [dx / len, dy / len] : [1, 0];
+	};
+	return {
+		length: total,
+		at,
+		tangentAt,
+		atProgress: (u) => at(clamp01(u) * total),
+		tangentAtProgress: (u) => tangentAt(clamp01(u) * total)
+	};
+}
+/** Total arc length of a path. */
+function pathLength(path) {
+	return motionPath(path).length;
+}
+/** Point at arc-length s along a path (clamped to [0, length]). */
+function pointAtLength(path, s) {
+	return motionPath(path).at(s);
+}
+/**
+* A companion node that drives `target` along `path` as `progress` animates.
+* Owns the target's `position` (and `rotation` when `orient`) via pull-based
+* binding, so there's no eval-order side effect. Add it to the scene (its
+* `progress` is the animatable target); it draws nothing itself.
+*/
+var FollowPath = class extends Node {
+	target;
+	progress;
+	constructor(props) {
+		super(props);
+		this.target = props.target;
+		this.progress = signal(1);
+		if (typeof props.progress === "function") this.progress.bindSource(props.progress);
+		else if (props.progress !== void 0) this.progress.set(props.progress);
+		this.registerTarget("progress", this.progress);
+		const sOpts = props.samplesPerSegment !== void 0 ? { samplesPerSegment: props.samplesPerSegment } : {};
+		const getPath = props.path instanceof Path ? () => props.path.data() : () => props.path;
+		let cachedPath = getPath();
+		let cachedSampler = motionPath(cachedPath, sOpts);
+		const sampler = () => {
+			const pv = getPath();
+			if (pv !== cachedPath) {
+				cachedPath = pv;
+				cachedSampler = motionPath(pv, sOpts);
+			}
+			return cachedSampler;
+		};
+		props.target.position.bindSource(() => sampler().atProgress(this.progress()));
+		if (props.orient) {
+			const offset = props.orientOffset ?? 0;
+			props.target.rotation.bindSource(() => {
+				const t = sampler().tangentAtProgress(this.progress());
+				return Math.atan2(t[1], t[0]) * 180 / Math.PI + offset;
+			});
+		}
+	}
+	draw() {}
+};
+/** `children: [route, cursor, followPath(cursor, route, { orient: true })]` — cursor traces the route.
+* Pass the Path *node* to follow it as it morphs; pass a PathValue for a fixed route. */
+function followPath(target, path, props = {}) {
+	return new FollowPath({
+		...props,
+		target,
+		path
+	});
+}
+//#endregion
 //#region src/tokenHighlight.ts
 /**
 * Multi-range token highlight: sub-line ranges over a Text node's wordBoxes,
@@ -826,4 +1061,4 @@ function evaluate(scene, doc, t) {
 	});
 }
 //#endregion
-export { Circle, ColdAssetError, DuplicateNodeIdError, FilterValidationError, Group, Highlight, IDENTITY, ImageNode, LayoutEngineMissingError, Node, Path, Raster2D, Rect, ShaderEffect, Text, TextCursor, TokenHighlight, TokenMatchError, Video, applyToPoint, bindScene, breakLines, createDisplayListBuilder, createScene, estimatingMeasurer, evaluate, filtersToCanvasFilter, fontString, fromTRS, getLayoutEngine, glow, highlight, invert, matEquals, matchTokenRun, multiply, quantize, requireLayoutEngine, resolveAnchor, revealSchedule, roundedRectSegs, segmentWords, setDefaultMeasurer, setLayoutEngine, textCursor, tokenHighlight, validateFilters };
+export { Circle, ColdAssetError, DuplicateNodeIdError, FilterValidationError, FollowPath, Group, Highlight, IDENTITY, ImageNode, LayoutEngineMissingError, Node, Path, Raster2D, Rect, ShaderEffect, Text, TextCursor, TokenHighlight, TokenMatchError, Video, applyToPoint, bindScene, breakLines, createDisplayListBuilder, createScene, estimatingMeasurer, evaluate, filtersToCanvasFilter, followPath, fontString, fromTRS, getLayoutEngine, glow, highlight, invert, matEquals, matchTokenRun, motionPath, multiply, pathLength, pointAtLength, quantize, requireLayoutEngine, resolveAnchor, revealSchedule, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, textCursor, tokenHighlight, typewriter, validateFilters };

package/dist/layout.d.ts

@@ -1,4 +1,4 @@
-import { F as TextMeasurer, M as NodeProps, N as PropInit, W as DisplayListBuilder, a as LayoutEngineMissingError, d as Group, i as LayoutEngine, j as Node, k as EvalContext, l as setLayoutEngine, n as LayoutChildSpec, o as LayoutResult, r as LayoutContainerSpec, s as getLayoutEngine, t as LayoutBox } from "./layoutEngine.js";
+import { F as TextMeasurer, G as DisplayListBuilder, M as NodeProps, N as PropInit, a as LayoutEngineMissingError, d as Group, i as LayoutEngine, j as Node, k as EvalContext, l as setLayoutEngine, n as LayoutChildSpec, o as LayoutResult, r as LayoutContainerSpec, s as getLayoutEngine, t as LayoutBox } from "./layoutEngine.js";
 import { BindableSignal } from "@glissade/core";
 
 //#region src/layout.d.ts

package/dist/layoutEngine.d.ts

@@ -211,7 +211,7 @@ declare function segmentWords(text: string): string[];
  * (reveal masking), Text.graphemes() (authoring), and revealSchedule() (the SFX
  * keystroke contract) all count the SAME units.
  */
-
+declare function segmentGraphemes(text: string): string[];
 /**
  * Greedy line breaking: explicit '\n' always breaks; otherwise word segments
  * flow until maxWidth is exceeded (Intl.Segmenter boundaries, so CJK wraps
@@ -673,4 +673,4 @@ declare function setLayoutEngine(e: LayoutEngine): void;
 declare function getLayoutEngine(): LayoutEngine | null;
 declare function requireLayoutEngine(): LayoutEngine;
 //#endregion
-export { ResourceId as $, HitArea as A, segmentWords as B, VideoProps as C, AnchorSpec as D, roundedRectSegs as E, TextMeasurer as F, DrawCommand as G, BlendMode as H, TextMetricsLite as I, FontSpec as J, FilterSpec as K, breakLines as L, NodeProps as M, PropInit as N, BindablePropTarget as O, resolveAnchor as P, Resource as Q, estimatingMeasurer as R, Video as S, revealSchedule as T, DisplayList as U, setDefaultMeasurer as V, DisplayListBuilder as W, PathSeg as X, Paint as Y, Rect$1 as Z, Rect as _, LayoutEngineMissingError as a, validateFilters as at, Text as b, requireLayoutEngine as c, applyToPoint as ct, Group as d, matEquals as dt, ShaderRef as et, ImageNode as f, multiply as ft, PathProps as g, Path as h, LayoutEngine as i, glow as it, Node as j, EvalContext as k, setLayoutEngine as l, fromTRS as lt, LineBox as m, LayoutChildSpec as n, createDisplayListBuilder as nt, LayoutResult as o, IDENTITY as ot, ImageProps as p, FilterValidationError as q, LayoutContainerSpec as r, filtersToCanvasFilter as rt, getLayoutEngine as s, Mat2x3 as st, LayoutBox as t, StrokeStyle as tt, Circle as u, invert as ut, RevealMark as v, WordBox as w, TextProps as x, ShapeProps as y, quantize as z };
+export { Resource as $, HitArea as A, segmentGraphemes as B, VideoProps as C, AnchorSpec as D, roundedRectSegs as E, TextMeasurer as F, DisplayListBuilder as G, setDefaultMeasurer as H, TextMetricsLite as I, FilterValidationError as J, DrawCommand as K, breakLines as L, NodeProps as M, PropInit as N, BindablePropTarget as O, resolveAnchor as P, Rect$1 as Q, estimatingMeasurer as R, Video as S, revealSchedule as T, BlendMode as U, segmentWords as V, DisplayList as W, Paint as X, FontSpec as Y, PathSeg as Z, Rect as _, LayoutEngineMissingError as a, glow as at, Text as b, requireLayoutEngine as c, Mat2x3 as ct, Group as d, invert as dt, ResourceId as et, ImageNode as f, matEquals as ft, PathProps as g, Path as h, LayoutEngine as i, filtersToCanvasFilter as it, Node as j, EvalContext as k, setLayoutEngine as l, applyToPoint as lt, LineBox as m, LayoutChildSpec as n, StrokeStyle as nt, LayoutResult as o, validateFilters as ot, ImageProps as p, multiply as pt, FilterSpec as q, LayoutContainerSpec as r, createDisplayListBuilder as rt, getLayoutEngine as s, IDENTITY as st, LayoutBox as t, ShaderRef as tt, Circle as u, fromTRS as ut, RevealMark as v, WordBox as w, TextProps as x, ShapeProps as y, quantize as z };

package/dist/layoutEngine.js

@@ -1224,4 +1224,4 @@ function requireLayoutEngine() {
 	return engine;
 }
 //#endregion
-export { invert as A, createDisplayListBuilder as C, IDENTITY as D, validateFilters as E, multiply as M, applyToPoint as O, FilterValidationError as S, glow as T, estimatingMeasurer as _, Circle as a, segmentWords as b, Path as c, Video as d, revealSchedule as f, breakLines as g, resolveAnchor as h, setLayoutEngine as i, matEquals as j, fromTRS as k, Rect as l, Node as m, getLayoutEngine as n, Group as o, roundedRectSegs as p, requireLayoutEngine as r, ImageNode as s, LayoutEngineMissingError as t, Text as u, fallbackMeasurer as v, filtersToCanvasFilter as w, setDefaultMeasurer as x, quantize as y };
+export { fromTRS as A, FilterValidationError as C, validateFilters as D, glow as E, matEquals as M, multiply as N, IDENTITY as O, setDefaultMeasurer as S, filtersToCanvasFilter as T, estimatingMeasurer as _, Circle as a, segmentGraphemes as b, Path as c, Video as d, revealSchedule as f, breakLines as g, resolveAnchor as h, setLayoutEngine as i, invert as j, applyToPoint as k, Rect as l, Node as m, getLayoutEngine as n, Group as o, roundedRectSegs as p, requireLayoutEngine as r, ImageNode as s, LayoutEngineMissingError as t, Text as u, fallbackMeasurer as v, createDisplayListBuilder as w, segmentWords as x, quantize as y };

package/package.json

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