@glissade/core 0.7.0-pre.0 → 0.8.0-pre.0

package/dist/index.d.ts

@@ -72,6 +72,9 @@ interface ValueType<T> {
   scale?(a: T, k: number): T;
   /** Type-class handoff default (§B.1): spring for kinetic, cut for hold-only. */
   defaultHandoff?: HandoffKind;
+  /** Document (de)serialization; default identity for JSON-native types (§2.2). */
+  serialize?(value: T): unknown;
+  deserialize?(raw: unknown): T;
 }
 type ValueTypeId = 'number' | 'vec2' | 'color' | 'string' | 'boolean' | (string & {});
 declare function registerValueType<T>(vt: ValueType<T>): void;
@@ -82,6 +85,8 @@ declare function getValueType<T = unknown>(id: ValueTypeId): ValueType<T>;
 declare const numberType: ValueType<number>;
 declare const vec2Equals: (a: Vec2, b: Vec2) => boolean;
 declare const vec2Type: ValueType<Vec2>;
+/** vec2 swept along a circular arc: polar lerp of radius + shortest-path angle (§2.2). */
+declare const vec2ArcType: ValueType<Vec2>;
 declare const colorType: ValueType<string>;
 declare const stringType: ValueType<string>;
 declare const booleanType: ValueType<boolean>;
@@ -280,6 +285,8 @@ interface Key<T = unknown> {
   id?: string;
   /** Builder-resolved implicit from-value; re-resolved on merge (§2.6, §6.2). */
   derived?: boolean;
+  /** Reserved (§4.7): a v2 synthesized-transition leading key reads the live value. v1 accepts but ignores it. */
+  from?: 'live';
 }
 interface Track<T = unknown> {
   /** Canonical path: '<nodeId>/<prop.path>', e.g. 'circle/position.x'. */
@@ -289,6 +296,8 @@ interface Track<T = unknown> {
   keys: Key<T>[];
   /** Studio may own this track's keys via sidecar (§6.2). */
   editable?: boolean;
+  /** Reserved (§2.2/§B.6): v2 additive blending. v1 accepts but ignores it (coalesce stays last-wins). */
+  additive?: boolean;
 }
 declare class TrackValidationError extends Error {
   constructor(target: string, message: string);
@@ -477,6 +486,13 @@ interface TimelineBuilder {
   }): TimelineBuilder;
   /** Compiles to a marker; the callback is Player-registered, never serialized (§4.2). */
   call(fn: () => void, at?: Position): TimelineBuilder;
+  /** A named cue marker (serialized, fired on crossing) — the composer-signal substrate. */
+  cue(at: Position, name: string, data?: Json): TimelineBuilder;
+  /** An ad-break cue: a marker with `data.kind: 'ad-break'` + optional duration (§ad-break). */
+  adBreak(at: Position, opts?: {
+    id?: string;
+    duration?: number;
+  }): TimelineBuilder;
   /** Mark the preceding track editable for the studio (§6.2). */
   editable(): TimelineBuilder;
 }
