@glissade/core 0.18.0-pre.2 → 0.18.0-pre.4

package/dist/clips.d.ts

@@ -1,4 +1,4 @@
-import { T as ValueTypeId, Y as EaseSpec, r as Track, t as Key } from "./track.js";
+import { D as Vec2, T as ValueTypeId, Y as EaseSpec, r as Track, t as Key } from "./track.js";
 import { r as TweenTarget } from "./targetRef.js";
 
 //#region src/clip.d.ts
@@ -182,20 +182,63 @@ declare function morph(from: Box, to: Box, targets: MorphTargets, opts: MorphOpt
 declare class PresenceError extends Error {
   constructor(message: string);
 }
+/**
+ * An inline ENTER/EXIT literal (0.18 sugar): a terse alternative to hand-building
+ * a `clip({channels})`. `transitionToClip` compiles it to the SAME `Clip` an author
+ * would write by hand, so presence() then runs UNCHANGED on the result — the inline
+ * spelling is byte-INDISTINGUISHABLE from the hand-authored clip path.
+ *
+ * Conventions mirror clipStdlib (`slideIn`/`popIn`): a scalar `offset` slides that
+ * magnitude in along `edge` (default 'bottom' = slide up from below); a scalar
+ * `scale` broadcasts to a Vec2; OMITTING `opacity` emits NO opacity channel so
+ * presence()'s synthesized rise/fall takes over (matching the Clip path exactly).
+ */
+interface PresenceTransition {
+  /** Opacity endpoints [from,to]. OMIT to rely on presence()'s synthesized rise/fall. */
+  opacity?: [number, number];
+  /**
+   * Slide displacement. A scalar slides that magnitude along `edge`; a single Vec2
+   * is the displaced point (animates to/from [0,0]); a [Vec2,Vec2] is explicit
+   * endpoints. Omit for no position channel.
+   */
+  offset?: number | Vec2 | [Vec2, Vec2];
+  /** Slide edge for a scalar `offset` (clipStdlib convention). Default 'bottom'. */
+  edge?: SlideEdge;
+  /** Scale endpoints. A scalar pair broadcasts each value to a Vec2 (popIn convention). */
+  scale?: [number, number] | [Vec2, Vec2];
+  /** Transition length in seconds. Default = the presence DEFAULT_FADE (0.3). */
+  dur?: number;
+  /** Arriving ease of every channel's last segment. */
+  ease?: EaseSpec;
+}
 interface PresenceOpts {
   /** Wall-clock second the node ENTERS (becomes visible). */
-  show: number;
+  show?: number;
   /** Wall-clock second the node has fully EXITED (the exit LANDS here). */
-  hide: number;
-  /** Entrance clip (default = a plain opacity fade-in 0→1, ~0.3s). */
-  enter?: Clip;
-  /** Exit clip (default = a plain opacity fade-out 1→0, ~0.3s). Back-timed to land on `hide`. */
-  exit?: Clip;
+  hide?: number;
+  /** Alias for `{ show: window[0], hide: window[1] }`. */
+  window?: [number, number];
+  /** Entrance clip, or an inline transition literal (default = a plain opacity fade-in 0→1, ~0.3s). */
+  enter?: Clip | PresenceTransition;
+  /** Exit clip, or an inline transition literal (default = a plain opacity fade-out 1→0, ~0.3s). Back-timed to land on `hide`. */
+  exit?: Clip | PresenceTransition;
   /** Forwarded to `enter.apply` (speed / per-channel overrides). */
   enterOpts?: ApplyOpts;
   /** Forwarded to `exit.apply` (speed / per-channel overrides). */
   exitOpts?: ApplyOpts;
 }
+/**
+ * Compile an inline `PresenceTransition` literal into the SAME `Clip` an author
+ * would hand-write — an opacity channel (only when `opacity` is given), a position
+ * channel from `offset`+`edge` (slideIn convention), and a scale channel (scalar
+ * broadcast to Vec2, popIn convention). presence() then runs UNCHANGED on it.
+ *
+ * `dir` selects the slide direction: an `enter` slides FROM the edge-displaced
+ * point TO [0,0]; an `exit` slides FROM [0,0] TO the edge-displaced point (so a
+ * back-timed exit reads as the inverse of the entrance). For an explicit
+ * `[Vec2,Vec2]` offset the endpoints are used verbatim (no direction flip).
+ */
+declare function transitionToClip(t: PresenceTransition, dir: 'enter' | 'exit'): Clip;
 interface PresenceResult {
   /** Reconciled tracks: the opacity guard (fused with enter/exit opacity keys) + any non-opacity channels. */
   tracks: Track[];
@@ -213,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 SlideEdge, clip, clipList, driftLoop, morph, popIn, presence, pulse, slideIn };
+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 };

package/dist/clips.js

@@ -398,6 +398,82 @@ function defaultExit() {
 		keys: [key(0, 1), key(DEFAULT_FADE, 0)]
 	} } });
 }
