@glissade/core 0.39.0 → 0.40.0-pre.1

package/dist/clips.d.ts

@@ -1,4 +1,4 @@
-import { A as Vec2, O as ValueTypeId, et as EaseSpec, i as Track, t as Key } from "./track.js";
+import { A as Vec2, O as ValueTypeId, et as EaseSpec, i as Track, l as retime, r as RetimeSpec, t as Key } from "./track.js";
 import { r as TweenTarget } from "./targetRef.js";
 
 //#region src/clip.d.ts
@@ -256,4 +256,4 @@ interface PresenceResult {
  */
 declare function presence(nodeId: TweenTarget, opts: PresenceOpts): PresenceResult;
 //#endregion
-export { type ApplyOpts, type ApplyOpts as ClipApplyOpts, type Box, type ChannelOverride, type Clip, type ClipChannel, ClipError, type ClipListDelay, type ClipListOpts, type ClipResult, type ClipSpec, type ClipTarget, type DurationOpts, MorphError, type MorphOpts, type MorphResult, type MorphTargets, PresenceError, type PresenceOpts, type PresenceResult, type PresenceTransition, type SlideEdge, clip, clipList, driftLoop, morph, popIn, presence, pulse, slideIn, transitionToClip };
+export { type ApplyOpts, type ApplyOpts as ClipApplyOpts, type Box, type ChannelOverride, type Clip, type ClipChannel, ClipError, type ClipListDelay, type ClipListOpts, type ClipResult, type ClipSpec, type ClipTarget, type DurationOpts, MorphError, type MorphOpts, type MorphResult, type MorphTargets, PresenceError, type PresenceOpts, type PresenceResult, type PresenceTransition, type RetimeSpec, type SlideEdge, clip, clipList, driftLoop, morph, popIn, presence, pulse, retime, slideIn, transitionToClip };

package/dist/clips.js

@@ -1,4 +1,5 @@
-import { C as inferValueType, i as resolveTweenTarget, m as track, s as key, t as TARGET_PATH } from "./targetRef.js";
+import { b as inferValueType, d as track, n as key, o as retime } from "./track.js";
+import { i as resolveTweenTarget, t as TARGET_PATH } from "./targetRef.js";
 //#region src/clip.ts
 /**
 * Motion clips (DESIGN.md §2 build-time sugar): `clip()` captures a relative-time
@@ -590,4 +591,4 @@ function presence(nodeId, opts) {
 	};
 }
 //#endregion
-export { ClipError, MorphError, PresenceError, clip, clipList, driftLoop, morph, popIn, presence, pulse, slideIn, transitionToClip };
+export { ClipError, MorphError, PresenceError, clip, clipList, driftLoop, morph, popIn, presence, pulse, retime, slideIn, transitionToClip };

package/dist/expr.d.ts

@@ -0,0 +1,32 @@
+import { i as Track } from "./track.js";
+
+//#region src/expr.d.ts
+
+declare class ExprError extends Error {
+  constructor(message: string);
+}
+/** A compiled expression: evaluate at a scope (must include `t`). */
+interface CompiledExpr {
+  /** the original source (serializable — a Track stores this). */
+  readonly source: string;
+  /** evaluate the formula; `scope.t` is the playhead time. Pure in its scope. */
+  eval(scope: Record<string, number>): number;
+}
+/**
+ * Compile an expression source to a {@link CompiledExpr}. Parses ONCE (fails loud
+ * on syntax / unknown function / arity / trailing tokens); `eval(scope)` is a fast
+ * pure closure. `scope.t` is the playhead time; add more vars (e.g. `i`, `n`) as
+ * the binding provides them.
+ */
+declare function compileExpr(source: string): CompiledExpr;
+/** The names available to an expression (for docs / a describe() surface). */
+declare const EXPR_FUNCTIONS: string[];
+declare const EXPR_CONSTANTS: string[];
+/**
+ * A raw formula-driven numeric track — `exprTrack('circle/opacity', '0.5 +
+ * 0.5*sin(t*3)')`. Sampled by evaluating the formula at the playhead `t` (no
+ * keys); compile-validated now (fail loud on bad syntax / unknown fn / arity).
+ */
+declare function exprTrack(target: string, formula: string): Track<number>;
+//#endregion
+export { CompiledExpr, EXPR_CONSTANTS, EXPR_FUNCTIONS, ExprError, compileExpr, exprTrack };

package/dist/expr.js

@@ -0,0 +1,344 @@
+import { c as setExprCompiler, r as makeExprTrack } from "./track.js";
+import { t as random } from "./rng.js";
+//#region src/expr.ts
+/**
+* `Expr` (0.40) — a deterministic math-expression evaluator for animating a prop
+* by a FORMULA of time: `expr('100 + 50*sin(t*2)')`. Compiles a source string ONCE
+* to a fast closure `(scope) => number`; the Track sampler evaluates it at the
+* playhead `t` through the SAME channel keyframe interpolation uses (so it's a pure
+* function of time, byte-identical run-to-run, and needs no ambient-time design —
+* glissade already threads `t` to the sampler).
+*
+* Grammar (arithmetic; no side effects): numbers, the variable `t` (+ any scope
+* var), `+ - * / % ^` (^ = pow, right-assoc), unary ±, parens, and a WHITELIST of
+* pure functions/constants. Determinism is enforced by construction: the only
+* randomness is `rand(x)` (a seeded hash → [0,1)); there is no `Date`/`Math.random`
+* reachable, and an unknown identifier/function fails loud at COMPILE time.
+*/
+var ExprError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExprError";
+	}
+};
+const fract = (x) => x - Math.floor(x);
+const clamp = (x, lo, hi) => x < lo ? lo : x > hi ? hi : x;
+const lerp = (a, b, t) => a + (b - a) * t;
+const smoothstep = (e0, e1, x) => {
+	const t = clamp(e1 === e0 ? 0 : (x - e0) / (e1 - e0), 0, 1);
+	return t * t * (3 - 2 * t);
+};
+/** deterministic hash of `x` → [0, 1) — the ONLY randomness (seeded, pure). */
+const rand = (x) => {
+	const buf = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	buf.setFloat64(0, x);
+	return random((buf.getUint32(0) ^ buf.getUint32(4)) >>> 0)();
+};
+const CONSTS = {
+	PI: Math.PI,
+	TAU: Math.PI * 2,
+	E: Math.E
+};
+const FNS = {
+	sin: {
+		fn: Math.sin,
+		arity: 1
+	},
+	cos: {
+		fn: Math.cos,
+		arity: 1
+	},
+	tan: {
+		fn: Math.tan,
+		arity: 1
+	},
+	asin: {
+		fn: Math.asin,
+		arity: 1
+	},
+	acos: {
+		fn: Math.acos,
+		arity: 1
+	},
+	atan: {
+		fn: Math.atan,
+		arity: 1
+	},
+	abs: {
+		fn: Math.abs,
+		arity: 1
+	},
+	sqrt: {
+		fn: Math.sqrt,
+		arity: 1
+	},
+	exp: {
+		fn: Math.exp,
+		arity: 1
+	},
+	log: {
+		fn: Math.log,
+		arity: 1
+	},
+	floor: {
+		fn: Math.floor,
+		arity: 1
+	},
+	ceil: {
+		fn: Math.ceil,
+		arity: 1
+	},
+	round: {
+		fn: Math.round,
+		arity: 1
+	},
+	sign: {
+		fn: Math.sign,
+		arity: 1
+	},
+	fract: {
+		fn: fract,
+		arity: 1
+	},
+	rand: {
+		fn: rand,
+		arity: 1
+	},
+	atan2: {
+		fn: Math.atan2,
+		arity: 2
+	},
+	pow: {
+		fn: Math.pow,
+		arity: 2
+	},
+	mod: {
+		fn: (a, b) => (a % b + b) % b,
+		arity: 2
+	},
+	step: {
+		fn: (edge, x) => x < edge ? 0 : 1,
+		arity: 2
+	},
+	min: {
+		fn: Math.min,
+		arity: "variadic"
+	},
+	max: {
+		fn: Math.max,
+		arity: "variadic"
+	},
+	clamp: {
+		fn: clamp,
+		arity: 3
+	},
+	lerp: {
+		fn: lerp,
+		arity: 3
+	},
+	mix: {
+		fn: lerp,
+		arity: 3
+	},
+	smoothstep: {
+		fn: smoothstep,
+		arity: 3
+	}
+};
+function tokenize(src) {
+	const toks = [];
+	let i = 0;
+	const n = src.length;
+	while (i < n) {
+		const c = src[i];
+		if (c === " " || c === "	" || c === "\n" || c === "\r") {
+			i++;
+			continue;
+		}
+		if (c === "(") {
+			toks.push({ k: "(" });
+			i++;
+			continue;
+		}
+		if (c === ")") {
+			toks.push({ k: ")" });
+			i++;
+			continue;
+		}
+		if (c === ",") {
+			toks.push({ k: "," });
+			i++;
+			continue;
+		}
+		if ("+-*/%^".includes(c)) {
+			toks.push({
+				k: "op",
+				v: c
+			});
+			i++;
+			continue;
+		}
+		if (c >= "0" && c <= "9" || c === ".") {
+			let j = i + 1;
+			while (j < n && /[0-9.eE+\-]/.test(src[j])) {
+				if ((src[j] === "+" || src[j] === "-") && !/[eE]/.test(src[j - 1])) break;
+				j++;
+			}
+			const num = Number(src.slice(i, j));
+			if (!Number.isFinite(num)) throw new ExprError(`invalid number '${src.slice(i, j)}' in expr`);
+			toks.push({
+				k: "num",
+				v: num
+			});
+			i = j;
+			continue;
+		}
+		if (/[a-zA-Z_]/.test(c)) {
+			let j = i + 1;
+			while (j < n && /[a-zA-Z0-9_]/.test(src[j])) j++;
+			toks.push({
+				k: "id",
+				v: src.slice(i, j)
+			});
+			i = j;
+			continue;
+		}
+		throw new ExprError(`unexpected character '${c}' in expr '${src}'`);
+	}
+	return toks;
+}
+const BINOP = {
+	"+": {
+		prec: 1,
+		apply: (a, b) => a + b
+	},
+	"-": {
+		prec: 1,
+		apply: (a, b) => a - b
+	},
+	"*": {
+		prec: 2,
+		apply: (a, b) => a * b
+	},
+	"/": {
+		prec: 2,
+		apply: (a, b) => a / b
+	},
+	"%": {
+		prec: 2,
+		apply: (a, b) => (a % b + b) % b
+	},
+	"^": {
+		prec: 4,
+		rightAssoc: true,
+		apply: (a, b) => Math.pow(a, b)
+	}
+};
+function parse(src) {
+	const toks = tokenize(src);
+	if (toks.length === 0) throw new ExprError(`empty expr`);
+	let p = 0;
+	const peek = () => toks[p];
+	const next = () => toks[p++];
+	function parsePrimary() {
+		const t = peek();
+		if (!t) throw new ExprError(`unexpected end of expr '${src}'`);
+		if (t.k === "op" && (t.v === "-" || t.v === "+")) {
+			next();
+			const operand = parseUnary();
+			return t.v === "-" ? (s) => -operand(s) : operand;
+		}
+		if (t.k === "num") {
+			next();
+			return () => t.v;
+		}
+		if (t.k === "(") {
+			next();
+			const e = parseExpr(0);
+			if (peek()?.k !== ")") throw new ExprError(`missing ')' in expr '${src}'`);
+			next();
+			return e;
+		}
+		if (t.k === "id") {
+			next();
+			const name = t.v;
+			if (peek()?.k === "(") {
+				next();
+				const args = [];
+				if (peek()?.k !== ")") {
+					args.push(parseExpr(0));
+					while (peek()?.k === ",") {
+						next();
+						args.push(parseExpr(0));
+					}
+				}
+				if (peek()?.k !== ")") throw new ExprError(`missing ')' after ${name}(… in expr '${src}'`);
+				next();
+				const spec = FNS[name];
+				if (!spec) throw new ExprError(`unknown function '${name}' in expr '${src}' (have: ${Object.keys(FNS).join(", ")})`);
+				if (spec.arity !== "variadic" && spec.arity !== args.length) throw new ExprError(`${name}() takes ${spec.arity} arg(s), got ${args.length}`);
+				return (s) => spec.fn(...args.map((a) => a(s)));
+			}
+			if (name in CONSTS) {
+				const v = CONSTS[name];
+				return () => v;
+			}
+			return (s) => {
+				const v = s[name];
+				if (v === void 0) throw new ExprError(`unknown variable '${name}' in expr '${src}' (scope has: ${Object.keys(s).join(", ") || "nothing"})`);
+				return v;
+			};
+		}
+		throw new ExprError(`unexpected token in expr '${src}'`);
+	}
+	function parseUnary() {
+		return parsePrimary();
+	}
+	function parseExpr(minPrec) {
+		let left = parseUnary();
+		for (;;) {
+			const t = peek();
+			if (!t || t.k !== "op") break;
+			const op = BINOP[t.v];
+			if (!op || op.prec < minPrec) break;
+			next();
+			const right = parseExpr(op.rightAssoc ? op.prec : op.prec + 1);
+			const l = left;
+			left = (s) => op.apply(l(s), right(s));
+		}
+		return left;
+	}
+	const root = parseExpr(0);
+	if (p !== toks.length) throw new ExprError(`unexpected trailing tokens in expr '${src}'`);
+	return root;
+}
+/**
+* Compile an expression source to a {@link CompiledExpr}. Parses ONCE (fails loud
+* on syntax / unknown function / arity / trailing tokens); `eval(scope)` is a fast
+* pure closure. `scope.t` is the playhead time; add more vars (e.g. `i`, `n`) as
+* the binding provides them.
+*/
+function compileExpr(source) {
+	const node = parse(source);
+	return {
+		source,
+		eval: (scope) => node(scope)
+	};
+}
+/** The names available to an expression (for docs / a describe() surface). */
+const EXPR_FUNCTIONS = Object.keys(FNS);
+const EXPR_CONSTANTS = Object.keys(CONSTS);
+/**
+* A raw formula-driven numeric track — `exprTrack('circle/opacity', '0.5 +
+* 0.5*sin(t*3)')`. Sampled by evaluating the formula at the playhead `t` (no
+* keys); compile-validated now (fail loud on bad syntax / unknown fn / arity).
+*/
+function exprTrack(target, formula) {
+	return makeExprTrack(target, formula);
+}
+setExprCompiler((src) => {
+	const c = compileExpr(src);
+	return (t) => c.eval({ t });
+});
+//#endregion
+export { EXPR_CONSTANTS, EXPR_FUNCTIONS, ExprError, compileExpr, exprTrack };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as DEFAULT_EASE, A as Vec2, B as registerValueType, C as Paint, D as ValueType, E as UnknownValueTypeError, F as inferValueType, G as vec2Type, H as stringType, I as listValueTypes, J as SpringEase, K as RetargetSpring, L as numberType, M as colorType, N as fontAxesType, O as ValueTypeId, P as getValueType, Q as springPresets, R as paintType, S as MeshPoint, T as PathValue, U as vec2ArcType, V as reprOf, W as vec2Equals, X as springEasing, Y as spring, Z as springEasingDerivative, _ as FontAxes, a as TrackValidationError, at as easingDerivatives, b as MeshInterpolation, c as resolveEaseDerivative, d as springTo, et as EaseSpec, f as stagger, g as ColorStop, h as velocityAt, i as Track, it as cubicBezierDerivative, j as booleanType, k as ValueTypeInferenceError, l as retime, m as validateTrack, n as KeyOpts, nt as UnknownEasingError, o as key, ot as easings, p as track, q as SpringConfig, r as RetimeSpec, rt as cubicBezier, s as resolveEase, st as namedEasing, t as Key, tt as EasingFn, u as sampleTrack, v as GradientInterpolation, w as PathContour, x as MeshPaint, y as HandoffKind, z as pathType } from "./track.js";
+import { $ as DEFAULT_EASE, A as Vec2, B as registerValueType, C as Paint, D as ValueType, E as UnknownValueTypeError, F as inferValueType, G as vec2Type, H as stringType, I as listValueTypes, J as SpringEase, K as RetargetSpring, L as numberType, M as colorType, N as fontAxesType, O as ValueTypeId, P as getValueType, Q as springPresets, R as paintType, S as MeshPoint, T as PathValue, U as vec2ArcType, V as reprOf, W as vec2Equals, X as springEasing, Y as spring, Z as springEasingDerivative, _ as FontAxes, a as TrackValidationError, at as easingDerivatives, b as MeshInterpolation, c as resolveEaseDerivative, d as springTo, et as EaseSpec, f as stagger, g as ColorStop, h as velocityAt, i as Track, it as cubicBezierDerivative, j as booleanType, k as ValueTypeInferenceError, m as validateTrack, n as KeyOpts, nt as UnknownEasingError, o as key, ot as easings, p as track, q as SpringConfig, rt as cubicBezier, s as resolveEase, st as namedEasing, t as Key, tt as EasingFn, u as sampleTrack, v as GradientInterpolation, w as PathContour, x as MeshPaint, y as HandoffKind, z as pathType } from "./track.js";
 import { a as isEditableNodeId, i as UnresolvableTargetError, n as TargetCarrier, o as resolveTweenTarget, r as TweenTarget, s as targetNodeId, t as TARGET_PATH } from "./targetRef.js";
 import { _ as setDevWarning, a as FontFaceRef, c as Marker, d as TimelineValidationError, f as audioOffsetSamples, g as emitDevWarning, h as DevWarning, i as CompiledTimeline, l as Timeline, m as isDurationEditable, n as AudioClip, o as GainEnvelope, p as compileTimeline, r as ChildEntry, s as Json, t as AssetRef, u as TimelineInit } from "./timeline.js";
 