@@ -571,36 +587,78 @@ interface CheckpointedSim {
 declare function bakeCheckpointed<W, S = W>(cfg: CheckpointedBakeConfig<W, S>): CheckpointedSim;
 //#endregion
 //#region src/sidecar.d.ts
+type OrphanReason = 'node-missing' | 'prop-missing' | 'type-changed';
+interface SidecarTrackEntry {
+  /** value type, so an editor-created track binds without a code baseline. */
+  type: ValueTypeId;
+  /** hash of the code baseline this track branched from; null = editor-created. */
+  baseHash: string | null;
+  keys: Key[];
+}
+interface SidecarOrphan {
+  type: ValueTypeId;
+  keys: Key[];
+  reason: OrphanReason;
+}
+interface SidecarTimelineEntry {
+  /** editor-owned tracks, keyed by canonical target. */
+  tracks: Record<string, SidecarTrackEntry>;
+  /** editor-created labels. */
+  labels?: Record<string, number>;
+  /** tracks parked off the merge because their target drifted (§6.2 rule 3). */
+  orphans?: Record<string, SidecarOrphan>;
+}
 interface SidecarDoc {
+  sidecarVersion: 2;
+  /** edits namespaced by timeline id; the linear timeline is 'main'. */
+  timelines: Record<string, SidecarTimelineEntry>;
+}
+/** The flat v1 shape, accepted on load and migrated forward. */
+interface SidecarDocV1 {
   sidecarVersion: 1;
-  /** Editor-owned tracks, replacing same-target code tracks wholesale. */
   tracks: Track[];
-  /** Editor-created labels; code labels are authoritative and win on a name collision (§6.2). */
   labels?: Record<string, number>;
 }
 declare class SidecarVersionError extends Error {
   constructor(version: unknown);
 }
 declare function emptySidecar(): SidecarDoc;
+/** Lift a v1 (or already-v2) document to the v2 shape. Throws on unknown versions. */
+declare function migrateSidecar(doc: SidecarDoc | SidecarDocV1 | null | undefined): SidecarDoc | null;
+/** Stable hash of a code track's keys — the baseline an editor branch records. */
+declare function hashKeys(keys: readonly Key[]): string;
+/** Assign stable monotonic `k<N>` ids to keys lacking one; existing ids preserved. */
+declare function assignKeyIds(keys: readonly Key[]): Key[];
+/**
+ * Set one editable track's keys in the sidecar (§6.2) — the studio write path.
+ * `codeBaselineKeys` is the code track this branches from (null = editor-created
+ * with no baseline). Keys get stable `k<N>` ids. Returns a new document.
+ */
+declare function setSidecarTrack(doc: SidecarDoc, timelineId: string, target: string, type: ValueTypeId, keys: Key[], codeBaselineKeys: readonly Key[] | null): SidecarDoc;
+interface MergeResult {
+  timeline: Timeline;
+  /** targets whose code baseline changed beneath the editor's keys (§6.2 rule 2). */
+  drift: string[];
+  /** sidecar tracks parked off the merge (§6.2 rule 3). */
+  orphans: Record<string, SidecarOrphan>;
+}
+/**
+ * Merge with the full §6.2 report: the bindable Timeline, the list of targets
+ * whose code baseline drifted, and the orphaned tracks (type-changed, or whose
+ * code track vanished). Orphans are NEVER merged, so a drifted edit can't make
+ * the whole overlay fail to bind — the good edits survive. Inputs unmutated.
+ */
+declare function mergeSidecarDetailed(code: Timeline, sidecar: SidecarDoc | SidecarDocV1 | null | undefined): MergeResult;
+/** Merge the sidecar overlay onto the code baseline → a bindable Timeline (§6.2). */
+declare function mergeSidecar(code: Timeline, sidecar: SidecarDoc | SidecarDocV1 | null | undefined): Timeline;
 /**
  * Editor-edit normalization (§2.7 invariant): a spring-eased key's t is
  * intrinsic — prev.t + spring.duration(cfg) — so after any retime, sort and
  * re-pin spring keys to their predecessors. Dragging a spring key itself
  * therefore snaps back; retiming its predecessor carries it along. Returns a
- * new array. Colliding keys are NUDGED apart (+1ms), never deleted — an
- * editor must not silently destroy keyframe data on an exact-t collision.
+ * new array. Colliding keys are NUDGED apart (+1ms), never deleted — an editor
+ * must not silently destroy keyframe data on an exact-t collision.
  */
 declare function normalizeEditedKeys(keys: Key[]): Key[];
-/**
- * Merge rules (§6.2, schema-drift resolution):
- * - a sidecar track whose target exists in code REPLACES that track's keys
- *   (the editor owns it; `editable` is preserved on the result);
- * - a sidecar track with no code counterpart is ADDED (editor-created track);
- * - sidecar tracks targeting nothing the scene can bind fail later at
- *   bindTimeline with UnboundTargetError — surfaced, never silently dropped;
- * - code tracks without sidecar counterparts pass through untouched.
- * The input documents are not mutated.
- */
-declare function mergeSidecar(code: Timeline, sidecar: SidecarDoc | null | undefined): Timeline;
 //#endregion
-export { type AssetRef, type AudioClip, type BakeConfig, BakeError, type BindTarget, type BindableSignal, type BoundTimeline, type CheckpointedBakeConfig, type CheckpointedSim, type ChildEntry, CircularDependencyError, ColorParseError, type CompiledTimeline, type CurveSampler, DEFAULT_EASE, type DevWarning, type EaseSpec, type EasingFn, type Equals, type GainEnvelope, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type OkLab, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type RetargetSpring, type Rgba, type Rng, type SidecarDoc, SidecarVersionError, type Signal, type SignalOptions, type SpringConfig, type SpringEase, TARGET_PATH, type TargetCarrier, type Timeline, type TimelineBuilder, type TimelineInit, TimelineValidationError, type Track, TrackValidationError, type TweenOpts, type TweenTarget, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Signal, WriteDuringEvaluationError, audioOffsetSamples, bake, bakeCheckpointed, beginReadPhase, bindTimeline, booleanType, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, key, lerpColor, mergeSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, timeline, track, untracked, validateTrack, vec2Equals, vec2Signal, vec2Type, velocityAt };
+export { type AssetRef, type AudioClip, type BakeConfig, BakeError, type BindTarget, type BindableSignal, type BoundTimeline, type CheckpointedBakeConfig, type CheckpointedSim, type ChildEntry, CircularDependencyError, ColorParseError, type CompiledTimeline, type CurveSampler, DEFAULT_EASE, type DevWarning, type EaseSpec, type EasingFn, type Equals, type GainEnvelope, type HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MergeResult, type OkLab, type OrphanReason, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type RetargetSpring, type Rgba, type Rng, type SidecarDoc, type SidecarDocV1, type SidecarOrphan, type SidecarTimelineEntry, type SidecarTrackEntry, SidecarVersionError, type Signal, type SignalOptions, type SpringConfig, type SpringEase, TARGET_PATH, type TargetCarrier, type Timeline, type TimelineBuilder, type TimelineInit, TimelineValidationError, type Track, TrackValidationError, type TweenOpts, type TweenTarget, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Signal, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, beginReadPhase, bindTimeline, booleanType, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, key, lerpColor, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setSidecarTrack, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, timeline, track, untracked, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };

package/dist/index.js

@@ -341,6 +341,24 @@ const vec2Type = {
 	scale: (a, k) => [a[0] * k, a[1] * k],
 	defaultHandoff: "spring"
 };
+/** vec2 swept along a circular arc: polar lerp of radius + shortest-path angle (§2.2). */
+const vec2ArcType = {
+	id: "vec2-arc",
+	lerp: (a, b, t) => {
+		const ra = Math.hypot(a[0], a[1]);
+		const rb = Math.hypot(b[0], b[1]);
+		const angA = Math.atan2(a[1], a[0]);
+		let dAng = Math.atan2(b[1], b[0]) - angA;
+		while (dAng > Math.PI) dAng -= 2 * Math.PI;
+		while (dAng < -Math.PI) dAng += 2 * Math.PI;
+		const r = ra + (rb - ra) * t;
+		const ang = angA + dAng * t;
+		return [r * Math.cos(ang), r * Math.sin(ang)];
+	},
+	extrapolates: true,
+	equals: vec2Equals,
+	defaultHandoff: "blend-from-frozen"
+};
 const colorType = {
 	id: "color",
 	lerp: lerpColor,
@@ -435,6 +453,7 @@ function inferValueType(value) {
 }
 registerValueType(numberType);
 registerValueType(vec2Type);
+registerValueType(vec2ArcType);
 registerValueType(colorType);
 registerValueType(stringType);
 registerValueType(booleanType);
@@ -1365,6 +1384,29 @@ function buildTimeline(build, init = {}) {
 			callbacks.set(name, fn);
 			return builder;
 		},
+		cue(at, name, data) {
+			markers.push(data !== void 0 ? {
+				t: resolvePosition(at),
+				name,
+				data
+			} : {
+				t: resolvePosition(at),
+				name
+			});
+			return builder;
+		},
+		adBreak(at, opts = {}) {
+			const data = {
+				kind: "ad-break",
+				...opts.duration !== void 0 ? { duration: opts.duration } : {}
+			};
+			markers.push({
+				t: resolvePosition(at),
+				name: opts.id ?? "ad-break",
+				data
+			});
+			return builder;
+		},
 		editable() {
 			const last = insertions[insertions.length - 1];
 			if (!last) throw new TimelineValidationError(".editable() requires a preceding insertion");
@@ -1624,85 +1666,204 @@ function bakeCheckpointed(cfg) {
 //#region src/sidecar.ts
 /**
 * The editor sidecar (DESIGN.md §6.2): code declares scene structure and
-* programmatic tracks; the studio owns keyframe data persisted as a sidecar
-* document next to the scene module, merged at track granularity. Versioned
-* independently of the API (§7.4) — breaking it orphans users' files.
+* programmatic tracks; the studio owns keyframe data persisted next to the
+* scene module and merged at track granularity. Versioned independently of the
+* API (§7.4) — breaking it orphans users' files, so v1 documents migrate.
+*
+* v2 namespaces edits by timeline id ('main' for the linear timeline; v2
+* machines add more), keys tracks by canonical target, records the code
+* baseline hash for drift detection, parks drifted tracks as `orphans`, and
+* gives keys stable `k<N>` ids.
 */
+const MAIN = "main";
 var SidecarVersionError = class extends Error {
 	constructor(version) {
-		super(`unsupported sidecar version ${String(version)}; this build reads sidecarVersion 1`);
+		super(`unsupported sidecar version ${String(version)}; this build reads sidecarVersion 1 or 2`);
 		this.name = "SidecarVersionError";
 	}
 };
 function emptySidecar() {
 	return {
-		sidecarVersion: 1,
-		tracks: []
+		sidecarVersion: 2,
+		timelines: { [MAIN]: { tracks: {} } }
 	};
 }
+/** Lift a v1 (or already-v2) document to the v2 shape. Throws on unknown versions. */
+function migrateSidecar(doc) {
+	if (!doc) return null;
+	if (doc.sidecarVersion === 2) return doc;
+	if (doc.sidecarVersion === 1) {
+		const tracks = {};
+		for (const t of doc.tracks) tracks[t.target] = {
+			type: t.type,
+			baseHash: null,
+			keys: t.keys
+		};
+		const main = { tracks };
+		if (doc.labels) main.labels = doc.labels;
+		return {
+			sidecarVersion: 2,
+			timelines: { [MAIN]: main }
+		};
+	}
+	throw new SidecarVersionError(doc.sidecarVersion);
+}
+/** Stable hash of a code track's keys — the baseline an editor branch records. */
+function hashKeys(keys) {
+	const s = JSON.stringify(keys.map((k) => [
+		k.t,
+		k.value,
+		k.ease ?? null,
+		k.interp ?? null
+	]));
+	let h = 2166136261;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(16);
+}
+/** Assign stable monotonic `k<N>` ids to keys lacking one; existing ids preserved. */
+function assignKeyIds(keys) {
+	let max = -1;
+	for (const k of keys) {
+		const m = k.id ? /^k(\d+)$/.exec(k.id) : null;
+		if (m) max = Math.max(max, Number(m[1]));
+	}
+	return keys.map((k) => k.id ? { ...k } : {
+		...k,
+		id: `k${++max}`
+	});
+}
 /**
-* Editor-edit normalization (§2.7 invariant): a spring-eased key's t is
-* intrinsic — prev.t + spring.duration(cfg) — so after any retime, sort and
-* re-pin spring keys to their predecessors. Dragging a spring key itself
-* therefore snaps back; retiming its predecessor carries it along. Returns a
-* new array. Colliding keys are NUDGED apart (+1ms), never deleted — an
-* editor must not silently destroy keyframe data on an exact-t collision.
+* Set one editable track's keys in the sidecar (§6.2) — the studio write path.
+* `codeBaselineKeys` is the code track this branches from (null = editor-created
+* with no baseline). Keys get stable `k<N>` ids. Returns a new document.
 */
-function normalizeEditedKeys(keys) {
-	const out = keys.map((k) => ({ ...k })).sort((a, b) => a.t - b.t);
-	for (let pass = 0; pass < 2; pass++) {
-		for (let i = 1; i < out.length; i++) {
-			const ease = out[i].ease;
-			if (ease && typeof ease === "object" && ease.kind === "spring") out[i].t = out[i - 1].t + spring.duration(ease);
+function setSidecarTrack(doc, timelineId, target, type, keys, codeBaselineKeys) {
+	const tl = doc.timelines[timelineId] ?? { tracks: {} };
+	const entry = {
+		type,
+		baseHash: codeBaselineKeys ? hashKeys(codeBaselineKeys) : null,
+		keys: assignKeyIds(keys)
+	};
+	return {
+		...doc,
+		timelines: {
+			...doc.timelines,
+			[timelineId]: {
+				...tl,
+				tracks: {
+					...tl.tracks,
+					[target]: entry
+				}
+			}
 		}
-		out.sort((a, b) => a.t - b.t);
-	}
-	for (let i = 1; i < out.length; i++) if (out[i].t <= out[i - 1].t) out[i].t = out[i - 1].t + .001;
-	return out;
+	};
 }
 /**
-* Merge rules (§6.2, schema-drift resolution):
-* - a sidecar track whose target exists in code REPLACES that track's keys
-*   (the editor owns it; `editable` is preserved on the result);
-* - a sidecar track with no code counterpart is ADDED (editor-created track);
-* - sidecar tracks targeting nothing the scene can bind fail later at
-*   bindTimeline with UnboundTargetError — surfaced, never silently dropped;
-* - code tracks without sidecar counterparts pass through untouched.
-* The input documents are not mutated.
+* Re-resolve `derived:true` leading keys against the merged track (§2.6): a
+* derived from-key duplicates the preceding key's held value, so an upstream
+* edit must flow into it or the segment pops at its start. Build-time derived
+* keys are already correct; this fixes the ones an edit moved beneath.
 */
-function mergeSidecar(code, sidecar) {
-	if (!sidecar) return code;
-	if (sidecar.sidecarVersion !== 1) throw new SidecarVersionError(sidecar.sidecarVersion);
-	const overlay = new Map(sidecar.tracks.map((t) => [t.target, t]));
+function reresolveDerived(keys) {
+	if (!keys.some((k) => k.derived)) return keys;
+	return keys.map((k, i) => k.derived && i > 0 ? {
+		...k,
+		value: keys[i - 1].value
+	} : k);
+}
+/**
+* Merge with the full §6.2 report: the bindable Timeline, the list of targets
+* whose code baseline drifted, and the orphaned tracks (type-changed, or whose
+* code track vanished). Orphans are NEVER merged, so a drifted edit can't make
+* the whole overlay fail to bind — the good edits survive. Inputs unmutated.
+*/
+function mergeSidecarDetailed(code, sidecar) {
+	const doc = migrateSidecar(sidecar);
+	if (!doc) return {
+		timeline: code,
+		drift: [],
+		orphans: {}
+	};
+	const main = doc.timelines[MAIN] ?? { tracks: {} };
+	const overlay = new Map(Object.entries(main.tracks));
+	const drift = [];
+	const orphans = { ...main.orphans ?? {} };
 	const tracks = code.tracks.map((t) => {
-		const replacement = overlay.get(t.target);
-		if (!replacement) return t;
+		const entry = overlay.get(t.target);
+		if (!entry) return t;
 		overlay.delete(t.target);
+		if (entry.type !== t.type) {
+			orphans[t.target] = {
+				type: entry.type,
+				keys: entry.keys,
+				reason: "type-changed"
+			};
+			return t;
+		}
+		if (entry.baseHash !== null && entry.baseHash !== hashKeys(t.keys)) drift.push(t.target);
 		return {
 			...t,
-			keys: replacement.keys.map((k) => ({ ...k })),
+			keys: reresolveDerived(entry.keys.map((k) => ({ ...k }))),
 			editable: true
 		};
 	});
-	for (const added of overlay.values()) tracks.push({
-		...added,
-		keys: added.keys.map((k) => ({ ...k })),
+	for (const [target, entry] of overlay) if (entry.baseHash !== null) orphans[target] = {
+		type: entry.type,
+		keys: entry.keys,
+		reason: "prop-missing"
+	};
+	else tracks.push({
+		target,
+		type: entry.type,
+		keys: reresolveDerived(entry.keys.map((k) => ({ ...k }))),
 		editable: true
 	});
 	const merged = {
 		...code,
 		tracks
 	};
-	if (sidecar.labels && Object.keys(sidecar.labels).length > 0) {
+	if (main.labels && Object.keys(main.labels).length > 0) {
 		const codeLabels = code.labels ?? {};
-		const shadowed = Object.keys(sidecar.labels).filter((n) => n in codeLabels);
+		const shadowed = Object.keys(main.labels).filter((n) => n in codeLabels);
 		if (shadowed.length) emitDevWarning(`sidecar label(s) ${shadowed.join(", ")} collide with code labels; code wins (§6.2)`);
 		merged.labels = {
-			...sidecar.labels,
+			...main.labels,
 			...codeLabels
 		};
 	}
-	return merged;
+	if (drift.length) emitDevWarning(`sidecar: code baseline changed beneath edits on ${drift.join(", ")} (§6.2)`);
+	return {
+		timeline: merged,
+		drift,
+		orphans
+	};
+}
+/** Merge the sidecar overlay onto the code baseline → a bindable Timeline (§6.2). */
+function mergeSidecar(code, sidecar) {
+	return mergeSidecarDetailed(code, sidecar).timeline;
+}
+/**
+* Editor-edit normalization (§2.7 invariant): a spring-eased key's t is
+* intrinsic — prev.t + spring.duration(cfg) — so after any retime, sort and
+* re-pin spring keys to their predecessors. Dragging a spring key itself
+* therefore snaps back; retiming its predecessor carries it along. Returns a
+* new array. Colliding keys are NUDGED apart (+1ms), never deleted — an editor
+* must not silently destroy keyframe data on an exact-t collision.
+*/
+function normalizeEditedKeys(keys) {
+	const out = keys.map((k) => ({ ...k })).sort((a, b) => a.t - b.t);
+	for (let pass = 0; pass < 2; pass++) {
+		for (let i = 1; i < out.length; i++) {
+			const ease = out[i].ease;
+			if (ease && typeof ease === "object" && ease.kind === "spring") out[i].t = out[i - 1].t + spring.duration(ease);
+		}
+		out.sort((a, b) => a.t - b.t);
+	}
+	for (let i = 1; i < out.length; i++) if (out[i].t <= out[i - 1].t) out[i].t = out[i - 1].t + .001;
+	return out;
 }
 //#endregion
-export { BakeError, CircularDependencyError, ColorParseError, DEFAULT_EASE, PositionError, SidecarVersionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, audioOffsetSamples, bake, bakeCheckpointed, beginReadPhase, bindTimeline, booleanType, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, key, lerpColor, mergeSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, timeline, track, untracked, validateTrack, vec2Equals, vec2Signal, vec2Type, velocityAt };
+export { BakeError, CircularDependencyError, ColorParseError, DEFAULT_EASE, PositionError, SidecarVersionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, beginReadPhase, bindTimeline, booleanType, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, cubicBezierDerivative, easingDerivatives, easings, emitDevWarning, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, hashKeys, inReadPhase, inferValueType, key, lerpColor, mergeSidecar, mergeSidecarDetailed, migrateSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setSidecarTrack, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, timeline, track, untracked, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/core",
-  "version": "0.7.0-pre.0",
+  "version": "0.8.0-pre.0",
   "description": "glissade core: signals, tracks, timeline document, evaluation, easing, springs, seeded RNG. Zero DOM/Node dependencies.",
   "license": "Apache-2.0",
   "type": "module",