lecodes-sdk 0.20.2 → 1.1.0

package/dist/global.d.ts

@@ -28,11 +28,14 @@ declare global {
   const Color: typeof SDK.Color
   const DateValue: typeof SDK.DateValue
   const DecalSet: typeof SDK.DecalSet
+  const DecalTrail: typeof SDK.DecalTrail
+  const DynamicBone: typeof SDK.DynamicBone
+  const DynamicBoneCollider: typeof SDK.DynamicBoneCollider
   const Feet: typeof SDK.Feet
   const File: typeof SDK.File
+  const Foliage: typeof SDK.Foliage
   const FollowPath: typeof SDK.FollowPath
   const FormData: typeof SDK.FormData
-  const Gearbox: typeof SDK.Gearbox
   const Geolocation: typeof SDK.Geolocation
   const Geometry: typeof SDK.Geometry
   const Gizmos: typeof SDK.Gizmos
@@ -108,6 +111,8 @@ declare global {
   const Tilemap: typeof SDK.Tilemap
   const Tileset: typeof SDK.Tileset
   const Time: typeof SDK.Time
+  const Timeline: typeof SDK.Timeline
+  const Tire: typeof SDK.Tire
   const TouchStartEvent: typeof SDK.TouchStartEvent
   const Trail: typeof SDK.Trail
   const Trigger: typeof SDK.Trigger
@@ -160,7 +165,6 @@ declare global {
   const __uiMap: typeof SDK.__uiMap
   const __withGizmoScope: typeof SDK.__withGizmoScope
   const animate: typeof SDK.animate
-  const animateMat4: typeof SDK.animateMat4
   const app: typeof SDK.app
   const audio: typeof SDK.audio
   const cells: typeof SDK.cells
@@ -193,20 +197,18 @@ declare global {
   const openFilePicker: typeof SDK.openFilePicker
   const openURL: typeof SDK.openURL
   const packTile: typeof SDK.packTile
-  const pauseAnimation: typeof SDK.pauseAnimation
   const rawCell: typeof SDK.rawCell
   const rawIndex: typeof SDK.rawIndex
   const ref: typeof SDK.ref
   const registerEditorTool: typeof SDK.registerEditorTool
   const registerEditorWindow: typeof SDK.registerEditorWindow
   const registerFont: typeof SDK.registerFont
-  const resumeAnimation: typeof SDK.resumeAnimation
+  const resolveTire: typeof SDK.resolveTire
   const rot180: typeof SDK.rot180
   const rot270: typeof SDK.rot270
   const rot90: typeof SDK.rot90
   const share: typeof SDK.share
   const signal: typeof SDK.signal
-  const stopAnimation: typeof SDK.stopAnimation
   const theme: typeof SDK.theme
   const tileFlip: typeof SDK.tileFlip
   const tileIndex: typeof SDK.tileIndex
@@ -217,6 +219,10 @@ declare global {
   type ARScene<T extends ARMode = "default"> = SDK.ARScene<T>
   type ActiveClip = SDK.ActiveClip
   type AeroConfig = SDK.AeroConfig
+  type AnimateOptions<T extends AnimateValue> = SDK.AnimateOptions<T>
+  type AnimateOut<T> = SDK.AnimateOut<T>
+  type AnimateValue = SDK.AnimateValue
+  type Animation = SDK.Animation
   type AnimationClip = SDK.AnimationClip
   type Animator = SDK.Animator
   type AppState = SDK.AppState
@@ -267,9 +273,17 @@ declare global {
   type DecalSet = SDK.DecalSet
   type DecalSetOptions = SDK.DecalSetOptions
   type DecalSpawnOptions = SDK.DecalSpawnOptions
+  type DecalTrail = SDK.DecalTrail
+  type DecalTrailOptions = SDK.DecalTrailOptions
   type DifferentialMode = SDK.DifferentialMode
   type Displacement = SDK.Displacement
   type DriveLayout = SDK.DriveLayout
+  type DynamicBone = SDK.DynamicBone
+  type DynamicBoneCollider = SDK.DynamicBoneCollider
+  type DynamicBoneColliders = SDK.DynamicBoneColliders
+  type DynamicBoneCurve = SDK.DynamicBoneCurve
+  type DynamicBoneFloor = SDK.DynamicBoneFloor
+  type EasingInput = SDK.EasingInput
   type EchoParams = SDK.EchoParams
   type EdgeSlot = SDK.EdgeSlot
   type EditorApi = SDK.EditorApi
@@ -286,13 +300,14 @@ declare global {
   type FileData = SDK.FileData
   type FillBlock = SDK.FillBlock
   type FitOptions = SDK.FitOptions
+  type FoliageOptions = SDK.FoliageOptions
+  type FoliageWind = SDK.FoliageWind
   type FollowPath = SDK.FollowPath
   type FootState = SDK.FootState
   type FormData = SDK.FormData
   type Gait = SDK.Gait
   type GamepadAxisName = SDK.GamepadAxisName
   type GamepadState = SDK.GamepadState
-  type Gearbox = SDK.Gearbox
   type GeoOptions = SDK.GeoOptions
   type GeoPosition = SDK.GeoPosition
   type GeoWatch = SDK.GeoWatch
@@ -407,6 +422,7 @@ declare global {
   type PlayOptions = SDK.PlayOptions
   type PlaySoundOptions = SDK.PlaySoundOptions
   type Playback = SDK.Playback
+  type Point = SDK.Point
   type PresentOptions = SDK.PresentOptions
   type Presentable = SDK.Presentable
   type PushEvent = SDK.PushEvent
@@ -416,7 +432,11 @@ declare global {
   type QRScanner = SDK.QRScanner
   type Quat = SDK.Quat
   type Ragdoll = SDK.Ragdoll
+  type RagdollActivateOptions = SDK.RagdollActivateOptions
+  type RagdollDeactivateOptions = SDK.RagdollDeactivateOptions
+  type RagdollFacing = SDK.RagdollFacing
   type RagdollHinge = SDK.RagdollHinge
+  type RagdollHitOptions = SDK.RagdollHitOptions
   type RagdollPart = SDK.RagdollPart
   type Ray = SDK.Ray
   type Replicated = SDK.Replicated
@@ -460,6 +480,8 @@ declare global {
   type StateMachineEvents = SDK.StateMachineEvents
   type StatesDef<C> = SDK.StatesDef<C>
   type SteeringConfig = SDK.SteeringConfig
+  type SteeringDriver = SDK.SteeringDriver
+  type SteeringFeedback = SDK.SteeringFeedback
   type StepHandler = SDK.StepHandler
   type StepWarpOptions = SDK.StepWarpOptions
   type StopOptions = SDK.StopOptions
@@ -485,15 +507,21 @@ declare global {
   type TilemapSourceDef = SDK.TilemapSourceDef
   type Tileset = SDK.Tileset
   type TilesetDef = SDK.TilesetDef
-  type TireCurve = SDK.TireCurve
+  type Timeline = SDK.Timeline
+  type TimelineAddOptions = SDK.TimelineAddOptions
+  type TimelineOptions = SDK.TimelineOptions
+  type TimelinePosition = SDK.TimelinePosition
+  type Tire = SDK.Tire
   type TouchStartEvent<T = any> = SDK.TouchStartEvent<T>
   type Trail = SDK.Trail
   type Transition = SDK.Transition
   type TransitionName = SDK.TransitionName
   type TransitionSpec = SDK.TransitionSpec
   type TransitionTransform = SDK.TransitionTransform
+  type TrianglePick = SDK.TrianglePick
   type Trigger = SDK.Trigger
   type Trigger2D = SDK.Trigger2D
+  type TweenMeta = SDK.TweenMeta
   type UIBottomSheet = SDK.UIBottomSheet
   type UIBottomSheetStyle = SDK.UIBottomSheetStyle
   type UIBox = SDK.UIBox
@@ -546,8 +574,6 @@ declare global {
   type WebSocket = SDK.WebSocket
   type Wheel = SDK.Wheel
   type WheelSuspension = SDK.WheelSuspension
-  type WheelTire = SDK.WheelTire
-  type WheelVisual = SDK.WheelVisual
   type With<N, A extends Aspect<any, any, any>> = SDK.With<N, A>
   type __GizmoBuffer = SDK.__GizmoBuffer
   // ---- server globals (available in *.server.ts; using them in client code is a build error) ----

package/dist/types/animate/tween/Animation.d.ts

@@ -0,0 +1,69 @@
+import { CLOCK_GAME, CLOCK_UI, type TweenSpec } from "./spec";
+/** Playback control shared by element tweens and timelines. Times are **milliseconds**. */
+export interface Animation {
+    /** One iteration, ms. */
+    readonly duration: number;
+    /** Position inside the current iteration, ms. Writable = seek. */
+    time: number;
+    /** 0..1 of the whole animation (iterations included). Writable = seek. */
+    progress: number;
+    /** Playback rate; negative runs backwards, 0 freezes. */
+    rate: number;
+    readonly playing: boolean;
+    /** Resolves `true` when the animation reaches its end, `false` when cancelled, replaced or replayed. Never rejects. */
+    readonly finished: Promise<boolean>;
+    /** Start from t = 0 (a running animation restarts). */
+    play(): this;
+    pause(): this;
+    resume(): this;
+    /** Jump to `ms`; playback state is unchanged. */
+    seek(ms: number): this;
+    /** Jump to the end: values land, commits apply, `finished` resolves `true`. */
+    finish(): this;
+    /** Stop where it is — no commit, `finished` resolves `false`. */
+    cancel(): this;
+    onFinish(fn: (done: boolean) => void): this;
+}
+/** The concrete handle — what the SDK instantiates behind `animateTo` / `animateFrom` / `Timeline`.
+ *  User code sees the {@link Animation} interface; the class itself must stay in the public
+ *  declarations because `TimelineImpl` extends it — marking it internal (even mentioning the tag in
+ *  this comment: the strip is a substring match) drops the timeline's playback members. */
+export declare class TweenAnimation implements Animation {
+    private _id;
+    private _started;
+    private _endTime;
+    private _playing;
+    private _rate;
+    private _finished;
+    private _resolve;
+    private _settled;
+    private _listeners;
+    private _fb?;
+    constructor(spec: TweenSpec);
+    private _newPromise;
+    private _settle;
+    get duration(): number;
+    get playing(): boolean;
+    get finished(): Promise<boolean>;
+    get rate(): number;
+    set rate(r: number);
+    get time(): number;
+    set time(ms: number);
+    get progress(): number;
+    set progress(p: number);
+    private _totalMs;
+    private _elapsedMs;
+    private _seekTotal;
+    /** Create the host animation (paused at t = 0) if it doesn't exist. */
+    private _ensure;
+    private _destroy;
+    play(): this;
+    pause(): this;
+    resume(): this;
+    seek(ms: number): this;
+    finish(): this;
+    cancel(): this;
+    onFinish(fn: (done: boolean) => void): this;
+    private _ensureFallback;
+}
+export { CLOCK_UI, CLOCK_GAME };

package/dist/types/animate/tween/Timeline.d.ts

@@ -0,0 +1,55 @@
+import { TweenAnimation } from "./Animation";
+import { type AnimateOptions, type AnimateValue } from "./animateValue";
+import { type TweenMeta, type TweenTarget } from "./spec";
+export type TimelineOptions = {
+    /** `'ui'` (default) = wall time; `'game'` follows `Time.scale` and pauses with the game. */
+    clock?: "ui" | "game";
+    /** Repeat the whole timeline: `true` = forever, a number = cycles. */
+    loop?: boolean | number;
+    loopMode?: "restart" | "ping-pong";
+    /** Wait before the first play, ms. */
+    delay?: number;
+};
+/** Where a track goes: ms, a label, or `[label, offsetMs]`. Default = the current end (sequencing). */
+export type TimelinePosition = number | string | [string, number];
+export type TimelineAddOptions = {
+    at?: TimelinePosition;
+    /** With several targets: each starts this many ms after the previous one. */
+    stagger?: number;
+};
+/** A choreography: tracks on many targets at absolute times, JS calls, labels and holds, driven by
+ *  one clock. Build it once, `play()` on every entrance — `play()` restarts from t = 0 and the pose
+ *  at any time is fully defined by the tracks (the first keyframe of a track holds before it
+ *  starts, the last one after it ends). */
+export declare class TimelineImpl extends TweenAnimation {
+    private _labels;
+    private _end;
+    constructor(options?: TimelineOptions);
+    private _at;
+    private _grow;
+    /** Animate `props` on one target or several (staggered), like `animateTo` — arrays are keyframes,
+     *  `duration` / `easing` / `times` / `commit` apply. The bag's `delay` shifts the track after `at`. */
+    add(target: TweenTarget | TweenTarget[], props: Record<string, unknown> & TweenMeta, options?: TimelineAddOptions): this;
+    /** Like `add` with the `animateFrom` shape: the target's own state is the implicit last keyframe. */
+    addFrom(target: TweenTarget | TweenTarget[], props: Record<string, unknown> & TweenMeta, options?: TimelineAddOptions): this;
+    /** A free-value track (see the `animate()` global): the host evaluates it and calls `onUpdate`
+     *  every frame with the value. */
+    animate<T extends AnimateValue>(options: AnimateOptions<T>, at?: TimelinePosition): this;
+    /** Call `fn` when playback crosses `at` (forward or backward), in time order, always before
+     *  finish, never from a previous run. */
+    call(at: TimelinePosition, fn: () => void): this;
+    /** Name a time — for `at`, `seek` and callers (`tl.labels.landed`). Default = the current end. */
+    label(name: string, at?: TimelinePosition): this;
+    /** Named times, ms. */
+    get labels(): Record<string, number>;
+    /** Extend the timeline with stillness after its current end. */
+    hold(ms: number): this;
+    /** The current end, ms (tracks, calls and holds). */
+    get end(): number;
+    /** `seek` also accepts a label. */
+    seek(at: number | string): this;
+}
+/** The timeline handle type (see {@link TimelineImpl} for the members). */
+export type Timeline = TimelineImpl;
+/** Create a timeline — `Timeline()` / `Timeline({ clock: 'game', loop: true })`. */
+export declare function Timeline(options?: TimelineOptions): Timeline;

package/dist/types/animate/tween/animateValue.d.ts

@@ -0,0 +1,27 @@
+import { type Animation } from "./Animation";
+import type { Vec2Like, Vec3Like } from "../../math/vec";
+import type { QuatLike } from "../../math/quat";
+import type { Mat4Like } from "../../math/mat4";
+import type { ColorInput } from "../../core/color";
+import { type TweenMeta } from "./spec";
+/** What `animate()` tweens: a number, a color (string / packed / rgb(a) array — delivered as rgba
+ *  0..1), a 2 / 3-vector, a quaternion (slerp), or a 4x4 matrix (position / rotation / scale). */
+export type AnimateValue = number | string | Vec2Like | Vec3Like | QuatLike | Mat4Like | ColorInput;
+/** `onUpdate` receives a number for a number; every other kind arrives as the SAME `Float32Array`
+ *  every frame (overwritten in place — copy it if you keep it). A matrix is the 16 floats. */
+export type AnimateOut<T> = T extends number ? number : Float32Array;
+export type AnimateOptions<T extends AnimateValue> = Omit<TweenMeta, "commit" | "layer"> & {
+    /** Start value (required unless `values` is given). */
+    from?: T;
+    /** End value. */
+    to?: T;
+    /** Keyframes instead of from/to (offsets via `times`). */
+    values?: T[];
+    onUpdate(value: AnimateOut<T>): void;
+    /** After the last frame of a run that reached its end (not on cancel). */
+    onComplete?(): void;
+};
+/** Tween a free value and apply it yourself in `onUpdate` — the primitive for anything without a
+ *  native channel (material params, volumes, numbers a Canvas draws). Same easing / keyframes /
+ *  `loop` / `clock` as `animateTo`; returns the {@link Animation} handle. Default clock: `'ui'`. */
+export declare const animate: <T extends AnimateValue>(options: AnimateOptions<T>) => Animation;

package/dist/types/animate/tween/easing.d.ts

@@ -0,0 +1,29 @@
+import type { Easing } from "../easings";
+export declare const EASE_LINEAR = 0;
+export declare const EASE_NAMED = 1;
+export declare const EASE_BEZIER = 2;
+export declare const EASE_STEPS = 3;
+export declare const EASE_TABLE = 4;
+/** Samples per table (t = i / 64). Interpolation error for the smooth built-ins is < 1e-3. */
+export declare const EASE_TABLE_SIZE = 65;
+export type EasingSpec = {
+    kind: number;
+    /** kind-specific parameters: NAMED [id], BEZIER [x1, y1, x2, y2], STEPS [n, jumpAtStart], TABLE [tableIndex] */
+    p: [number, number, number, number];
+    /** TABLE only — the samples, appended to the blob's table section by the builder. */
+    table?: Float32Array;
+};
+/** A curve in the options bag: a name, `"cubic-bezier(x1,y1,x2,y2)"`, `"steps(n)"`, a bezier tuple,
+ *  or any `Easing` function. */
+export type EasingInput = string | readonly [number, number, number, number] | Easing;
+/** id → (name, formula). The formulas are the standard easings.net set; creator-tween's
+ *  `ctweenEaseNamed` implements the same list by id. */
+export declare const NAMED_EASINGS: ReadonlyArray<readonly [string, Easing]>;
+/** Sample an `Easing` function into a table. Endpoints are forced exact so a curve that is
+ *  numerically 0.9999 at 1 still lands on the keyframe. */
+export declare const sampleEasing: (fn: Easing) => Float32Array;
+/** Normalize one easing input. Unknown strings fall back to linear with a console warning (a typo
+ *  should be visible, not a silent snap). */
+export declare const parseEasing: (input: EasingInput | undefined) => EasingSpec;
+/** Evaluate an `EasingSpec` at `u` ∈ [0, 1] — the JS twin of `ctweenEase`. */
+export declare const evalEasing: (e: EasingSpec, u: number) => number;

package/dist/types/animate/tween/spec.d.ts

@@ -0,0 +1,178 @@
+import { type EasingInput, type EasingSpec } from "./easing";
+export declare const BLOB_VERSION = 1;
+export declare const DOM_UI = 0;
+export declare const DOM_GL_NODE = 1;
+export declare const DOM_GL_LIGHT = 2;
+export declare const DOM_GL_CAMERA = 3;
+export declare const DOM_NODE2D = 4;
+export declare const DOM_SPRITE2D = 5;
+export declare const DOM_VALUE = 6;
+export declare const KIND_FLOAT = 0;
+export declare const KIND_FLOAT_UNIT = 1;
+export declare const KIND_COLOR = 2;
+export declare const KIND_TRANSFORM = 3;
+export declare const KIND_TRANSFORM_MATRIX = 4;
+export declare const KIND_VEC3 = 5;
+export declare const KIND_QUAT = 6;
+export declare const KIND_EULER = 7;
+export declare const KIND_DISCRETE = 8;
+export declare const KIND_STRING = 9;
+export declare const KIND_VEC2 = 10;
+export declare const KIND_MAT4 = 11;
+export declare const CLOCK_UI = 0;
+export declare const CLOCK_GAME = 1;
+export declare const lanesOf: (kind: number) => number;
+/** One normalized value: numeric lanes, or a string (string-lane kinds). */
+export type TweenValue = {
+    lanes: number[];
+} | {
+    str: string;
+};
+/** A target's answer to "can you animate `prop`?": the writer domain, the id resolver, the value
+ *  normalizer, and the commit hook (UI writes the last key into its stored style). */
+export type TweenChannel = {
+    domain: number;
+    /** Host handle at play time — a number (entity, web node id) or the host's opaque node object
+     *  (creator-pkg hands `_id` out as one); falsy = not addressable right now (unmounted), the
+     *  track is skipped. Handed to the host in the blob's `targets` list, never in the float data. */
+    id: () => unknown;
+    /** Normalize one keyframe value; `null` = not animatable (a warning, the value is committed only). */
+    value: (v: unknown) => ({
+        kind: number;
+        sig?: string;
+    } & TweenValue) | null;
+    commit?: (v: unknown) => void;
+};
+/** Implemented by every animatable class (Element, Node, Node2D, Sprite, Light, Camera). */
+export interface TweenTarget {
+}
+export type Keyframe = {
+    /** 0..1 within the track. */
+    t: number;
+    easing: EasingSpec;
+    /** `undefined` = capture at play. */
+    value?: TweenValue;
+    /** The bag value as written — what the old-host path forwards verbatim. */
+    raw?: unknown;
+};
+export type Track = {
+    target: TweenTarget;
+    prop: string;
+    channel: TweenChannel;
+    kind: number;
+    lanes: number;
+    sig?: string;
+    atMs: number;
+    durMs: number;
+    commit: boolean;
+    keys: Keyframe[];
+};
+export type TweenSpec = {
+    clock: number;
+    /** One iteration, ms — the last track's end (holds included). */
+    durationMs: number;
+    delayMs: number;
+    /** -1 = forever. */
+    iterations: number;
+    pingPong: boolean;
+    rate: number;
+    tracks: Track[];
+    /** Time-callbacks, ms; index = the event index the host reports. */
+    calls: number[];
+};
+/** Meta keys of an `animateTo` / `Timeline.add` bag — everything that is not a prop target. */
+export declare const TWEEN_META: Set<string>;
+export type TweenMeta = {
+    /** Tween length in **milliseconds** (default 225). */
+    duration?: number;
+    /** Wait before starting, **milliseconds**. The first keyframe holds through the wait. A loop delays once. */
+    delay?: number;
+    /** A curve for every prop, or a per-prop map (`{ width: 'outExpo', opacity: 'linear' }`). Names
+     *  (`outCubic`, `inOutSine`, `outBack`, …), `cubic-bezier(…)` / a `[x1, y1, x2, y2]` tuple,
+     *  `steps(n)`, or any `Easing` function. Default linear. */
+    easing?: EasingInput | Record<string, EasingInput>;
+    /** Keyframe offsets 0..1 for array-valued props (default: evenly spaced). */
+    times?: number[];
+    /** `true` = forever, a number = that many cycles. A loop never commits. */
+    loop?: boolean | number;
+    /** `"ping-pong"` (default) there and back each cycle; `"restart"` snaps back and replays. */
+    loopMode?: "restart" | "ping-pong";
+    /** `false` = animate without writing the last keyframe into the element's style. */
+    commit?: boolean;
+    /** `'ui'` = wall time (menus animate while the game is paused); `'game'` follows `Time.scale`.
+     *  Default: `'ui'` on UI elements, `'game'` on 3D / 2D nodes. */
+    clock?: "ui" | "game";
+    /** Legacy escape hatch (old hosts only). */
+    layer?: number;
+};
+export declare const DEFAULT_DURATION_MS = 225;
+export declare const warnOnce: (key: string, msg: string) => void;
+/** Resolve the per-prop easing from the bag. */
+export declare const easingFor: (easing: TweenMeta["easing"], prop: string) => EasingSpec;
+/** Iteration count from `loop`: 1 = one-shot, -1 = forever, n = cycles. */
+export declare const iterationsOf: (loop: TweenMeta["loop"]) => number;
+/** A UI style value: number → FLOAT; "12px" / "50%" → FLOAT_UNIT; other strings → STRING (the host
+ *  decides color vs discrete); booleans → DISCRETE. */
+export declare const uiValue: (v: unknown) => ({
+    kind: number;
+    sig?: string;
+} & TweenValue) | null;
+/** Parse `"translate(10px, 20px) rotate(45deg) scale(1.2)"` into a signature + lanes, or null when a
+ *  function is unknown (the caller falls back to matrix decomposition on the host). `scale(2)` and
+ *  `translate(5px)` complete their second argument like CSS. */
+export declare const parseTransformList: (s: string) => {
+    sig: string;
+    lanes: number[];
+} | null;
+export declare const transformLanes: (sig: string) => number;
+export declare const vec3Value: (v: unknown) => {
+    kind: number;
+    lanes: number[];
+} | null;
+export declare const quatValue: (v: unknown) => {
+    kind: number;
+    lanes: number[];
+} | null;
+export declare const eulerValue: (v: unknown) => {
+    kind: number;
+    lanes: number[];
+} | null;
+export declare const vec2Value: (v: unknown) => {
+    kind: number;
+    lanes: number[];
+} | null;
+export declare const floatValue: (v: unknown) => {
+    kind: number;
+    lanes: number[];
+} | null;
+export declare const colorValue: (v: unknown, toRgba: (c: any) => [number, number, number, number]) => {
+    kind: number;
+    lanes: [number, number, number, number];
+} | null;
+/** A free value for animate(): number → FLOAT, a color string → COLOR, arrays / vectors by length
+ *  (2 → VEC2, 3 → VEC3, 4 → QUAT, 16 → MAT4 decomposed into position · quaternion · scale). */
+export declare const valueValue: (v: unknown) => ({
+    kind: number;
+} & TweenValue) | null;
+/** Is this bag value a KEYFRAME ARRAY for a vector prop, as opposed to one vector? A vector value
+ *  is an array of NUMBERS (`[0, 2, 0]`); anything else in the array is a list of keyframes —
+ *  `[[0,0,0], [0,2,0]]`, `[new Vec3(), …]`, and the UI's `color: ['#fff', '#e29a22']`. */
+export declare const isVectorKeyframes: (v: unknown) => boolean;
+/** Build one track's keyframes from a bag value: a single value = one explicit key (the other end
+ *  captured), an array = explicit keys spaced by `times` or evenly. `fromCurrent` says which end is
+ *  implicit (animateTo: the first; animateFrom: the last). Returns null when a value can't be
+ *  animated (already warned). */
+export declare const makeTrack: (target: TweenTarget, prop: string, raw: unknown, meta: TweenMeta, atMs: number, fromCurrent: boolean, vectorProp: boolean) => Track | null;
+/** Every (prop → value) entry of a bag, meta keys stripped. */
+export declare const bagProps: (bag: Record<string, unknown>) => [string, unknown][];
+/** The value of a numeric track at local time `ms` (the C evaluator's rule: first key holds before,
+ *  last after; eased segment between). `out` receives `track.lanes` numbers. */
+export declare const evaluateTrack: (track: Track, ms: number, out: number[]) => void;
+export type TweenBlob = {
+    data: Float32Array;
+    strings: string[];
+    targets: unknown[];
+};
+/** Flatten a spec for `_creatorUI.tweenCreate`. Tracks whose target has no host id right now are
+ *  dropped (the animation still runs its clock, calls and finish). */
+export declare const buildBlob: (spec: TweenSpec) => TweenBlob;

package/dist/types/canvas/Canvas.d.ts

@@ -56,6 +56,8 @@ export declare class Canvas {
     private _surfaceId;
     private _tex2d?;
     private _uiBound;
+    private _lastBakeLen;
+    private _warnedGrowth;
     constructor(width: number, height: number, opts?: {
         pixelRatio?: number;
     });

package/dist/types/g2/Node2D.d.ts

@@ -3,6 +3,17 @@ import type { CompAxis, CompWriter } from "../core/compWrite";
 import { Registry } from "../core/registry";
 import { Vec2, type Vec2Like } from "../math/vec";
 import type { ClickEvent, TouchStartEvent } from "../runtime/touch";
+import type { Animation } from "../animate/tween/Animation";
+import { type TweenMeta } from "../animate/tween/spec";
+/** Animatable transform props of a 2D node; an array of values is a keyframe list. */
+export type Node2DTweenProps = {
+    x?: number | number[];
+    y?: number | number[];
+    position?: Vec2Like | Vec2Like[];
+    /** Degrees. */
+    rotation?: number | number[];
+    scale?: number | Vec2Like | (number | Vec2Like)[];
+};
 export { Vec2, type Vec2Like };
 export type Node2DEvents = {
     /** A looping animation clip wrapped around (fires each loop). */
@@ -59,6 +70,11 @@ export declare class Node2D extends AspectHost<Node2DEvents> implements CompWrit
     set rotation(deg: number);
     get scale(): Vec2;
     set scale(v: Vec2Like | number);
+    /** Tween the transform — `node.animateTo({ x: 120, rotation: 90, duration: 400, easing: 'outBack' })`;
+     *  arrays are keyframes. Game clock unless `clock: 'ui'`. Returns the {@link Animation} handle. */
+    animateTo(props: Node2DTweenProps & TweenMeta): Animation;
+    /** Tween FROM the given values to the node's current transform. */
+    animateFrom(props: Node2DTweenProps & TweenMeta): Animation;
     /** Draw layer (int). Higher layers render on top. */
     get layer(): number;
     set layer(v: number);

package/dist/types/g2/Sprite.d.ts

@@ -1,8 +1,15 @@
 import { type ColorInput } from "../core/color";
 import { Vec2, type Vec2Like } from "../math/vec";
 import { Canvas } from "../canvas/Canvas";
-import { Node2D } from "./Node2D";
+import { Node2D, type Node2DTweenProps } from "./Node2D";
 import type { Texture2D } from "./Texture2D";
+import { type TweenMeta } from "../animate/tween/spec";
+import type { Animation } from "../animate/tween/Animation";
+/** Animatable sprite props on top of the 2D transform. */
+export type SpriteTweenProps = Node2DTweenProps & {
+    opacity?: number | number[];
+    color?: ColorInput | ColorInput[];
+};
 /** Anything that can back a sprite: a texture, or a Canvas (baked to a texture on assign). */
 export type TextureSource = Texture2D | Canvas;
 export type SpriteOptions = {
@@ -40,6 +47,9 @@ export declare class Sprite extends Node2D {
     set frame(uv: [number, number, number, number]);
     /** Set the sub-rect in texture pixels. */
     setFramePx(px: number, py: number, pw: number, ph: number): this;
+    /** Tween `opacity` / `color` and the transform — see {@link Node2D.animateTo}. */
+    animateTo(props: SpriteTweenProps & TweenMeta): Animation;
+    animateFrom(props: SpriteTweenProps & TweenMeta): Animation;
     get color(): ColorInput;
     set color(c: ColorInput);
     get opacity(): number;

package/dist/types/gl/Camera.d.ts

@@ -1,6 +1,14 @@
 import { Vec3 } from "../math/vec";
-import { Node } from "./Node";
+import { Node, type NodeTweenProps } from "./Node";
 import { Ray } from "./Ray";
+import { type TweenMeta } from "../animate/tween/spec";
+import type { Animation } from "../animate/tween/Animation";
+/** Animatable camera props on top of the node transform. */
+export type CameraTweenProps = NodeTweenProps & {
+    fov?: number | number[];
+    near?: number | number[];
+    far?: number | number[];
+};
 /** Projection every host starts a scene with (creator-gl scene.cpp / the lite core agree on these). */
 export declare const CAMERA_DEFAULTS: {
     fov: number;
@@ -9,6 +17,9 @@ export declare const CAMERA_DEFAULTS: {
 };
 export declare class Camera extends Node {
     private _sceneId;
+    /** Tween `fov` / `near` / `far` (a zoom, a dolly) and the transform — see {@link Node.animateTo}. */
+    animateTo(props: CameraTweenProps & TweenMeta): Animation;
+    animateFrom(props: CameraTweenProps & TweenMeta): Animation;
     /** Live projection matrix (updated by the host when the viewport/fov changes). */
     readonly projectionMatrix: Float32Array<ArrayBuffer>;
     private _fov;
@@ -25,6 +36,9 @@ export declare class Camera extends Node {
      *  adaptation when the sun swings into view (drop it, and the sun stays at the display's peak
      *  while everything else darkens). Scene light follows it; particle `emissive` is post-exposure
      *  and does not, so a fireball keeps its on-screen brightness. Cheap to animate every frame. */
+    /** The camera's EV100 with the compensation in: log2(aperture² / shutterSpeed x 100 / iso) - compensation. Sunny 16 is
+     *  ~15; a lit surface of luminance L lands on screen at L / (1.2 x 2^ev100). */
+    get ev100(): number;
     get exposureCompensation(): number;
     set exposureCompensation(stops: number);
     /** The physical camera: `aperture` in f-stops, `shutterSpeed` in seconds, `iso`, plus the same