@@ -505,4 +505,4 @@ interface CheckpointedSim {
 }
 declare function bakeCheckpointed<W, S = W>(cfg: CheckpointedBakeConfig<W, S>): CheckpointedSim;
 //#endregion
-export { type AssetRef, type AudioClip, type BakeConfig, BakeError, type BindOptions, type BindTarget, BindTypeMismatchError, type BindableSignal, type BoundTimeline, type CheckpointedBakeConfig, type CheckpointedSim, type ChildEntry, CircularDependencyError, ColorParseError, type ColorStop, type CompiledTimeline, type CoverageReport, type CurveSampler, DEFAULT_EASE, type DevWarning, type EaseSpec, type EasingFn, type Equals, type FontAxes, type FontFaceRef, type FontMode, type FontRegistry, type FontUsage, FontValidationError, type GainEnvelope, type GradientInterpolation, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MeshInterpolation, type MeshPaint, type MeshPoint, type MissingGlyphs, type OkLab, type Paint, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, type RetargetSpring, type RetimeSpec, type Rgba, type Rng, type Scheduler, type Signal, type SignalOptions, type SpringConfig, type SpringEase, type StaggerOpts, type StaggerSpec, TARGET_PATH, type TargetCarrier, type Timeline, type TimelineBuilder, type TimelineInit, TimelineValidationError, type Track, TrackValidationError, type TweenOpts, type TweenTarget, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, type ValidateFontsOptions, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Component, type Vec2Signal, WriteDuringEvaluationError, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, endReadPhase, evaluateAt, fontAxesType, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, listValueTypes, namedEasing, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, retime, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };
+export { type AssetRef, type AudioClip, type BakeConfig, BakeError, type BindOptions, type BindTarget, BindTypeMismatchError, type BindableSignal, type BoundTimeline, type CheckpointedBakeConfig, type CheckpointedSim, type ChildEntry, CircularDependencyError, ColorParseError, type ColorStop, type CompiledTimeline, type CoverageReport, type CurveSampler, DEFAULT_EASE, type DevWarning, type EaseSpec, type EasingFn, type Equals, type FontAxes, type FontFaceRef, type FontMode, type FontRegistry, type FontUsage, FontValidationError, type GainEnvelope, type GradientInterpolation, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MeshInterpolation, type MeshPaint, type MeshPoint, type MissingGlyphs, type OkLab, type Paint, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, type RetargetSpring, type Rgba, type Rng, type Scheduler, type Signal, type SignalOptions, type SpringConfig, type SpringEase, type StaggerOpts, type StaggerSpec, TARGET_PATH, type TargetCarrier, type Timeline, type TimelineBuilder, type TimelineInit, TimelineValidationError, type Track, TrackValidationError, type TweenOpts, type TweenTarget, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, type ValidateFontsOptions, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Component, type Vec2Signal, WriteDuringEvaluationError, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, endReadPhase, evaluateAt, fontAxesType, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, listValueTypes, namedEasing, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };

package/dist/index.js

@@ -1,4 +1,6 @@
-import { A as stringType, B as emitDevWarning, C as inferValueType, D as pathType, E as paintType, F as formatColor, G as springPresets, H as spring, I as lerpColor, J as cubicBezier, K as DEFAULT_EASE, L as oklabToRgba, M as vec2Equals, N as vec2Type, O as registerValueType, P as ColorParseError, Q as namedEasing, R as parseColor, S as getValueType, T as numberType, U as springEasing, V as setDevWarning, W as springEasingDerivative, X as easingDerivatives, Y as cubicBezierDerivative, Z as easings, _ as UnknownValueTypeError, a as targetNodeId, b as colorType, c as resolveEase, d as sampleTrack, f as springTo, g as velocityAt, h as validateTrack, i as resolveTweenTarget, j as vec2ArcType, k as reprOf, l as resolveEaseDerivative, m as track, n as UnresolvableTargetError, o as TrackValidationError, p as stagger, q as UnknownEasingError, r as isEditableNodeId, s as key, t as TARGET_PATH, u as retime, v as ValueTypeInferenceError, w as listValueTypes, x as fontAxesType, y as booleanType, z as rgbaToOklab } from "./targetRef.js";
+import { A as vec2Type, B as springEasing, C as paintType, D as stringType, E as reprOf, F as parseColor, G as cubicBezier, H as springPresets, I as rgbaToOklab, J as easings, K as cubicBezierDerivative, L as emitDevWarning, M as formatColor, N as lerpColor, O as vec2ArcType, P as oklabToRgba, R as setDevWarning, S as numberType, T as registerValueType, U as DEFAULT_EASE, V as springEasingDerivative, W as UnknownEasingError, Y as namedEasing, _ as colorType, a as resolveEaseDerivative, b as inferValueType, d as track, f as validateTrack, g as booleanType, h as ValueTypeInferenceError, i as resolveEase, j as ColorParseError, k as vec2Equals, l as springTo, m as UnknownValueTypeError, n as key, p as velocityAt, q as easingDerivatives, s as sampleTrack, t as TrackValidationError, u as stagger, v as fontAxesType, w as pathType, x as listValueTypes, y as getValueType, z as spring } from "./track.js";
+import { a as targetNodeId, i as resolveTweenTarget, n as UnresolvableTargetError, r as isEditableNodeId, t as TARGET_PATH } from "./targetRef.js";
+import { t as random } from "./rng.js";
 import { t as parseCmap } from "./cmap.js";
 import { a as isDurationEditable, i as compileTimeline, n as audioOffsetSamples, o as namespaceCallName, r as callMarkerPrefix, s as timeline$1, t as TimelineValidationError } from "./timeline.js";
 //#region src/ticker.ts