+/** A `PresenceTransition` is a plain bag; a `Clip` carries `apply`. Discriminate on that. */
+function isClip(t) {
+	return typeof t.apply === "function";
+}
+/** Is a value a Vec2 ([number, number])? */
+function isVec2(v) {
+	return Array.isArray(v);
+}
+/**
+* Compile an inline `PresenceTransition` literal into the SAME `Clip` an author
+* would hand-write — an opacity channel (only when `opacity` is given), a position
+* channel from `offset`+`edge` (slideIn convention), and a scale channel (scalar
+* broadcast to Vec2, popIn convention). presence() then runs UNCHANGED on it.
+*
+* `dir` selects the slide direction: an `enter` slides FROM the edge-displaced
+* point TO [0,0]; an `exit` slides FROM [0,0] TO the edge-displaced point (so a
+* back-timed exit reads as the inverse of the entrance). For an explicit
+* `[Vec2,Vec2]` offset the endpoints are used verbatim (no direction flip).
+*/
+function transitionToClip(t, dir) {
+	const d = t.dur ?? DEFAULT_FADE;
+	const ease = t.ease;
+	const channels = {};
+	if (t.opacity !== void 0) {
+		const [from, to] = t.opacity;
+		channels.opacity = {
+			path: "opacity",
+			keys: [key(0, from), key(d, to, ...easeArg(ease))]
+		};
+	}
+	if (t.offset !== void 0) {
+		const [from, to] = offsetEndpoints(t.offset, t.edge ?? "bottom", dir);
+		channels.offset = {
+			path: "position",
+			keys: [key(0, from), key(d, to, ...easeArg(ease))]
+		};
+	}
+	if (t.scale !== void 0) {
+		const [from, to] = scaleEndpoints(t.scale);
+		channels.scale = {
+			path: "scale",
+			keys: [key(0, from), key(d, to, ...easeArg(ease))]
+		};
+	}
+	return clip({ channels });
+}
+/** Spread-arg helper: pass `ease` to `key()` only when defined (no `undefined` arg). */
+function easeArg(ease) {
+	return ease !== void 0 ? [ease] : [];
+}
+/** Edge → unit displacement direction (matches clipStdlib's slideIn `from` vectors). */
+function edgeVec(edge, dist) {
+	return edge === "left" ? [-dist, 0] : edge === "right" ? [dist, 0] : edge === "top" ? [0, -dist] : [0, dist];
+}
+/**
+* Resolve the `offset` field to position [from, to] endpoints. A scalar slides that
+* magnitude along `edge`; a single Vec2 is the displaced point; a [Vec2,Vec2] is
+* verbatim endpoints. enter goes displaced→[0,0]; exit goes [0,0]→displaced.
+*/
+function offsetEndpoints(offset, edge, dir) {
+	if (Array.isArray(offset) && isVec2(offset[0])) return offset;
+	const displaced = isVec2(offset) ? offset : edgeVec(edge, offset);
+	const origin = [0, 0];
+	return dir === "enter" ? [displaced, origin] : [origin, displaced];
+}
+/** Resolve the `scale` field to [from, to] Vec2 endpoints (scalar pair → broadcast). */
+function scaleEndpoints(scale) {
+	const [a, b] = scale;
+	const broadcast = (v) => isVec2(v) ? v : [v, v];
+	return [broadcast(a), broadcast(b)];
+}
+/** Normalize an enter/exit option (Clip or inline literal) to a Clip. */
+function resolveTransition(t, dir, fallback) {
+	if (t === void 0) return fallback();
+	return isClip(t) ? t : transitionToClip(t, dir);
+}
 /** Effective duration of a clip after a speed multiplier (`apply` divides every t by speed). */
 function effectiveDuration(c, opts) {
 	return c.duration / (opts?.speed ?? 1);
@@ -425,17 +501,63 @@ 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
 */
 function presence(nodeId, opts) {
-	const { show, hide } = opts;
+	const show = opts.show ?? opts.window?.[0];
+	const hide = opts.hide ?? opts.window?.[1];
+	if (show === void 0 || hide === void 0) throw new PresenceError(`presence() needs a window: pass { show, hide } or { window: [show, hide] }`);
 	const opacityTarget = resolveTweenTarget(typeof nodeId === "string" ? `${nodeId}/opacity` : nodeId);
 	const lastSlash = opacityTarget.lastIndexOf("/");
 	const nodeIdStr = lastSlash < 0 ? opacityTarget : opacityTarget.slice(0, lastSlash);
-	const enter = opts.enter ?? defaultEnter();
-	const exit = opts.exit ?? defaultExit();
+	const enter = resolveTransition(opts.enter, "enter", defaultEnter);
+	const exit = resolveTransition(opts.exit, "exit", defaultExit);
 	const enterRes = enter.apply(nodeIdStr, show, opts.enterOpts);
 	const enterEnd = show + effectiveDuration(enter, opts.enterOpts);
 	const exitDur = effectiveDuration(exit, opts.exitOpts);
@@ -460,23 +582,12 @@ 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
 	};
 }
 //#endregion
-export { ClipError, MorphError, PresenceError, clip, clipList, driftLoop, morph, popIn, presence, pulse, slideIn };
+export { ClipError, MorphError, PresenceError, clip, clipList, driftLoop, morph, popIn, presence, pulse, slideIn, transitionToClip };

package/dist/index.d.ts

@@ -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). */

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 { 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;

package/dist/sidecar.js

@@ -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/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/package.json

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