@glissade/core 0.8.1 → 0.9.0-pre.1

package/dist/index.d.ts

@@ -1,4 +1,7 @@
+import { $ as validateTrack, A as GainEnvelope, At as pathType, B as emitDevWarning, C as resolveTweenTarget, Ct as ValueTypeInferenceError, D as ChildEntry, Dt as getValueType, E as AudioClip, Et as colorType, F as TimelineValidationError, Ft as vec2Type, G as TrackValidationError, H as Key, I as audioOffsetSamples, J as resolveEaseDerivative, K as key, L as compileTimeline, M as Marker, Mt as stringType, N as Timeline, Nt as vec2ArcType, O as CompiledTimeline, Ot as inferValueType, P as TimelineInit, Pt as vec2Equals, Q as track, R as isDurationEditable, S as isEditableNodeId, St as ValueTypeId, T as AssetRef, Tt as booleanType, U as KeyOpts, V as setDevWarning, W as Track, X as springTo, Y as sampleTrack, Z as stagger, _ as setSidecarTrack, _t as HandoffKind, a as SidecarOrphan, at as springEasing, b as TweenTarget, bt as UnknownValueTypeError, c as SidecarVersionError, ct as DEFAULT_EASE, d as emptySidecar, dt as UnknownEasingError, et as velocityAt, f as hashKeys, ft as cubicBezier, g as normalizeEditedKeys, gt as namedEasing, h as migrateSidecar, ht as easings, i as SidecarDocV1, it as spring, j as Json, jt as registerValueType, k as FontFaceRef, kt as numberType, l as assignKeyIds, lt as EaseSpec, m as mergeSidecarDetailed, mt as easingDerivatives, n as OrphanReason, nt as SpringConfig, o as SidecarTimelineEntry, ot as springEasingDerivative, p as mergeSidecar, pt as cubicBezierDerivative, q as resolveEase, r as SidecarDoc, rt as SpringEase, s as SidecarTrackEntry, st as springPresets, t as MergeResult, tt as RetargetSpring, u as deleteSidecarTrack, ut as EasingFn, v as TARGET_PATH, vt as PathContour, w as targetNodeId, wt as Vec2, x as UnresolvableTargetError, xt as ValueType, y as TargetCarrier, yt as PathValue, z as DevWarning } from "./sidecar.js";
+
 //#region src/signal.d.ts
+
 /**
  * Pull-based reactive signals: lazy, cached, dependency-tracked (DESIGN.md §2.1).
  *
@@ -42,69 +45,6 @@ declare function computed<T>(fn: () => T, options?: SignalOptions<T>): ReadonlyS
 /** Run `fn` without registering dependencies on the active consumer. */
 declare function untracked<T>(fn: () => T): T;
 //#endregion
