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

package/dist/clips.d.ts

@@ -1,4 +1,4 @@
-import { D as Vec2, T as ValueTypeId, Y as EaseSpec, r as Track, t as Key } from "./track.js";
+import { D as Vec2, T as ValueTypeId, X as EaseSpec, r as Track, t as Key } from "./track.js";
 import { r as TweenTarget } from "./targetRef.js";
 
 //#region src/clip.d.ts

package/dist/clips.js

@@ -501,6 +501,50 @@ function partitionOpacity(tracks, opacityTarget) {
 	};
 }
 /**
+* The same stable-sort + coincident-`t` later-wins dedup the opacity guard uses,
+* factored out so the NON-opacity channels reconcile identically. Given keys
+* already in merge order (earlier-emitted first), sort by `t` keeping that order
+* at ties, then collapse a coincident-`t` run to its LAST key. Pure.
+*/
+function reconcileKeys(keys) {
+	const sorted = stableSortByT(keys);
+	const deduped = [];
+	for (const k of sorted) {
+		const last = deduped[deduped.length - 1];
+		if (last && last.t === k.t) deduped[deduped.length - 1] = k;
+		else deduped.push(k);
+	}
+	return deduped;
+}
+/**
+* Reconcile the enter's then the exit's NON-opacity tracks per target. When enter
+* AND exit animate the SAME non-opacity channel (e.g. both slide `position` — a
+* slide-in-hold-slide-out), emit ONE track per target whose keys are the enter's
+* then the exit's, fused with the SAME stable-sort + later-wins dedup as opacity:
+* at a coincident `t` (the enter's settle vs the exit's start) the exit wins, so
+* the merged ramp is continuous and no key is silently dropped by
+* `compileTimeline`'s `coalesce()`. Disjoint targets pass straight through.
+* Output order is stable: first appearance across [enterRest, exitRest].
+*/
+function reconcileNonOpacity(enterRest, exitRest) {
+	const order = [];
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const tr of [...enterRest, ...exitRest]) {
+		const bucket = byTarget.get(tr.target);
+		if (bucket) bucket.push(tr);
+		else {
+			byTarget.set(tr.target, [tr]);
+			order.push(tr.target);
+		}
+	}
+	return order.map((target) => {
+		const group = byTarget.get(target);
+		if (group.length === 1) return group[0];
+		const merged = group.flatMap((tr) => tr.keys);
+		return track(target, group[0].type, reconcileKeys(merged));
+	});
+}
+/**
 * Schedule a node's enter/exit presence. Emits keyed `Track[]` only.
 *
 *   presence('card', { show: 1, hide: 5 })  // fade in at 1, fade out to land on 5
@@ -538,19 +582,8 @@ function presence(nodeId, opts) {
 	else overlay.push(key(show, 0), key(enterEnd, 1));
 	if (exitOpacity.length > 0) for (const k of exitOpacity) overlay.push(k);
 	else overlay.push(key(exitStart, 1), key(hide, 0));
-	const sorted = stableSortByT([...bareGuard, ...overlay]);
-	const deduped = [];
-	for (const k of sorted) {
-		const last = deduped[deduped.length - 1];
-		if (last && last.t === k.t) deduped[deduped.length - 1] = k;
-		else deduped.push(k);
-	}
 	return {
-		tracks: [
-			track(opacityTarget, "number", deduped),
-			...enterRest,
-			...exitRest
-		],
+		tracks: [track(opacityTarget, "number", reconcileKeys([...bareGuard, ...overlay])), ...reconcileNonOpacity(enterRest, exitRest)],
 		end: hide,
 		shownAt: show,
 		hiddenAt: hide

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as cubicBezierDerivative, A as getValueType, B as vec2Type, C as UnknownValueTypeError, D as Vec2, E as ValueTypeInferenceError, F as registerValueType, G as springEasing, H as SpringConfig, I as reprOf, J as DEFAULT_EASE, K as springEasingDerivative, L as stringType, M as numberType, N as paintType, O as booleanType, P as pathType, Q as cubicBezier, R as vec2ArcType, S as PathValue, T as ValueTypeId, U as SpringEase, V as RetargetSpring, W as spring, X as EasingFn, Y as EaseSpec, Z as UnknownEasingError, _ as MeshInterpolation, a as key, b as Paint, c as sampleTrack, d as track, et as easingDerivatives, f as validateTrack, g as HandoffKind, h as GradientInterpolation, i as TrackValidationError, j as inferValueType, k as colorType, l as springTo, m as ColorStop, n as KeyOpts, nt as namedEasing, o as resolveEase, p as velocityAt, q as springPresets, r as Track, s as resolveEaseDerivative, t as Key, tt as easings, u as stagger, v as MeshPaint, w as ValueType, x as PathContour, y as MeshPoint, z as vec2Equals } from "./track.js";
+import { $ as cubicBezier, A as getValueType, B as vec2Equals, C as UnknownValueTypeError, D as Vec2, E as ValueTypeInferenceError, F as pathType, G as spring, H as RetargetSpring, I as registerValueType, J as springPresets, K as springEasing, L as reprOf, M as listValueTypes, N as numberType, O as booleanType, P as paintType, Q as UnknownEasingError, R as stringType, S as PathValue, T as ValueTypeId, U as SpringConfig, V as vec2Type, W as SpringEase, X as EaseSpec, Y as DEFAULT_EASE, Z as EasingFn, _ as MeshInterpolation, a as key, b as Paint, c as sampleTrack, d as track, et as cubicBezierDerivative, f as validateTrack, g as HandoffKind, h as GradientInterpolation, i as TrackValidationError, j as inferValueType, k as colorType, l as springTo, m as ColorStop, n as KeyOpts, nt as easings, o as resolveEase, p as velocityAt, q as springEasingDerivative, r as Track, rt as namedEasing, s as resolveEaseDerivative, t as Key, tt as easingDerivatives, u as stagger, v as MeshPaint, w as ValueType, x as PathContour, y as MeshPoint, z as vec2ArcType } 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";
 import { _ as setSidecarTrack, a as SidecarOrphan, c as SidecarVersionError, d as emptySidecar, f as hashKeys, g as normalizeEditedKeys, h as migrateSidecar, i as SidecarDocV1, l as assignKeyIds, m as mergeSidecarDetailed, n as OrphanReason, o as SidecarTimelineEntry, p as mergeSidecar, r as SidecarDoc, s as SidecarTrackEntry, t as MergeResult, u as deleteSidecarTrack } from "./sidecar.js";
@@ -249,13 +249,22 @@ interface StaggerSpec<T = unknown> {
   ease?: EaseSpec;
 }
 /**
- * Stagger placement. `each` is the per-rank delay (seconds, number-only in v1).
- * `from` picks the anchor the cascade ranks outward from (GSAP parity); `at`
- * places the whole group's base position (defaults to the chain end).
+ * Stagger placement.
+ *
+ * `each` is the per-target delay. A number gives the uniform cascade
+ * `d_i = rank_i * each` (the common case). A function `(rank, count) => seconds`
+ * maps each target's rank (and the group size) to its own delay, so accelerating
+ * / decelerating / eased cascades are author-controlled (GSAP parity). The
+ * function must return a finite number for every target.
+ *
+ * `anchor` picks the placement the cascade ranks outward from — note this is the
+ * placement axis, distinct from `StaggerSpec.from` (the start VALUE that routes a
+ * target through `fromTo`). `at` places the whole group's base position
+ * (defaults to the chain end).
  */
 interface StaggerOpts {
-  each: number;
-  from?: 'start' | 'end' | 'center' | 'edges' | number;
+  each: number | ((rank: number, count: number) => number);
+  anchor?: 'start' | 'end' | 'center' | 'edges' | number;
   at?: Position;
 }
 interface TimelineBuilder {
@@ -264,12 +273,15 @@ interface TimelineBuilder {
   /**
    * Build-time sugar: loop the shipped `to`/`fromTo` emission over `targets`,
    * cascading each by a per-rank delay. Emits keys byte-identical to N
-   * hand-authored offset tweens. The `from` anchor ranks targets over their
-   * array index i (n = targets.length, c = (n-1)/2): `'start'` → i; `'end'` →
+   * hand-authored offset tweens. The `anchor` ranks targets over their array
+   * index i (n = targets.length, c = (n-1)/2): `'start'` → i; `'end'` →
    * (n-1)-i; `'center'` → round(|i-c|); `'edges'` → round(c-|i-c|); numeric k →
-   * round(|i-k|). Delay d_i = rank_i * each, inserted at `base + d_i` where
-   * `base = resolvePosition(opts.at)`. The group reads as one block to a
-   * following `'<'`/`'>'`/`'+='` step.
+   * round(|i-k|). The delay is `d_i = rank_i * each` for a numeric `each`, or
+   * `d_i = each(rank_i, n)` for a function `each` (accel/decel/eased cascades).
+   * Each target is inserted at `base + d_i` where `base = resolvePosition(opts.at)`.
+   * The group reads as one block to a following `'<'`/`'>'`/`'+='` step (its
+   * bounds are the true min/max delay, so a backward/non-uniform spread reports
+   * honestly to the cursor).
    */
   stagger<T>(targets: TweenTarget[], spec: StaggerSpec<T>, opts: StaggerOpts): TimelineBuilder;
   /** Hold key: the value snaps at the resolved position (§2.6). */
@@ -439,4 +451,4 @@ interface CheckpointedSim {
 }
 declare function bakeCheckpointed<W, S = W>(cfg: CheckpointedBakeConfig<W, S>): CheckpointedSim;
 //#endregion
-export { type AssetRef, type AudioClip, type BakeConfig, BakeError, 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 FontFaceRef, type FontMode, type FontRegistry, type FontUsage, FontValidationError, type GainEnvelope, type GradientInterpolation, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MergeResult, type MeshInterpolation, type MeshPaint, type MeshPoint, type MissingGlyphs, type OkLab, type OrphanReason, type Paint, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, type RetargetSpring, type Rgba, type Rng, type Scheduler, type SidecarDoc, type SidecarDocV1, type SidecarOrphan, type SidecarTimelineEntry, type SidecarTrackEntry, SidecarVersionError, 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, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, deleteSidecarTrack, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, setSidecarTrack, 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 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 FontFaceRef, type FontMode, type FontRegistry, type FontUsage, FontValidationError, type GainEnvelope, type GradientInterpolation, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MergeResult, type MeshInterpolation, type MeshPaint, type MeshPoint, type MissingGlyphs, type OkLab, type OrphanReason, type Paint, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, type RetargetSpring, type Rgba, type Rng, type Scheduler, type SidecarDoc, type SidecarDocV1, type SidecarOrphan, type SidecarTimelineEntry, type SidecarTrackEntry, SidecarVersionError, 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, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, deleteSidecarTrack, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, listValueTypes, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, setSidecarTrack, 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,6 +1,6 @@
-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 ValueTypeInferenceError, a as targetNodeId, b as getValueType, c as resolveEase, d as springTo, f as stagger, g as UnknownValueTypeError, h as velocityAt, i as resolveTweenTarget, j as ColorParseError, k as vec2Equals, l as resolveEaseDerivative, m as validateTrack, n as UnresolvableTargetError, o as TrackValidationError, p as track, q as easingDerivatives, r as isEditableNodeId, s as key, t as TARGET_PATH, u as sampleTrack, v as booleanType, w as pathType, x as inferValueType, y as colorType, z as spring } from "./targetRef.js";
+import { A as vec2Equals, B as spring, C as numberType, D as reprOf, E as registerValueType, F as oklabToRgba, G as UnknownEasingError, H as springEasingDerivative, I as parseColor, J as easingDerivatives, K as cubicBezier, L as rgbaToOklab, M as ColorParseError, N as formatColor, O as stringType, P as lerpColor, R as emitDevWarning, S as listValueTypes, T as pathType, U as springPresets, V as springEasing, W as DEFAULT_EASE, X as namedEasing, Y as easings, _ as ValueTypeInferenceError, a as targetNodeId, b as getValueType, c as resolveEase, d as springTo, f as stagger, g as UnknownValueTypeError, h as velocityAt, i as resolveTweenTarget, j as vec2Type, k as vec2ArcType, l as resolveEaseDerivative, m as validateTrack, n as UnresolvableTargetError, o as TrackValidationError, p as track, q as cubicBezierDerivative, r as isEditableNodeId, s as key, t as TARGET_PATH, u as sampleTrack, v as booleanType, w as paintType, x as inferValueType, y as colorType, z as setDevWarning } from "./targetRef.js";
 import { t as parseCmap } from "./cmap.js";
-import { a as hashKeys, c as migrateSidecar, d as TimelineValidationError, f as audioOffsetSamples, h as timeline$1, i as emptySidecar, l as normalizeEditedKeys, m as isDurationEditable, n as assignKeyIds, o as mergeSidecar, p as compileTimeline, r as deleteSidecarTrack, s as mergeSidecarDetailed, t as SidecarVersionError, u as setSidecarTrack } from "./sidecar.js";
+import { _ as timeline$1, a as hashKeys, c as migrateSidecar, d as TimelineValidationError, f as audioOffsetSamples, g as namespaceCallName, h as isDurationEditable, i as emptySidecar, l as normalizeEditedKeys, m as compileTimeline, n as assignKeyIds, o as mergeSidecar, p as callMarkerPrefix, r as deleteSidecarTrack, s as mergeSidecarDetailed, t as SidecarVersionError, u as setSidecarTrack } from "./sidecar.js";
 //#region src/ticker.ts
 /** The default scheduler: flush synchronously, preserving pre-ticker timing. */
 const synchronousScheduler = (flush) => flush();
@@ -647,30 +647,44 @@ function buildTimeline(build, init = {}) {
 			const n = targets.length;
 			const base = resolvePosition(opts.at);
 			const c = (n - 1) / 2;
+			const { anchor = "start", each } = opts;
+			const finite = (v) => {
+				if (!Number.isFinite(v)) throw new TimelineValidationError(`stagger: non-finite each/anchor (${String(v)})`);
+				return v;
+			};
+			if (typeof anchor === "number") finite(anchor);
+			if (typeof each === "number") finite(each);
 			const rankOf = (i) => {
-				const f = opts.from ?? "start";
-				if (f === "start") return i;
-				if (f === "end") return n - 1 - i;
-				if (f === "center") return Math.round(Math.abs(i - c));
-				if (f === "edges") return Math.round(c - Math.abs(i - c));
-				return Math.round(Math.abs(i - f));
+				if (anchor === "start") return i;
+				if (anchor === "end") return n - 1 - i;
+				if (anchor === "center") return Math.round(Math.abs(i - c));
+				if (anchor === "edges") return Math.round(c - Math.abs(i - c));
+				return Math.round(Math.abs(i - anchor));
 			};
-			const duration = spec.duration ?? 1;
-			let maxDelay = 0;
+			const delayOf = (rank) => finite(typeof each === "function" ? each(rank, n) : rank * each);
+			const ease = spec.ease;
+			const effDur = typeof ease === "object" && ease !== null && ease.kind === "spring" ? spring.duration(ease) : spec.duration ?? 1;
 			const tweenOpts = (d) => ({
 				at: base + d,
 				...spec.duration !== void 0 ? { duration: spec.duration } : {},
 				...spec.ease !== void 0 ? { ease: spec.ease } : {}
 			});
+			let minDelay = 0;
+			let maxDelay = 0;
 			for (let i = 0; i < n; i++) {
-				const d = rankOf(i) * opts.each;
-				if (d > maxDelay) maxDelay = d;
+				const d = delayOf(rankOf(i));
+				if (i === 0 || d < minDelay) minDelay = d;
+				if (i === 0 || d > maxDelay) maxDelay = d;
+				const start = base + d;
+				if (start < 0) throw new TimelineValidationError(`stagger: target would land at t=${start} (< 0); shift opts.at`);
 				const t = targets[i];
 				if (spec.from !== void 0) builder.fromTo(t, spec.from, spec.to, tweenOpts(d));
 				else builder.to(t, spec.to, tweenOpts(d));
 			}
-			prevStart = base;
-			prevEnd = base + maxDelay + duration;
+			if (n > 0) {
+				prevStart = base + minDelay;
+				prevEnd = base + maxDelay + effDur;
+			}
 			return builder;
 		},
 		set(target, value, opts = {}) {
@@ -704,8 +718,10 @@ function buildTimeline(build, init = {}) {
 				_pos: at
 			};
 			if (opts.timeScale !== void 0) entry.timeScale = opts.timeScale;
+			const childIndex = children.length;
 			children.push(entry);
-			for (const [name, fn] of getTimelineCallbacks(child)) if (!callbacks.has(name)) callbacks.set(name, fn);
+			const prefix = callMarkerPrefix(childIndex);
+			for (const [name, fn] of getTimelineCallbacks(child)) callbacks.set(namespaceCallName(name, prefix), fn);
 			const scale = mode === "sync" ? opts.timeScale ?? 1 : 1;
 			prevStart = start;
 			prevEnd = start + compileTimeline(child).duration / scale;
@@ -1047,4 +1063,4 @@ function bakeCheckpointed(cfg) {
 	};
 }
 //#endregion
-export { BakeError, BindTypeMismatchError, CircularDependencyError, ColorParseError, DEFAULT_EASE, FontValidationError, PositionError, SidecarVersionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, deleteSidecarTrack, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, setSidecarTrack, 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, SidecarVersionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, batch, beginReadPhase, bindTimeline, booleanType, buildFontRegistry, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, deleteSidecarTrack, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, isDurationEditable, isEditableNodeId, isExemptFamily, key, lerpColor, listValueTypes, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, paintType, parseCmap, parseColor, pathType, random, registerValueType, reprOf, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setScheduler, setSidecarTrack, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, synchronousScheduler, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };

package/dist/sidecar.js

@@ -1,4 +1,4 @@
-import { L as emitDevWarning, a as targetNodeId, m as validateTrack, o as TrackValidationError, r as isEditableNodeId, z as spring } from "./targetRef.js";
+import { B as spring, R as emitDevWarning, a as targetNodeId, m as validateTrack, o as TrackValidationError, r as isEditableNodeId } from "./targetRef.js";
 //#region src/timeline.ts
 /**
 * The Timeline document (DESIGN.md §2.3) — the serializable animation source
@@ -53,6 +53,24 @@ function rebaseKeys(keys, at, timeScale) {
 		t: at + k.t / timeScale
 	}));
 }
+/**
+* `.call()` markers carry an auto-assigned `call:N` name whose counter resets
+* per document, so two sibling sub-timelines that each define a `.call()` would
+* collide on `call:0` when rebased into one parent (one callback dropped, the
+* other double-firing). We namespace a child's `call:*` markers by the child's
+* position PATH in the parent (`c<index>/…`), and the builder's `add()` applies
+* the EXACT same prefix when forwarding the child's name→fn map — so the rebased
+* marker name and the registered callback key agree by construction. Only
+* `call:*` names are rewritten; author-named cues keep their names. Both surfaces
+* call these so the convention lives in one place.
+*/
+function callMarkerPrefix(childIndex) {
+	return `c${childIndex}/`;
+}
+const CALL = /(^|\/)call:\d+$/;
+function namespaceCallName(name, prefix) {
+	return prefix !== "" && CALL.test(name) ? prefix + name : name;
+}
 function flatten(doc, at, timeScale, unit, out, counter) {
 	for (const tr of doc.tracks) {
 		validateTrack(tr);
@@ -136,13 +154,15 @@ function compileTimeline(doc) {
 	const labels = { ...doc.labels };
 	const markers = [...doc.markers ?? []];
 	const audio = [...doc.audio ?? []];
-	const visitChildren = (children, at, scale) => {
-		for (const child of children ?? []) {
+	const visitChildren = (children, at, scale, prefix) => {
+		(children ?? []).forEach((child, index) => {
 			const base = at + child.at / scale;
 			const childScale = scale * (child.mode === "sync" ? child.timeScale ?? 1 : 1);
+			const childPrefix = prefix + callMarkerPrefix(index);
 			for (const [name, t] of Object.entries(child.timeline.labels ?? {})) if (!(name in labels)) labels[name] = base + t / childScale;
 			for (const m of child.timeline.markers ?? []) markers.push({
 				...m,
+				name: namespaceCallName(m.name, childPrefix),
 				t: base + m.t / childScale
 			});
 			for (const clip of child.timeline.audio ?? []) audio.push({
@@ -150,10 +170,10 @@ function compileTimeline(doc) {
 				at: base + clip.at / childScale,
 				...childScale !== 1 ? { playbackRate: (clip.playbackRate ?? 1) * childScale } : {}
 			});
-			visitChildren(child.timeline.children, base, childScale);
-		}
+			visitChildren(child.timeline.children, base, childScale, childPrefix);
+		});
 	};
-	visitChildren(doc.children, 0, 1);
+	visitChildren(doc.children, 0, 1, "");
 	markers.sort((a, b) => a.t - b.t);
 	audio.sort((a, b) => a.at - b.at);
 	return {
@@ -391,4 +411,4 @@ function normalizeEditedKeys(keys) {
 	return out;
 }
 //#endregion
-export { hashKeys as a, migrateSidecar as c, TimelineValidationError as d, audioOffsetSamples as f, timeline as h, emptySidecar as i, normalizeEditedKeys as l, isDurationEditable as m, assignKeyIds as n, mergeSidecar as o, compileTimeline as p, deleteSidecarTrack as r, mergeSidecarDetailed as s, SidecarVersionError as t, setSidecarTrack as u };
+export { timeline as _, hashKeys as a, migrateSidecar as c, TimelineValidationError as d, audioOffsetSamples as f, namespaceCallName as g, isDurationEditable as h, emptySidecar as i, normalizeEditedKeys as l, compileTimeline as m, assignKeyIds as n, mergeSidecar as o, callMarkerPrefix as p, deleteSidecarTrack as r, mergeSidecarDetailed as s, SidecarVersionError as t, setSidecarTrack as u };

package/dist/studioHost.d.ts

@@ -1,4 +1,4 @@
-import { T as ValueTypeId, Y as EaseSpec, t as Key } from "./track.js";
+import { T as ValueTypeId, X as EaseSpec, t as Key } from "./track.js";
 import { a as isEditableNodeId, s as targetNodeId } from "./targetRef.js";
 import { l as Timeline } from "./timeline.js";
 import { a as SidecarOrphan, r as SidecarDoc } from "./sidecar.js";

package/dist/targetRef.js

@@ -491,6 +491,16 @@ function getValueType(id) {
 	return vt;
 }
 /**
+* The ids of every currently-registered value type, in registration order
+* (the built-ins first, then any custom `registerValueType` additions). The
+* introspection seam `describe()` reads to list `valueTypes` from the REAL
+* registry — so the manifest can't drift from what `evaluate()` can actually
+* interpolate. Pure read; never touched by evaluate().
+*/
+function listValueTypes() {
+	return [...registry.keys()];
+}
+/**
 * Resolve a value-type id to its REPRESENTATION (the bind guard's compatibility
 * key, §2.2): a type's `repr` (the built-in it's representationally compatible
 * with), else the id itself. SINGLE-HOP — `repr` is never chained, so a custom
@@ -1030,4 +1040,4 @@ function resolveTweenTarget(target) {
 	return path;
 }
 //#endregion
-export { vec2Type as A, springEasing as B, paintType as C, stringType as D, reprOf as E, parseColor as F, cubicBezier as G, springPresets as H, rgbaToOklab as I, easings as J, cubicBezierDerivative as K, emitDevWarning as L, formatColor as M, lerpColor as N, vec2ArcType as O, oklabToRgba as P, setDevWarning as R, numberType as S, registerValueType as T, DEFAULT_EASE as U, springEasingDerivative as V, UnknownEasingError as W, namedEasing as Y, ValueTypeInferenceError as _, targetNodeId as a, getValueType as b, resolveEase as c, springTo as d, stagger as f, UnknownValueTypeError as g, velocityAt as h, resolveTweenTarget as i, ColorParseError as j, vec2Equals as k, resolveEaseDerivative as l, validateTrack as m, UnresolvableTargetError as n, TrackValidationError as o, track as p, easingDerivatives as q, isEditableNodeId as r, key as s, TARGET_PATH as t, sampleTrack as u, booleanType as v, pathType as w, inferValueType as x, colorType as y, spring as z };
+export { vec2Equals as A, spring as B, numberType as C, reprOf as D, registerValueType as E, oklabToRgba as F, UnknownEasingError as G, springEasingDerivative as H, parseColor as I, easingDerivatives as J, cubicBezier as K, rgbaToOklab as L, ColorParseError as M, formatColor as N, stringType as O, lerpColor as P, emitDevWarning as R, listValueTypes as S, pathType as T, springPresets as U, springEasing as V, DEFAULT_EASE as W, namedEasing as X, easings as Y, ValueTypeInferenceError as _, targetNodeId as a, getValueType as b, resolveEase as c, springTo as d, stagger as f, UnknownValueTypeError as g, velocityAt as h, resolveTweenTarget as i, vec2Type as j, vec2ArcType as k, resolveEaseDerivative as l, validateTrack as m, UnresolvableTargetError as n, TrackValidationError as o, track as p, cubicBezierDerivative as q, isEditableNodeId as r, key as s, TARGET_PATH as t, sampleTrack as u, booleanType as v, paintType as w, inferValueType as x, colorType as y, setDevWarning as z };

package/dist/timeline.d.ts

@@ -128,6 +128,18 @@ interface CompiledTimeline {
  * and the other to raw float seconds. Default rate is the canonical mix grid.
  */
 declare function audioOffsetSamples(at: number, sampleRate?: number): number;
+/**
+ * `.call()` markers carry an auto-assigned `call:N` name whose counter resets
+ * per document, so two sibling sub-timelines that each define a `.call()` would
+ * collide on `call:0` when rebased into one parent (one callback dropped, the
+ * other double-firing). We namespace a child's `call:*` markers by the child's
+ * position PATH in the parent (`c<index>/…`), and the builder's `add()` applies
+ * the EXACT same prefix when forwarding the child's name→fn map — so the rebased
+ * marker name and the registered callback key agree by construction. Only
+ * `call:*` names are rewritten; author-named cues keep their names. Both surfaces
+ * call these so the convention lives in one place.
+ */
+
 /**
  * Studio reader (§6.2 rule 4): is this timeline's duration opted into editor
  * editing? Code-owned and read-only by default; `editableDuration()` flips it.

package/dist/track.d.ts

@@ -175,6 +175,14 @@ declare class UnknownValueTypeError extends Error {
   constructor(id: string);
 }
 declare function getValueType<T = unknown>(id: ValueTypeId): ValueType<T>;
+/**
+ * The ids of every currently-registered value type, in registration order
+ * (the built-ins first, then any custom `registerValueType` additions). The
+ * introspection seam `describe()` reads to list `valueTypes` from the REAL
+ * registry — so the manifest can't drift from what `evaluate()` can actually
+ * interpolate. Pure read; never touched by evaluate().
+ */
+declare function listValueTypes(): string[];
 /**
  * Resolve a value-type id to its REPRESENTATION (the bind guard's compatibility
  * key, §2.2): a type's `repr` (the built-in it's representationally compatible
@@ -344,4 +352,4 @@ declare function velocityAt<T>(tr: Track<T>, t: number): T | null;
 /** Pure sample of a track at time t (§2.4). */
 declare function sampleTrack<T>(tr: Track<T>, t: number): T;
 //#endregion
-export { cubicBezierDerivative as $, getValueType as A, vec2Type as B, UnknownValueTypeError as C, Vec2 as D, ValueTypeInferenceError as E, registerValueType as F, springEasing as G, SpringConfig as H, reprOf as I, DEFAULT_EASE as J, springEasingDerivative as K, stringType as L, numberType as M, paintType as N, booleanType as O, pathType as P, cubicBezier as Q, vec2ArcType as R, PathValue as S, ValueTypeId as T, SpringEase as U, RetargetSpring as V, spring as W, EasingFn as X, EaseSpec as Y, UnknownEasingError as Z, MeshInterpolation as _, key as a, Paint as b, sampleTrack as c, track as d, easingDerivatives as et, validateTrack as f, HandoffKind as g, GradientInterpolation as h, TrackValidationError as i, inferValueType as j, colorType as k, springTo as l, ColorStop as m, KeyOpts as n, namedEasing as nt, resolveEase as o, velocityAt as p, springPresets as q, Track as r, resolveEaseDerivative as s, Key as t, easings as tt, stagger as u, MeshPaint as v, ValueType as w, PathContour as x, MeshPoint as y, vec2Equals as z };
+export { cubicBezier as $, getValueType as A, vec2Equals as B, UnknownValueTypeError as C, Vec2 as D, ValueTypeInferenceError as E, pathType as F, spring as G, RetargetSpring as H, registerValueType as I, springPresets as J, springEasing as K, reprOf as L, listValueTypes as M, numberType as N, booleanType as O, paintType as P, UnknownEasingError as Q, stringType as R, PathValue as S, ValueTypeId as T, SpringConfig as U, vec2Type as V, SpringEase as W, EaseSpec as X, DEFAULT_EASE as Y, EasingFn as Z, MeshInterpolation as _, key as a, Paint as b, sampleTrack as c, track as d, cubicBezierDerivative as et, validateTrack as f, HandoffKind as g, GradientInterpolation as h, TrackValidationError as i, inferValueType as j, colorType as k, springTo as l, ColorStop as m, KeyOpts as n, easings as nt, resolveEase as o, velocityAt as p, springEasingDerivative as q, Track as r, namedEasing as rt, resolveEaseDerivative as s, Key as t, easingDerivatives as tt, stagger as u, MeshPaint as v, ValueType as w, PathContour as x, MeshPoint as y, vec2ArcType as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/core",
-  "version": "0.18.0-pre.3",
+  "version": "0.18.0-pre.5",
   "description": "glissade core: signals, tracks, timeline document, evaluation, easing, springs, seeded RNG. Zero DOM/Node dependencies.",
   "license": "Apache-2.0",
   "engines": {