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

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

@@ -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.3",
+  "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": {