-//#region src/valueTypes.d.ts
-/**
- * Value-type registry with pluggable per-type interpolation (DESIGN.md §2.2).
- * `extrapolates` declares whether a type's lerp accepts easedT outside [0,1]
- * (spring overshoot); non-extrapolating types clamp.
- */
-type Vec2 = readonly [number, number];
-/** One bezier contour in Lottie's vertex form: anchor points + RELATIVE in/out tangents. */
-interface PathContour {
-  closed: boolean;
-  v: Vec2[];
-  in: Vec2[];
-  out: Vec2[];
-}
-/** The 'path' document value (§2.2): plain JSON, serializes with no new hooks. */
-type PathValue = PathContour[];
-/** Transition handoff policies (v2 addendum §A.4/§B.1); 'crossfade' reserved. */
-type HandoffKind = 'cut' | 'decay' | 'spring' | 'blend-from-frozen';
-interface ValueType<T> {
-  id: string;
-  lerp(a: T, b: T, t: number): T;
-  /** Accepts easedT outside [0,1] (spring overshoot)? Otherwise clamped. */
-  extrapolates: boolean;
-  equals(a: T, b: T): boolean;
-  /** Optional linear-space operators (offset decay + reserved additive blending, §B.6). */
-  add?(a: T, b: T): T;
-  sub?(a: T, b: T): 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;
-declare class UnknownValueTypeError extends Error {
-  constructor(id: string);
-}
-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>;
-/**
- * Path morphing (§2.2): pairwise lerp of anchors and tangents — exactly how
- * lottie-web morphs, so imported animations are pixel-faithful. Mismatched
- * topology snaps (hold a, then b at t ≥ 1) with a one-time dev warning; the
- * de Casteljau normalization fallback for arbitrary native morphs is tracked
- * future work. Lerp-only: offsets are not well-defined under mismatched
- * topology, so no add/sub/scale — handoffs blend from the frozen value.
- */
-declare const pathType: ValueType<PathValue>;
-declare class ValueTypeInferenceError extends Error {
-  constructor(value: unknown);
-}
-/** Infer a registered type id from a sample value (builder + bake authoring surfaces). */
-declare function inferValueType(value: unknown): ValueTypeId;
-//#endregion
 //#region src/vec2Signal.d.ts
 interface Vec2Signal extends ReadonlySignal<Vec2> {
   readonly x: BindableSignal<number>;
@@ -119,133 +59,6 @@ declare function vec2Signal(initial: Vec2 | {
   y: number;
 }): Vec2Signal;
 //#endregion
-//#region src/easing.d.ts
-/**
- * Easing registry + cubic bézier (DESIGN.md §2.2). All functions map [0,1]→ℝ
- * with f(0)=0 and f(1)=1; back/elastic intentionally leave [0,1].
- */
-type EasingFn = (t: number) => number;
-type EaseSpec = string | {
-  kind: 'cubicBezier';
-  pts: [number, number, number, number];
-} | {
-  kind: 'spring';
-  stiffness: number;
-  damping: number;
-  mass: number;
-};
-declare const easings: Record<string, EasingFn>;
-/**
- * Analytic derivatives d(u) of every named ease (§B.6) — closed-form, used
- * for reading velocity off in-flight curves at interruption time. Property-
- * tested against central differences at interior points.
- */
-declare const easingDerivatives: Record<string, EasingFn>;
-/** Default property-tween ease (Motion Canvas precedent). */
-declare const DEFAULT_EASE = "easeInOutCubic";
-/**
- * CSS-style cubic bézier where x is time and y is progress. Newton's method
- * with a bisection fallback for the flat-derivative regions.
- */
-declare function cubicBezier(p1x: number, p1y: number, p2x: number, p2y: number): EasingFn;
-/** Analytic dy/dx of a cubic bézier ease: y'(s)/x'(s) at the solved parameter (§B.6). */
-declare function cubicBezierDerivative(p1x: number, p1y: number, p2x: number, p2y: number): EasingFn;
-declare class UnknownEasingError extends Error {
-  constructor(name: string);
-}
-declare function namedEasing(name: string): EasingFn;
-//#endregion
-//#region src/spring.d.ts
-interface SpringConfig {
-  stiffness: number;
-  damping: number;
-  mass?: number;
-}
-interface SpringEase {
-  kind: 'spring';
-  stiffness: number;
-  damping: number;
-  mass: number;
-}
-/**
- * Settle duration: the earliest time after which |x - 1| stays within
- * settleTolerance. Closed-form via the decay envelope for the underdamped
- * case; bisection on the monotone tail otherwise. Deterministic.
- */
-declare function duration(cfg: SpringConfig, opts?: {
-  settleTolerance?: number;
-}): number;
-/**
- * Spring progress at local time t, affinely rescaled so value(duration) = 1
- * exactly — the raw form only approaches 1, and an unscaled curve would snap
- * at the key (§2.7 "endpoint continuity"). May exceed 1 (overshoot).
- */
-declare function value(cfg: SpringConfig, t: number, opts?: {
-  settleTolerance?: number;
-}): number;
-/**
- * Velocity-matched retarget oscillator (v2 addendum §B.3): the same damped
- * harmonic oscillator on an OFFSET in value units with nonzero initial
- * velocity — y(0)=x0, y'(0)=v0, decaying to 0. No affine rescale (the target
- * is exactly 0). Pure closed forms; seek-safe at any τ.
- */
-interface RetargetSpring {
-  value(tau: number): number;
-  velocity(tau: number): number;
-  /** Earliest τ after which |value| stays within tol (default 0.005·|x0|+1e-6 floor). */
-  settleTime(tol?: number): number;
-}
-declare function retarget(cfg: SpringConfig, x0: number, v0: number): RetargetSpring;
-interface SpringFactory {
-  (cfg: SpringConfig): SpringEase;
-  duration: typeof duration;
-  value: typeof value;
-  retarget: typeof retarget;
-}
-declare const spring: SpringFactory;
-/**
- * Named spring feels (react-spring conventions, mass 1) — a vocabulary instead
- * of hand-tuned stiffness/damping. Use `spring(springPresets.wobbly)` or
- * `springTo(t, a, b, springPresets.gentle)`.
- */
-declare const springPresets: {
-  readonly default: {
-    readonly stiffness: 170;
-    readonly damping: 26;
-  };
-  readonly gentle: {
-    readonly stiffness: 120;
-    readonly damping: 14;
-  };
-  readonly wobbly: {
-    readonly stiffness: 180;
-    readonly damping: 12;
-  };
-  readonly stiff: {
-    readonly stiffness: 210;
-    readonly damping: 20;
-  };
-  readonly slow: {
-    readonly stiffness: 280;
-    readonly damping: 60;
-  };
-  readonly molasses: {
-    readonly stiffness: 280;
-    readonly damping: 120;
-  };
-};
-/**
- * The spring as a normalized easing over a segment whose length must equal
- * spring.duration(cfg) (validated at the document layer, §2.7).
- */
-declare function springEasing(cfg: SpringConfig): EasingFn;
-/**
- * Analytic d/dp of springEasing (§B.6): oscillator derivative × the affine
- * rescale factor × duration (chain rule p → t = p·D). Flat past p=1,
- * matching value()'s clamp (right-derivative convention).
- */
-declare function springEasingDerivative(cfg: SpringConfig): EasingFn;
-//#endregion
 //#region src/color.d.ts
 /**
  * Minimal color support for tracks: hex/rgb(a) parsing, OKLab interpolation
@@ -274,194 +87,87 @@ declare function oklabToRgba(c: OkLab): Rgba;
 /** Interpolate two CSS color strings in OKLab; t may extrapolate. */
 declare function lerpColor(from: string, to: string, t: number): string;
 //#endregion
-//#region src/track.d.ts
-interface Key<T = unknown> {
-  t: number;
-  value: T;
-  /** Shape of the segment ARRIVING at this key (from the previous key). */
-  ease?: EaseSpec;
-  interp?: 'default' | 'hold';
-  /** Stable key id (studio-assigned); optional in code-authored documents. */
-  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'. */
-  target: string;
-  type: ValueTypeId;
-  /** Sorted by t; enforced by validateTrack(). */
-  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);
-}
-declare function validateTrack(track: Track): void;
-type KeyOpts<T> = Partial<Omit<Key<T>, 't' | 'value'>>;
-declare function key<T>(t: number, value: T, easeOrOpts?: EaseSpec | KeyOpts<T>): Key<T>;
-/**
- * The settle-ON-the-beat helper: a spring key must sit at prev.t +
- * spring.duration(cfg) (§2.7), so beat-anchored authoring otherwise means
- * hand-computing the launch time. springTo returns the [launch, settle] key
- * pair with the arithmetic done — spread it into a raw track():
- *   track('x/width', 'number', [...springTo(beats.start('drop'), 0, 320, cfg)])
- */
-declare function springTo<T>(endT: number, from: T, to: T, cfg: SpringConfig): [Key<T>, Key<T>];
-/**
- * Cascade a set of tracks by shifting each one's key times — the classic
- * stagger for animating a list of nodes with a delay between them. `delay` is
- * the per-index gap in seconds, or a function of the index for non-linear
- * cascades. Pure: returns new tracks, leaving the inputs untouched.
- *
- *   stagger(items.map((it, i) => track(`${it.id}/opacity`, 'number',
- *     [key(0, 0), key(0.3, 1, 'easeOutCubic')])), 0.08)
- */
-declare function stagger<T>(tracks: readonly Track<T>[], delay: number | ((index: number) => number)): Track<T>[];
-declare function track<T>(target: string, type: ValueTypeId, keys: Key<T>[], opts?: {
-  editable?: boolean;
-}): Track<T>;
-declare function resolveEase(spec: EaseSpec | undefined): EasingFn;
-/**
- * Analytic d(u) for an ease spec (§B.6). Custom-registered eases without a
- * derivative fall back to a symmetric difference with a one-time dev warning.
- */
-declare function resolveEaseDerivative(spec: EaseSpec | undefined): EasingFn;
-/**
- * Analytic track derivative at time t, in value-units per second of local
- * track time (v2 addendum §B.3/§B.6 conventions, pinned):
- * (a) at a key boundary, velocity is the RIGHT derivative;
- * (b) hold segments and the clamped regions outside the keys have v = 0;
- * (c) types without sub/scale operators return null (no kinetic velocity).
- */
-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
-//#region src/devWarning.d.ts
-/** The configurable dev-warning channel (no DOM lib in core; console may not exist). */
-type DevWarning = (message: string) => void;
-declare function setDevWarning(fn: DevWarning): void;
-/** Internal: emit through the configurable channel. */
-declare function emitDevWarning(message: string): void;
-//#endregion
-//#region src/timeline.d.ts
-type Json = null | boolean | number | string | Json[] | {
-  [k: string]: Json;
-};
-interface Marker {
-  t: number;
-  name: string;
-  data?: Json;
-}
-interface AssetRef {
-  kind: 'font' | 'image' | 'audio' | 'video' | 'timeline';
+//#region src/fontRegistry.d.ts
+/** A concrete, fully-resolved face: family + the URL to load it from. */
+interface ResolvedFace {
+  family: string;
   url: string;
-}
-/**
- * A gain envelope: keys of linear gain multipliers on the clip's local time
- * axis. A full Track satisfies it structurally, but its target/type carry no
- * meaning here — `{ keys: [...] }` is all a clip needs.
- */
-interface GainEnvelope {
-  keys: Key[];
-}
-/** Audio is timeline metadata, never a render product (§5.3). */
-interface AudioClip {
-  asset: AssetRef;
-  /** timeline seconds (frame-quantized at export via sample-position arithmetic) */
-  at: number;
-  /** seconds within the source asset */
-  trim?: {
-    start: number;
-    end: number;
-  };
-  gain?: GainEnvelope;
-  playbackRate?: number;
-}
-interface ChildEntry {
-  timeline: Timeline;
-  /** Offset on the parent time axis. */
-  at: number;
+  weight: number;
+  style: 'normal' | 'italic';
+}
+interface FontRegistry {
+  /** true iff `family` was declared as a font asset (case-sensitive, §3.6). */
+  has(family: string): boolean;
+  /** Every declared face across every family — what the loaders register. */
+  faces(): ResolvedFace[];
   /**
-   * 'add': flattened at compile time into the parent's track space.
-   * 'sync': opaque sub-timeline with its own clock (parent t maps through
-   * at/timeScale); never coalesced against parent tracks.
+   * CSS nearest-weight matching within `family` (and the requested style when
+   * an exact style match exists), or undefined when the family is unregistered.
    */
-  mode: 'add' | 'sync';
-  /** sync-mode only: child plays at this rate. */
-  timeScale?: number;
-}
-interface Timeline {
-  version: 1;
-  duration?: number;
-  fps?: number;
-  posterTime?: number;
-  tracks: Track[];
-  labels?: Record<string, number>;
-  markers?: Marker[];
-  children?: ChildEntry[];
-  audio?: AudioClip[];
-  assets?: Record<string, AssetRef>;
-}
-interface TimelineInit {
-  tracks?: Track[];
-  duration?: number;
-  fps?: number;
-  posterTime?: number;
-  labels?: Record<string, number>;
-  markers?: Marker[];
-  children?: ChildEntry[];
-  audio?: AudioClip[];
-  assets?: Record<string, AssetRef>;
-}
-declare class TimelineValidationError extends Error {
-  constructor(message: string);
-}
-interface CompiledTimeline {
-  duration: number;
-  labels: Record<string, number>;
-  markers: Marker[];
-  /** One track per target (§2.2), keys rebased to the root time axis. */
-  tracks: Map<string, Track>;
-  /** Audio clips rebased to the root time axis (§5.3); sync timeScale scales playbackRate. */
-  audio: AudioClip[];
+  resolveFace(family: string, weight?: number, style?: 'normal' | 'italic'): ResolvedFace | undefined;
+  /** `[family, ...declaredFallback]` — the order glyph coverage walks. */
+  fallbackChain(family: string): string[];
 }
+declare function buildFontRegistry(assets?: Record<string, AssetRef> | undefined): FontRegistry;
+//#endregion
+//#region src/cmap.d.ts
 /**
- * Sample-indexed clip offset — the single A/V-sync source of truth (§5.3),
- * `round(at * sampleRate)`. Both the CLI (FFmpeg) and the browser
- * (OfflineAudioContext) mixers derive their delay from this, so A/V offsets
- * agree across paths by construction rather than one rounding to milliseconds
- * and the other to raw float seconds. Default rate is the canonical mix grid.
+ * Minimal sfnt `cmap` reader (DESIGN.md §3.6 glyph-coverage check) — pure,
+ * byte-only, ZERO DOM / ZERO Node. Given the raw bytes of a TrueType/OpenType
+ * (or the first table of a TTC) font, returns the set of Unicode code points
+ * the font claims to cover. I/O (reading the file / fetching the URL) happens
+ * at the call site; this function only parses bytes.
+ *
+ * Hand-rolled (no font-parsing dependency) to keep core zero-dep and in budget.
+ * It covers the two cmap subtable formats that matter in practice:
+ *   - format 4  (segment mapping to delta values — the BMP workhorse)
+ *   - format 12 (segmented coverage — astral planes, e.g. emoji)
+ * Malformed or unsupported input yields an empty set; it never throws or hangs.
  */
-declare function audioOffsetSamples(at: number, sampleRate?: number): number;
-declare function compileTimeline(doc: Timeline): CompiledTimeline;
+declare function parseCmap(bytes: ArrayBuffer): Set<number>;
 //#endregion
-//#region src/targetRef.d.ts
+//#region src/fontValidation.d.ts
+type FontMode = 'strict' | 'dev';
+/** One text usage to validate: a family and the (full, un-revealed) text. */
+interface FontUsage {
+  family: string;
+  text: string;
+}
+interface MissingGlyphs {
+  family: string;
+  /** the uncovered code points, ascending, de-duplicated */
+  codePoints: number[];
+}
+interface CoverageReport {
+  /** non-generic, unregistered families referenced by Text content */
+  unregistered: string[];
+  /** per-family code points no face in the family's chain covers */
+  missingGlyphs: MissingGlyphs[];
+}
+declare class FontValidationError extends Error {
+  readonly report: CoverageReport;
+  constructor(report: CoverageReport);
+}
 /**
- * Target references (DESIGN.md §2.6): the builder accepts either a canonical
- * target string ('circle/opacity') or a property signal that carries its own
- * path — attached by the scene package at node construction via TARGET_PATH.
+ * Is `family` exempt from the unregistered-family check? Generics are exempt by
+ * the spec; an `osFamilies` allowlist lets a caller mark OS-installed families
+ * (which the rasterizer can resolve without registration) as exempt too.
  */
-declare const TARGET_PATH: unique symbol;
-interface TargetCarrier {
-  [TARGET_PATH]?: string;
+declare function isExemptFamily(family: string, osFamilies?: ReadonlySet<string>): boolean;
+interface ValidateFontsOptions {
+  /** OS-installed families to treat as registered (lowercased). */
+  osFamilies?: ReadonlySet<string> | undefined;
 }
 /**
- * A target string, or any object carrying TARGET_PATH (property signals of
- * id-bearing nodes). Typed as `object` because signals are callables and the
- * symbol prop is attached dynamically; resolution is checked at build time.
+ * Validate `usages` against `registry`. `cmaps` maps family → covered code
+ * points (already parsed via parseCmap by the caller's I/O). A family with no
+ * cmap entry contributes no coverage (its glyphs all count as missing) unless
+ * it is exempt or its chain reaches a covered family.
+ *
+ * Returns the report. In `'strict'` mode it throws FontValidationError when the
+ * report is non-empty; in `'dev'` mode it emits a dev warning instead.
  */
-type TweenTarget = string | object;
-declare class UnresolvableTargetError extends Error {
-  constructor();
-}
-declare function resolveTweenTarget(target: TweenTarget): string;
+declare function validateFonts(usages: readonly FontUsage[], registry: FontRegistry, cmaps: ReadonlyMap<string, ReadonlySet<number>>, mode: FontMode, options?: ValidateFontsOptions): CoverageReport;
 //#endregion
 //#region src/builder.d.ts
 type Position = number | string;
@@ -501,6 +207,12 @@ interface TimelineBuilder {
   }): TimelineBuilder;
   /** Mark the preceding track editable for the studio (§6.2). */
   editable(): TimelineBuilder;
+  /**
+   * Opt the timeline duration into studio editing (§6.2 rule 4). Duration is
+   * code-owned and read-only in the editor by default; this mirrors
+   * `.editable()` for the duration itself. Order-independent within the chain.
+   */
+  editableDuration(): TimelineBuilder;
 }
 declare class PositionError extends Error {
   constructor(pos: string, detail: string);
@@ -592,79 +304,4 @@ 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;
-  tracks: Track[];
-  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.
- */
-declare function normalizeEditedKeys(keys: Key[]): Key[];
-//#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 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 };
+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 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 HandoffKind, type Json, type Key, type KeyOpts, type Marker, type MergeResult, type MissingGlyphs, type OkLab, type OrphanReason, type PathContour, type PathValue, type Playhead, type Position, PositionError, type ReadonlySignal, type ResolvedFace, 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 ValidateFontsOptions, type ValueType, type ValueTypeId, ValueTypeInferenceError, type Vec2, type Vec2Signal, WriteDuringEvaluationError, assignKeyIds, audioOffsetSamples, bake, bakeCheckpointed, 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, parseCmap, parseColor, pathType, random, registerValueType, resolveEase, resolveEaseDerivative, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, setSidecarTrack, signal, spring, springEasing, springEasingDerivative, springPresets, springTo, stagger, stringType, targetNodeId, timeline, track, untracked, validateFonts, validateTrack, vec2ArcType, vec2Equals, vec2Signal, vec2Type, velocityAt };