@@ -1002,21 +1004,6 @@ function evaluateAt(playhead, t, read) {
 	}
 }
 //#endregion
-//#region src/rng.ts
-/** Returns a deterministic [0,1) generator for the given integer seed. */
-function random(seed) {
-	let a = seed >>> 0;
-	return () => {
-		a = a + 2654435769 | 0;
-		let t = a ^ a >>> 16;
-		t = Math.imul(t, 569420461);
-		t = t ^ t >>> 15;
-		t = Math.imul(t, 1935289751);
-		t = t ^ t >>> 15;
-		return (t >>> 0) / 4294967296;
-	};
-}
-//#endregion
 //#region src/bake.ts
 /**
 * bake() (DESIGN.md §2.8): stateful simulation as a compilation step. Run the
@@ -1121,4 +1108,4 @@ function bakeCheckpointed(cfg) {
 	};
 }
 //#endregion
-export { BakeError, BindTypeMismatchError, CircularDependencyError, ColorParseError, DEFAULT_EASE, FontValidationError, PositionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, endReadPhase, evaluateAt, fontAxesType, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, listValueTypes, namedEasing, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, retime, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };
+export { BakeError, BindTypeMismatchError, CircularDependencyError, ColorParseError, DEFAULT_EASE, FontValidationError, PositionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, endReadPhase, evaluateAt, fontAxesType, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, listValueTypes, namedEasing, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };

package/dist/rng.js

@@ -0,0 +1,16 @@
+//#region src/rng.ts
+/** Returns a deterministic [0,1) generator for the given integer seed. */
+function random(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 2654435769 | 0;
+		let t = a ^ a >>> 16;
+		t = Math.imul(t, 569420461);
+		t = t ^ t >>> 15;
+		t = Math.imul(t, 1935289751);
+		t = t ^ t >>> 15;
+		return (t >>> 0) / 4294967296;
+	};
+}
+//#endregion
+export { random as t };

package/dist/sidecar.js

@@ -1,4 +1,5 @@
-import { B as emitDevWarning, H as spring, a as targetNodeId, o as TrackValidationError, r as isEditableNodeId } from "./targetRef.js";
+import { L as emitDevWarning, t as TrackValidationError, z as spring } from "./track.js";
+import { a as targetNodeId, r as isEditableNodeId } from "./targetRef.js";
 //#region src/sidecar.ts
 /**
 * The editor sidecar (DESIGN.md §6.2): code declares scene structure and