framefields 2.14.0 → 2.15.0

package/dist/{index-9xte4JgL.d.mts → index-DkAjKnhW.d.mts}

@@ -1,14 +1,167 @@
 import { $ as FrameSignal, $n as ToonShading, At as MediaTimeRemapInput, Et as MediaSourceInput, Ft as MeshAudioDeformConfig, I as Effect$1, Jn as TextSpan, M as DeflickerOptions, Nt as MediaTimeSignalRemap, O as DataType, Sn as Signal, Z as FrameContext, _n as ResolvedMediaTimeRemap, en as NormalRelightingOptions, fn as ProgrammaticSignal, fr as VirtualMediaData, gn as RenderDiagnostic, gr as VisionTask, it as GeometryOutlineOptions, yt as MediaMetadata, z as EffectDomain } from "./index-C-V6CAhP.mjs";
-import { A as PolyhedronGeometryOptions, F as RoundedBoxGeometryOptions, G as TorusGeometryOptions, H as SlugFontCache, K as TubeGeometryOptions, Nn as TypewriterAnimator, P as RingGeometryOptions, R as ShardGeometryOptions, Rr as Path3D, Vt as KineticMarqueeConfig, W as SphereGeometryOptions, _ as ExtrudeShapeGeometryOptions, b as LatheGeometryOptions, ft as AdvancedTextAnimator, h as CylinderGeometryOptions, k as Points3DGeometryOptions, m as CapsuleGeometryOptions, q as TubePathSpec, ut as AETextAnimator, x as Line3DGeometryOptions, yn as TextPathOptions } from "./index-CRaydvLi.mjs";
-import { i as RegisterFontOptions } from "./index-C5sgRLlG.mjs";
-import { F as VisionNode, J as TensorPipeline, O as VisionAnalysisReport, a as ClipPose, c as InstanceMask, g as ObjectTrackSignals, k as VisionBundle, l as LandmarkCoordinateSignals, o as ClipSubjectSource, r as COCO17_KEYPOINT_NAMES, s as DepthMap, u as MaskTrackSignals, v as PinToLandmarkOptions, y as PinToObjectOptions } from "./index-D1FqV1eu.mjs";
-import { S as Sam3Options, p as Sam2Options } from "./index-CEKxvGY-.mjs";
-import { $n as ResizerScalerProps, $t as FlipProps, An as Paint, At as CameraParallax3DProps, B as PBRGlass, Bn as Pixelate, Bt as ContourProps, C as GradientMapProps, Cn as MeshWarp, Ct as AudioParametricEq, D as HalftoneScreen, Dn as NoiseGeneratorProps, Dt as CRT, En as NoiseGenerator, Et as AudioReverbProps, F as LevelsProps, Fn as Painterly, Ft as ColorBalance, G as SSAOProps, Gn as ProceduralVFXProps, Gt as DatamoshProps, H as Relight3D, Hn as Posterize, I as Modulate, In as PainterlyProps, It as ColorBalanceProps, J as SelectiveColorProps, Jn as RefineEdge, Jt as Dither, K as SelectiveColor, Kn as RGBSplit, Kt as DisplacementMap, L as ModulateProps, Ln as PatchHeal, Lt as ColorKey, M as HighPassProps, Mt as ChannelMergerProps, Nt as ChannelSplitter, O as HalftoneScreenProps, On as OpArt, Ot as CRTProps, P as Levels, Pt as ChannelSplitterProps, Q as TileOffset, Qn as ResizerScaler, Qt as Flip, R as MotionBlur, Rt as ColorKeyProps, S as GradientMap, Sn as MaskMathProps, St as AudioNoiseGateProps, Tn as MeshWarpProps, Tt as AudioReverb, U as Relight3DProps, Un as PosterizeProps, Ut as CornerPinProps, V as PBRGlassProps, Vn as PixelateProps, Vt as CornerPin, W as SSAO, Wn as ProceduralVFX, Wt as Datamosh, X as ShadowsHighlightsProps, Xn as RefractionCaustics3D, Xt as ExtractLUT, Y as ShadowsHighlights, Yn as RefineEdgeProps, Yt as DitherProps, Z as TemporalDeflicker, Zn as RefractionCaustics3DProps, Zt as ExtractLUTProps, _t as AudioDelay, a as ApplyLUTProps, an as KaleidoscopeProps, ar as Toon, b as FilmGrain, bn as LiquifyProps, bt as AudioFadeProps, c as Crop, cn as KenBurnsProps, cr as TrailsProps, dr as EffectProp, dt as Blur, en as Gooey, er as Rotate, et as TileOffsetProps, f as CurvesProps, ft as BlurProps, g as DepthOfFieldProps, gn as LayerStyleProps, gt as AudioCompressorProps, h as DepthOfField, ht as AudioCompressor, i as ApplyLUT, in as Kaleidoscope, it as VisionProps, j as HighPass, jn as PaintProps, jt as ChannelMerger, kn as OpArtProps, kt as CameraParallax3D, l as CropProps, ln as LayerStyle, lr as Vignette, m as DeflickerProps, mt as AsciiProps, n as AnyEffect, nn as Iridescence, nr as StereoPanning, nt as UnsharpMaskProps, on as KenBurns, or as ToonProps, p as CustomEffect, pt as Ascii, qn as RGBSplitProps, qt as DisplacementMapProps, r as AnyVisualEffect, rn as IridescenceProps, rr as StereoPanningProps, rt as Vision, sr as Trails, t as AnyAudioEffect, tn as GooeyProps, tr as RotateProps, tt as UnsharpMask, u as Curves, ur as VignetteProps, vn as Liquify, vt as AudioDelayProps, wt as AudioParametricEqProps, x as FilmGrainProps, xn as MaskMath, xt as AudioNoiseGate, yt as AudioFade, z as MotionBlurProps, zn as PatchHealProps, zt as Contour } from "./index-DoP6EiHj.mjs";
-import { _ as RenderProgress, b as VideoQaOptions, f as HeadlessMediaRenderer, t as FrameGridOptions, x as VideoQaReport } from "./index-C7-p9zwU.mjs";
+import { $ as TubeGeometryOptions, A as PolyhedronGeometryOptions, Dn as TextPathOptions, F as RoundedBoxGeometryOptions, H as ShardGeometryOptions, J as SphereGeometryOptions, K as SlugFontCache, L as ScatterOptions, P as RingGeometryOptions, Q as TorusGeometryOptions, R as ScatterPoint, Vn as TypewriterAnimator, X as TerrainGeometryOptions, Yt as KineticMarqueeConfig, _ as ExtrudeShapeGeometryOptions, b as LatheGeometryOptions, bt as AdvancedTextAnimator, et as TubePathSpec, h as CylinderGeometryOptions, k as Points3DGeometryOptions, m as CapsuleGeometryOptions, oi as Path3D, vt as AETextAnimator, x as Line3DGeometryOptions, z as SdfGeometryOptions } from "./index-s2qQ8ifZ.mjs";
+import { i as RegisterFontOptions } from "./index-TCtdSXd7.mjs";
+import { A as VisionBundle, I as VisionNode, Y as TensorPipeline, _ as ObjectTrackSignals, a as ClipPose, b as PinToObjectOptions, c as InstanceMask, d as MatteRefineOptions, k as VisionAnalysisReport, l as LandmarkCoordinateSignals, o as ClipSubjectSource, r as COCO17_KEYPOINT_NAMES, s as DepthMap, u as MaskTrackSignals, y as PinToLandmarkOptions } from "./index-CMhkkc56.mjs";
+import { S as Sam3Options, p as Sam2Options } from "./index-BHTycml5.mjs";
+import { $n as ResizerScalerProps, $t as FlipProps, An as Paint, At as CameraParallax3DProps, B as PBRGlass, Bn as Pixelate, Bt as ContourProps, C as GradientMapProps, Cn as MeshWarp, Ct as AudioParametricEq, D as HalftoneScreen, Dn as NoiseGeneratorProps, Dt as CRT, En as NoiseGenerator, Et as AudioReverbProps, F as LevelsProps, Fn as Painterly, Ft as ColorBalance, G as SSAOProps, Gn as ProceduralVFXProps, Gt as DatamoshProps, H as Relight3D, Hn as Posterize, I as Modulate, In as PainterlyProps, It as ColorBalanceProps, J as SelectiveColorProps, Jn as RefineEdge, Jt as Dither, K as SelectiveColor, Kn as RGBSplit, Kt as DisplacementMap, L as ModulateProps, Ln as PatchHeal, Lt as ColorKey, M as HighPassProps, Mt as ChannelMergerProps, Nt as ChannelSplitter, O as HalftoneScreenProps, On as OpArt, Ot as CRTProps, P as Levels, Pt as ChannelSplitterProps, Q as TileOffset, Qn as ResizerScaler, Qt as Flip, R as MotionBlur, Rt as ColorKeyProps, S as GradientMap, Sn as MaskMathProps, St as AudioNoiseGateProps, Tn as MeshWarpProps, Tt as AudioReverb, U as Relight3DProps, Un as PosterizeProps, Ut as CornerPinProps, V as PBRGlassProps, Vn as PixelateProps, Vt as CornerPin, W as SSAO, Wn as ProceduralVFX, Wt as Datamosh, X as ShadowsHighlightsProps, Xn as RefractionCaustics3D, Xt as ExtractLUT, Y as ShadowsHighlights, Yn as RefineEdgeProps, Yt as DitherProps, Z as TemporalDeflicker, Zn as RefractionCaustics3DProps, Zt as ExtractLUTProps, _t as AudioDelay, a as ApplyLUTProps, an as KaleidoscopeProps, ar as Toon, b as FilmGrain, bn as LiquifyProps, bt as AudioFadeProps, c as Crop, cn as KenBurnsProps, cr as TrailsProps, dr as EffectProp, dt as Blur, en as Gooey, er as Rotate, et as TileOffsetProps, f as CurvesProps, ft as BlurProps, g as DepthOfFieldProps, gn as LayerStyleProps, gt as AudioCompressorProps, h as DepthOfField, ht as AudioCompressor, i as ApplyLUT, in as Kaleidoscope, it as VisionProps, j as HighPass, jn as PaintProps, jt as ChannelMerger, kn as OpArtProps, kt as CameraParallax3D, l as CropProps, ln as LayerStyle, lr as Vignette, m as DeflickerProps, mt as AsciiProps, n as AnyEffect, nn as Iridescence, nr as StereoPanning, nt as UnsharpMaskProps, on as KenBurns, or as ToonProps, p as CustomEffect, pt as Ascii, qn as RGBSplitProps, qt as DisplacementMapProps, r as AnyVisualEffect, rn as IridescenceProps, rr as StereoPanningProps, rt as Vision, sr as Trails, t as AnyAudioEffect, tn as GooeyProps, tr as RotateProps, tt as UnsharpMask, u as Curves, ur as VignetteProps, vn as Liquify, vt as AudioDelayProps, wt as AudioParametricEqProps, x as FilmGrainProps, xn as MaskMath, xt as AudioNoiseGate, yt as AudioFade, z as MotionBlurProps, zn as PatchHealProps, zt as Contour } from "./index-BcxxxwhV.mjs";
+import { _ as RenderProgress, b as VideoQaOptions, f as HeadlessMediaRenderer, t as FrameGridOptions, x as VideoQaReport } from "./index-DhL7ckvs.mjs";
 import { z, z as z$2 } from "zod";
 import { Yoga } from "yoga-layout/load";
 
 //#region ../compositions/dist/program/index.d.mts
+//#region src/program/character-schema.d.ts
+/** A frame signal: anything with `get(ctx)` (`Signal.*`, audio, physics, vision). */
+interface TrackSignal {
+  get(ctx?: unknown): number;
+}
+/**
+ * A number over time: constant, `[[frame, value], …]` keys, `(frame) =>
+ * value`, or a signal.
+ */
+declare const NumberTrackSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>;
+type NumberTrack = z.infer<typeof NumberTrackSchema>;
+/**
+ * A point over time: `[x, y, z]` where each axis is a {@link NumberTrack}
+ * (so a constant, keys, a function or a signal per axis), `[[frame, x, y,
+ * z], …]` keys, or `(frame) => [x, y, z]`.
+ */
+declare const Vec3TrackSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>], null>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => [number, number, number], (frame: number) => [number, number, number]>]>;
+type Vec3Track = z.infer<typeof Vec3TrackSchema>;
+declare const ModelAnimationLayerSchema: z.ZodObject<{
+  clip: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  speed: z.ZodOptional<z.ZodNumber>;
+  timeOffset: z.ZodOptional<z.ZodNumber>;
+  mask: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  loop: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type ModelAnimationLayer = z.infer<typeof ModelAnimationLayerSchema>;
+declare const TwoBoneIkSchema: z.ZodObject<{
+  chain: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodString], null>;
+  target: z.ZodUnion<readonly [z.ZodTuple<[z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>], null>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => [number, number, number], (frame: number) => [number, number, number]>]>;
+  poleTarget: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>], null>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => [number, number, number], (frame: number) => [number, number, number]>]>>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+}, z.core.$strict>;
+type TwoBoneIkConstraint = z.infer<typeof TwoBoneIkSchema>;
+declare const LookAtSchema: z.ZodObject<{
+  joint: z.ZodString;
+  target: z.ZodUnion<readonly [z.ZodTuple<[z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>], null>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => [number, number, number], (frame: number) => [number, number, number]>]>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  maxAngleDeg: z.ZodOptional<z.ZodNumber>;
+  axis: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>;
+type LookAtConstraint = z.infer<typeof LookAtSchema>;
+/**
+ * A joint posed directly, in its own local frame: Euler degrees (applied
+ * Z, then Y, then X, like layers) and a translation offset in model units,
+ * on top of the animated pose (`"additive"`, default) or of the joint's rest
+ * pose (`"rest"`: clips no longer move it).
+ */
+declare const JointPoseSchema: z.ZodObject<{
+  rotateX: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  rotateY: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  rotateZ: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  x: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  y: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  z: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    additive: "additive";
+    rest: "rest";
+  }>>;
+}, z.core.$strict>;
+type JointPose = z.infer<typeof JointPoseSchema>;
+/**
+ * Points a bone along a scene direction (the joint turns so the bone,
+ * toward its first child, or its local `axis` lies along it). Retargeting a
+ * performer's pose is a chain of aims, parents first.
+ */
+declare const AimSchema: z.ZodObject<{
+  joint: z.ZodString;
+  direction: z.ZodUnion<readonly [z.ZodTuple<[z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>, z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>], null>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => [number, number, number], (frame: number) => [number, number, number]>]>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, z.ZodCustom<(frame: number) => number, (frame: number) => number>, z.ZodCustom<TrackSignal, TrackSignal>]>>;
+  axis: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>;
+type AimConstraint = z.infer<typeof AimSchema>;
+/**
+ * A joint driven by another: it turns by a share of the source joint's turn
+ * from its rest, per local axis (Euler degrees, Z then Y then X). Applied
+ * after look-ats, before IK, so eyelids follow eyes a `lookAt` aims.
+ */
+declare const JointDriverSchema: z.ZodObject<{
+  joint: z.ZodString;
+  from: z.ZodString;
+  rotate: z.ZodObject<{
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    z: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type JointDriver = z.infer<typeof JointDriverSchema>;
+declare const SpringBoneChainSchema: z.ZodObject<{
+  joints: z.ZodArray<z.ZodString>;
+  stiffness: z.ZodOptional<z.ZodNumber>;
+  damping: z.ZodOptional<z.ZodNumber>;
+  gravity: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>;
+type SpringBoneChain = z.infer<typeof SpringBoneChainSchema>;
+declare const CrowdSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+  fps: z.ZodOptional<z.ZodNumber>;
+  seed: z.ZodOptional<z.ZodNumber>;
+  speedRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+  phase: z.ZodOptional<z.ZodEnum<{
+    random: "random";
+    sync: "sync";
+  }>>;
+}, z.core.$strict>;
+type CrowdConfig = z.infer<typeof CrowdSchema>;
+//#endregion
+//#region src/program/procedural-schema.d.ts
+
+declare const WindSchema: z.ZodObject<{
+  amplitudeDeg: z.ZodOptional<z.ZodNumber>;
+  frequency: z.ZodOptional<z.ZodNumber>;
+  direction: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+  waveScale: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type WindConfig = z.infer<typeof WindSchema>;
+declare const Scatter3DSchema: z.ZodObject<{
+  surface: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+  count: z.ZodNumber;
+  minDistance: z.ZodOptional<z.ZodNumber>;
+  seed: z.ZodOptional<z.ZodNumber>;
+  slopeRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+  elevationRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+  alignToNormal: z.ZodOptional<z.ZodNumber>;
+  scaleRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+  randomYaw: z.ZodOptional<z.ZodBoolean>;
+  exclude: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    x: z.ZodNumber;
+    z: z.ZodNumber;
+    radius: z.ZodNumber;
+    falloff: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>>;
+  sink: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type Scatter3DSpec = z.infer<typeof Scatter3DSchema>;
+/** A layer drawn offscreen every frame and wrapped onto a model's surface. */
+
+/**
+ * Voronoi destruction (`world.fracture`): the model is cut into `cells`
+ * pieces, drawn as one rigidly skinned mesh posed per frame from `track`.
+ * Without a track the pieces rest in place and the model looks whole.
+ */
+declare const Fracture3DSchema: z.ZodObject<{
+  cells: z.ZodOptional<z.ZodNumber>;
+  seed: z.ZodOptional<z.ZodNumber>;
+  impactPoint: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+  interiorColor: z.ZodOptional<z.ZodString>;
+  interiorRoughness: z.ZodOptional<z.ZodNumber>;
+  track: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>;
+type Fracture3DSpec = z.infer<typeof Fracture3DSchema>;
+//#endregion
 //#region src/program/schema.d.ts
 /** number px | "auto" (intrinsic) | "fit" (shrink-wrap) | "fill" (parent extent). */
 declare const SizeSpecSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
@@ -99,6 +252,7 @@ declare const AnimatablePropSchema: z.ZodEnum<{
   maxBlurRadius: "maxBlurRadius";
   shakeTranslation: "shakeTranslation";
   shakeRotation: "shakeRotation";
+  relativitySpeed: "relativitySpeed";
   orbitRadius: "orbitRadius";
   orbitAzimuth: "orbitAzimuth";
   orbitElevation: "orbitElevation";
@@ -127,17 +281,35 @@ declare const AnimatablePropSchema: z.ZodEnum<{
   scaleY: "scaleY";
   emissive: "emissive";
   emissiveIntensity: "emissiveIntensity";
+  clearcoat: "clearcoat";
+  clearcoatRoughness: "clearcoatRoughness";
+  anisotropy: "anisotropy";
+  anisotropyRotation: "anisotropyRotation";
+  subsurface: "subsurface";
+  subsurfaceColor: "subsurfaceColor";
+  sheen: "sheen";
+  sheenColor: "sheenColor";
+  sheenRoughness: "sheenRoughness";
+  iridescence: "iridescence";
+  iridescenceThickness: "iridescenceThickness";
+  iridescenceIor: "iridescenceIor";
+  triplanarScale: "triplanarScale";
+  triplanarSharpness: "triplanarSharpness";
   exposure: "exposure";
+  volumetricFogDensity: "volumetricFogDensity";
+  volumetricFogAnisotropy: "volumetricFogAnisotropy";
+  volumetricFogNoiseStrength: "volumetricFogNoiseStrength";
 }>;
 type AnimatableProp = z.infer<typeof AnimatablePropSchema>;
 type SpatialAnimatableProp = "x" | "y" | "z" | "scale" | "scaleX" | "scaleY" | "scaleZ" | "rotation" | "rotateX" | "rotateY" | "rotateZ" | "opacity" | "width" | "height" | "hidden" | "perspective" | "perspectiveOriginX" | "perspectiveOriginY" | "translateZ" | "motionBlurShutter";
-type BoxAnimatableProp = SpatialAnimatableProp | "gap" | "padding" | "borderRadius" | "fill" | "color" | "borderColor" | "borderWidth" | "shininess" | "roughness" | "specularIntensity" | "ambientIntensity" | "metallic" | "ior" | "dispersion" | "transmission" | "fresnelPower" | "emissive" | "emissiveIntensity" | "envIntensity" | "exposure";
+type MaterialAnimatableProp = "shininess" | "roughness" | "specularIntensity" | "ambientIntensity" | "metallic" | "ior" | "dispersion" | "transmission" | "fresnelPower" | "emissive" | "emissiveIntensity" | "clearcoat" | "clearcoatRoughness" | "anisotropy" | "anisotropyRotation" | "subsurface" | "subsurfaceColor" | "sheen" | "sheenColor" | "sheenRoughness" | "iridescence" | "iridescenceThickness" | "iridescenceIor" | "triplanarScale" | "triplanarSharpness" | "envIntensity" | "exposure";
+type BoxAnimatableProp = SpatialAnimatableProp | MaterialAnimatableProp | "gap" | "padding" | "borderRadius" | "fill" | "color" | "borderColor" | "borderWidth";
 type TextAnimatableProp = SpatialAnimatableProp | "text" | "fontSize" | "letterSpacing" | "fill" | "color" | "rangeStart" | "rangeEnd" | "offset" | "animatorRangeStart" | "animatorRangeEnd" | "animatorOffset" | "firstMargin" | "lastMargin" | "baselineShift";
 type ShapeAnimatableProp = SpatialAnimatableProp | "d" | "trimStart" | "trimEnd" | "trimOffset" | "strokeWidth" | "strokeDashOffset" | "cornerRadius" | "starInnerRadiusRatio" | "fillColor" | "strokeColor" | "borderColor" | "borderWidth";
 type MediaAnimatableProp = SpatialAnimatableProp | "volume" | "muted";
-type CameraAnimatableProp = SpatialAnimatableProp | "cameraX" | "cameraY" | "cameraZ" | "targetX" | "targetY" | "targetZ" | "cameraPitch" | "cameraYaw" | "cameraRoll" | "cameraFov" | "cameraZoom" | "focalLength" | "focusDistance" | "fStop" | "maxBlurRadius" | "shakeTranslation" | "shakeRotation" | "orbitRadius" | "orbitAzimuth" | "orbitElevation";
-type LightAnimatableProp = SpatialAnimatableProp | "intensity" | "angle" | "radius" | "penumbra" | "decay" | "color";
-type Model3DAnimatableProp = SpatialAnimatableProp | "animationProgress" | "animationTime" | "animationSpeed" | "wireframe";
+type CameraAnimatableProp = SpatialAnimatableProp | "cameraX" | "cameraY" | "cameraZ" | "targetX" | "targetY" | "targetZ" | "cameraPitch" | "cameraYaw" | "cameraRoll" | "cameraFov" | "cameraZoom" | "focalLength" | "focusDistance" | "fStop" | "maxBlurRadius" | "shakeTranslation" | "shakeRotation" | "relativitySpeed" | "orbitRadius" | "orbitAzimuth" | "orbitElevation";
+type LightAnimatableProp = SpatialAnimatableProp | "targetX" | "targetY" | "targetZ" | "intensity" | "angle" | "radius" | "penumbra" | "decay" | "color" | "exposure" | "volumetricFogDensity" | "volumetricFogAnisotropy" | "volumetricFogNoiseStrength";
+type Model3DAnimatableProp = SpatialAnimatableProp | MaterialAnimatableProp | "color" | "animationProgress" | "animationTime" | "animationSpeed" | "wireframe";
 type AnimatablePropsFor<TNode> = TNode extends {
   kind: "text";
 } ? TextAnimatableProp : TNode extends {
@@ -357,6 +529,7 @@ declare const AnimationTrackSchema: z.ZodObject<{
     maxBlurRadius: "maxBlurRadius";
     shakeTranslation: "shakeTranslation";
     shakeRotation: "shakeRotation";
+    relativitySpeed: "relativitySpeed";
     orbitRadius: "orbitRadius";
     orbitAzimuth: "orbitAzimuth";
     orbitElevation: "orbitElevation";
@@ -385,7 +558,24 @@ declare const AnimationTrackSchema: z.ZodObject<{
     scaleY: "scaleY";
     emissive: "emissive";
     emissiveIntensity: "emissiveIntensity";
+    clearcoat: "clearcoat";
+    clearcoatRoughness: "clearcoatRoughness";
+    anisotropy: "anisotropy";
+    anisotropyRotation: "anisotropyRotation";
+    subsurface: "subsurface";
+    subsurfaceColor: "subsurfaceColor";
+    sheen: "sheen";
+    sheenColor: "sheenColor";
+    sheenRoughness: "sheenRoughness";
+    iridescence: "iridescence";
+    iridescenceThickness: "iridescenceThickness";
+    iridescenceIor: "iridescenceIor";
+    triplanarScale: "triplanarScale";
+    triplanarSharpness: "triplanarSharpness";
     exposure: "exposure";
+    volumetricFogDensity: "volumetricFogDensity";
+    volumetricFogAnisotropy: "volumetricFogAnisotropy";
+    volumetricFogNoiseStrength: "volumetricFogNoiseStrength";
   }>;
   source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"keyframe">;
@@ -541,6 +731,7 @@ declare const LayerAnimationSchema: z.ZodObject<{
       maxBlurRadius: "maxBlurRadius";
       shakeTranslation: "shakeTranslation";
       shakeRotation: "shakeRotation";
+      relativitySpeed: "relativitySpeed";
       orbitRadius: "orbitRadius";
       orbitAzimuth: "orbitAzimuth";
       orbitElevation: "orbitElevation";
@@ -569,7 +760,24 @@ declare const LayerAnimationSchema: z.ZodObject<{
       scaleY: "scaleY";
       emissive: "emissive";
       emissiveIntensity: "emissiveIntensity";
+      clearcoat: "clearcoat";
+      clearcoatRoughness: "clearcoatRoughness";
+      anisotropy: "anisotropy";
+      anisotropyRotation: "anisotropyRotation";
+      subsurface: "subsurface";
+      subsurfaceColor: "subsurfaceColor";
+      sheen: "sheen";
+      sheenColor: "sheenColor";
+      sheenRoughness: "sheenRoughness";
+      iridescence: "iridescence";
+      iridescenceThickness: "iridescenceThickness";
+      iridescenceIor: "iridescenceIor";
+      triplanarScale: "triplanarScale";
+      triplanarSharpness: "triplanarSharpness";
       exposure: "exposure";
+      volumetricFogDensity: "volumetricFogDensity";
+      volumetricFogAnisotropy: "volumetricFogAnisotropy";
+      volumetricFogNoiseStrength: "volumetricFogNoiseStrength";
     }>;
     source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
       type: z.ZodLiteral<"keyframe">;
@@ -661,6 +869,17 @@ type LayerAnimationSpec<TProp extends AnimatableProp = AnimatableProp> = Omit<Ba
 };
 declare const ToonShadingSchema: z.ZodType<ToonShading>;
 declare const GeometryOutlineOptionsSchema: z.ZodType<GeometryOutlineOptions>;
+declare const IridescenceConfigSchema: z.ZodObject<{
+  intensity: z.ZodOptional<z.ZodNumber>;
+  thickness: z.ZodOptional<z.ZodNumber>;
+  ior: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type IridescenceConfig = z.infer<typeof IridescenceConfigSchema>;
+declare const TriplanarConfigSchema: z.ZodObject<{
+  scale: z.ZodOptional<z.ZodNumber>;
+  sharpness: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type TriplanarConfig = z.infer<typeof TriplanarConfigSchema>;
 interface CompositionNodeBase {
   id: string;
   inputHandleId?: string;
@@ -709,6 +928,21 @@ interface CompositionNodeBase {
   fresnelPower?: number;
   emissive?: string;
   emissiveIntensity?: number;
+  clearcoat?: number;
+  clearcoatRoughness?: number;
+  anisotropy?: number;
+  anisotropyRotation?: number;
+  subsurface?: number;
+  subsurfaceColor?: string;
+  sheen?: number;
+  sheenColor?: string;
+  sheenRoughness?: number;
+  iridescence?: number | IridescenceConfig;
+  iridescenceThickness?: number;
+  iridescenceIor?: number;
+  triplanar?: boolean | TriplanarConfig;
+  triplanarScale?: number;
+  triplanarSharpness?: number;
   castShadow?: boolean;
   toon?: ToonShading;
   outline?: boolean;
@@ -726,6 +960,7 @@ interface CompositionNodeBase {
   reliefId?: string;
   reliefOf?: string;
   reliefAmount?: number;
+  textureOf?: string;
   envIntensity?: number;
   startFrame?: number;
   durationFrames?: number;
@@ -885,6 +1120,13 @@ interface TextNode extends CompositionNodeBase {
   fontSize?: number;
   fontWeight?: number | string;
   fontStyle?: string;
+  /**
+   * Variable font axes by tag, as CSS `font-variation-settings`: `{ wdth: 68 }`
+   * narrows a font with a width axis, `{ opsz: 72 }` or `{ GRAD: 50 }` set
+   * others. `fontWeight` sets `wght`; `opsz` follows the font size unless set.
+   * Axes the font lacks are ignored. Spans inherit them.
+   */
+  fontVariations?: Record<string, number>;
   fill?: string;
   align?: "start" | "center" | "end";
   /**
@@ -976,6 +1218,12 @@ interface ShapeNode extends CompositionNodeBase {
   trimEnd?: number;
   trimOffset?: number;
 }
+/**
+ * The picture a camera draws. `perspective` is an ordinary lens; the others
+ * are cube cameras: the scene is drawn as six 90° faces around the eye and
+ * remapped, so they can show what no single frustum holds.
+ */
+
 declare const CameraLensSchema: z.ZodObject<{
   focalLength: z.ZodDefault<z.ZodNumber>;
   fov: z.ZodOptional<z.ZodNumber>;
@@ -983,8 +1231,15 @@ declare const CameraLensSchema: z.ZodObject<{
   near: z.ZodDefault<z.ZodNumber>;
   far: z.ZodDefault<z.ZodNumber>;
   zoom: z.ZodDefault<z.ZodNumber>;
+  projection: z.ZodDefault<z.ZodEnum<{
+    perspective: "perspective";
+    equirectangular: "equirectangular";
+    fisheye: "fisheye";
+  }>>;
+  cubeSize: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
-type CameraLens = z.infer<typeof CameraLensSchema>;
+/** A lens as authored: fields with schema defaults may be left out. */
+type CameraLens = z.input<typeof CameraLensSchema>;
 declare const CameraDoFSchema: z.ZodObject<{
   enabled: z.ZodDefault<z.ZodBoolean>;
   focusDistance: z.ZodDefault<z.ZodNumber>;
@@ -1002,7 +1257,33 @@ declare const CameraShakeSchema: z.ZodObject<{
   octaves: z.ZodDefault<z.ZodNumber>;
   seed: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
-type CameraShake = z.infer<typeof CameraShakeSchema>;
+type CameraShake = z.input<typeof CameraShakeSchema>;
+/**
+ * Per-object shutter motion blur for the 3D scene: every mesh, skinned
+ * joint, instance and fractured piece streaks by its own motion over the
+ * shutter (and the camera's), reconstructed from a velocity buffer.
+ */
+declare const CameraMotionBlurSchema: z.ZodObject<{
+  shutter: z.ZodDefault<z.ZodNumber>;
+  samples: z.ZodDefault<z.ZodNumber>;
+  maxBlur: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type CameraMotionBlur = z.input<typeof CameraMotionBlurSchema>;
+/**
+ * The camera moves through the scene near the speed of light. What it sees
+ * is physics, not grading: rays crowd towards the direction of motion
+ * (aberration), colours shift blue ahead and red behind (Doppler) and ahead
+ * brightens (beaming). Always drawn by a cube camera.
+ */
+declare const CameraRelativitySchema: z.ZodObject<{
+  speed: z.ZodDefault<z.ZodNumber>;
+  direction: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+  doppler: z.ZodDefault<z.ZodBoolean>;
+  beaming: z.ZodDefault<z.ZodBoolean>;
+  exposure: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
+}, z.core.$strict>;
+/** Relativity as authored: fields with schema defaults may be left out. */
+type CameraRelativity = z.input<typeof CameraRelativitySchema>;
 interface CameraNode {
   id: string;
   kind: "camera";
@@ -1019,13 +1300,17 @@ interface CameraNode {
   lens?: CameraLens;
   dof?: CameraDoF;
   shake?: CameraShake;
+  /** Shutter motion blur of the 3D scene; `true` takes the defaults. */
+  motionBlur?: boolean | CameraMotionBlur;
+  relativity?: CameraRelativity;
   startFrame?: number;
   durationFrames?: number;
   animation?: LayerAnimationSpec;
 }
 declare const CameraNodeSchema: z.ZodType<CameraNode>;
-type LightType = "ambient" | "directional" | "point" | "spot" | "environment";
+type LightType = "ambient" | "directional" | "point" | "spot" | "rect" | "environment";
 declare const LightTypeSchema: z.ZodEnum<{
+  rect: "rect";
   ambient: "ambient";
   directional: "directional";
   point: "point";
@@ -1035,8 +1320,10 @@ declare const LightTypeSchema: z.ZodEnum<{
 declare const EnvironmentPresetSchema: z.ZodEnum<{
   studio: "studio";
   soft: "soft";
+  warm: "warm";
   sunset: "sunset";
   night: "night";
+  neon: "neon";
   neutral: "neutral";
 }>;
 type EnvironmentPreset = z.infer<typeof EnvironmentPresetSchema>;
@@ -1070,6 +1357,44 @@ declare const EnvironmentFloorSchema: z.ZodObject<{
   opacity: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 type EnvironmentFloor = z.infer<typeof EnvironmentFloorSchema>;
+declare const EnvironmentVolumetricFogNoiseSchema: z.ZodObject<{
+  scale: z.ZodOptional<z.ZodNumber>;
+  strength: z.ZodOptional<z.ZodNumber>;
+  speed: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+  octaves: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type EnvironmentVolumetricFogNoise = z.infer<typeof EnvironmentVolumetricFogNoiseSchema>;
+declare const EnvironmentVolumetricFogSchema: z.ZodObject<{
+  density: z.ZodOptional<z.ZodNumber>;
+  color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  anisotropy: z.ZodOptional<z.ZodNumber>;
+  heightFalloff: z.ZodOptional<z.ZodNumber>;
+  baseHeight: z.ZodOptional<z.ZodNumber>;
+  steps: z.ZodOptional<z.ZodNumber>;
+  maxDistance: z.ZodOptional<z.ZodNumber>;
+  lightIntensity: z.ZodOptional<z.ZodNumber>;
+  ambientIntensity: z.ZodOptional<z.ZodNumber>;
+  noise: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    scale: z.ZodOptional<z.ZodNumber>;
+    strength: z.ZodOptional<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    octaves: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>]>>;
+}, z.core.$strict>;
+type EnvironmentVolumetricFog = z.infer<typeof EnvironmentVolumetricFogSchema>;
+declare const EnvironmentSsrSchema: z.ZodObject<{
+  intensity: z.ZodOptional<z.ZodNumber>;
+  maxRoughness: z.ZodOptional<z.ZodNumber>;
+  thickness: z.ZodOptional<z.ZodNumber>;
+  steps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type EnvironmentSsr = z.infer<typeof EnvironmentSsrSchema>;
+declare const EnvironmentGiSchema: z.ZodObject<{
+  intensity: z.ZodOptional<z.ZodNumber>;
+  radius: z.ZodOptional<z.ZodNumber>;
+  samples: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type EnvironmentGi = z.infer<typeof EnvironmentGiSchema>;
 interface LightNode {
   id: string;
   kind: "light";
@@ -1087,15 +1412,23 @@ interface LightNode {
   decay?: number;
   angle?: number;
   penumbra?: number;
-  /** Directional / spot: render a shadow map. */
+  /** Area light width in world px (default 240, rect lights only). */
+  width?: number;
+  /** Area light height in world px (default 140, rect lights only). */
+  height?: number;
+  /** Emit from both faces of a rect light (default false). */
+  twoSided?: boolean;
+  /** Directional / spot / point / rect: render a shadow map. */
   castShadow?: boolean;
   /** Shadow edge blur in shadow-map texels. Default 2.5. */
   shadowSoftness?: number;
   /** 0..1, how dark shadows get. Default 1. */
   shadowDarkness?: number;
-  /** Shadow map resolution (texels per side). Default 2048. */
+  /** Shadow map resolution (texels per side). Default 2048 (1024 for point). */
   shadowMapSize?: number;
   preset?: EnvironmentPreset;
+  /** Equirectangular panorama for real HDRI IBL: a `.hdr` (Radiance RGBE) or `.exr` (OpenEXR) path, or the file's bytes. */
+  hdri?: string | Uint8Array;
   top?: string;
   horizon?: string;
   bottom?: string;
@@ -1105,6 +1438,18 @@ interface LightNode {
   toneMapping?: ToneMapping;
   fog?: EnvironmentFog;
   floor?: EnvironmentFloor;
+  /** Froxel-style volumetric participating media & shadowed light shafts (god rays). */
+  volumetricFog?: boolean | EnvironmentVolumetricFog;
+  /** Animatable / signal-driven override for volumetricFog.density. */
+  volumetricFogDensity?: number;
+  /** Animatable / signal-driven override for volumetricFog.anisotropy. */
+  volumetricFogAnisotropy?: number;
+  /** Animatable / signal-driven override for volumetricFog.noise.strength. */
+  volumetricFogNoiseStrength?: number;
+  /** Screen-space reflections of nearby geometry and emissives on glossy surfaces. */
+  ssr?: boolean | EnvironmentSsr;
+  /** Screen-space diffuse GI: occlusion and color bleeding from visible surfaces. */
+  gi?: boolean | EnvironmentGi;
   /** Optional depth/normal outlines, before depth of field and bloom. */
   outlines?: boolean | GeometryOutlineOptions;
   /** Glow around emissive surfaces and hot highlights: `true` or settings. */
@@ -1141,6 +1486,26 @@ interface Model3DNode {
   specularIntensity?: number;
   ambientIntensity?: number;
   metallic?: number;
+  emissive?: string;
+  emissiveIntensity?: number;
+  clearcoat?: number;
+  clearcoatRoughness?: number;
+  anisotropy?: number;
+  anisotropyRotation?: number;
+  subsurface?: number;
+  subsurfaceColor?: string;
+  sheen?: number;
+  sheenColor?: string;
+  sheenRoughness?: number;
+  iridescence?: number | IridescenceConfig;
+  iridescenceThickness?: number;
+  iridescenceIor?: number;
+  triplanar?: boolean | TriplanarConfig;
+  triplanarScale?: number;
+  triplanarSharpness?: number;
+  toon?: ToonShading;
+  outline?: boolean;
+  castShadow?: boolean;
   color?: string;
   colorTint?: string;
   opacity?: number;
@@ -1161,6 +1526,41 @@ interface Model3DNode {
   instances3d?: unknown;
   /** Layer3D.swarm GPU simulation and instancing options. */
   swarm3d?: unknown;
+  /** Layer3D.scatter: instances placed on another model's surface. */
+  scatter3d?: Scatter3DSpec;
+  /** Voronoi destruction: the mesh drawn as pieces posed by physics (`world.fracture`). */
+  fracture3d?: Fracture3DSpec;
+  /** Procedural wind sway (bends vertices downwind by height above the mesh base). */
+  wind?: WindConfig;
+  /** Any layer (image, video, layout) drawn each frame and wrapped onto the mesh by its UVs. */
+  textureLayer?: {
+    node: unknown;
+  };
+  /** Set by the compiler: the id of the hoisted texture layer. */
+  textureLayerId?: string;
+  /** Clips blended in order, each over the pose beneath by its weight (replaces animationName). */
+  animationLayers?: ModelAnimationLayer[];
+  /** Two-bone IK: limbs reach scene-space targets. */
+  ik?: TwoBoneIkConstraint[];
+  /** Joints (heads, eyes) turn toward scene-space targets. */
+  lookAt?: LookAtConstraint[];
+  /** Secondary motion simulated from frame 0 (capes, tails, hair). */
+  springBones?: SpringBoneChain[];
+  /** Joints posed directly by name (local Euler degrees, offsets), over the clips. */
+  pose?: Record<string, JointPose>;
+  /**
+   * Blend shape weights by target name (glTF `extras.targetNames`; case is
+   * ignored): `{ eyeBlinkLeft: blink, jawOpen: speech }`. Each value is a
+   * number, `[[frame, v]]` keys, `(frame) => v` or a signal; it replaces the
+   * clip's weight for that target.
+   */
+  morphs?: Record<string, NumberTrack>;
+  /** Bones pointed along scene directions, parents first (pose retargeting). */
+  aim?: AimConstraint[];
+  /** Joints driven by other joints, on top of any the model file declares (eyelids, twist bones). */
+  drive?: JointDriver[];
+  /** Instance nodes: every instance a skinned character on its own clip, phase and speed. */
+  crowd?: CrowdConfig;
 }
 type LayoutNode = FlexNode | BlockNode | BoxNode | TextNode | MediaNode | ShapeNode | CameraNode | LightNode | Model3DNode;
 declare const FlexNodeSchema: z.ZodType<FlexNode>;
@@ -1291,6 +1691,9 @@ declare function computeLayoutSync(yoga: Yoga, input: LayoutInput): LayoutResult
 declare function computeLayout(input: LayoutInput): Promise<LayoutResult>;
 //#endregion
 //#region src/program/animation.d.ts
+/** Common 3D Euler rotation aliases accepted alongside `rotateX` / `rotateY` / `rotateZ`. */
+type AnimatablePropAlias = "rotationX" | "rotationY" | "rotationZ";
+type CanonicalAnimatableProp<P extends AnimatableProp | AnimatablePropAlias> = P extends "rotationX" ? "rotateX" : P extends "rotationY" ? "rotateY" : P extends "rotationZ" ? "rotateZ" : P;
 /**
  * One keyframe as a tuple: `[frame, value]` or `[frame, value, ease]`. The
  * ease shapes the motion arriving at this keyframe from the one before.
@@ -1437,21 +1840,24 @@ declare class LayerAnimation<TProp extends AnimatableProp = AnimatableProp> impl
   static stepped<P extends AnimatableProp = AnimatableProp>(frames?: number): LayerAnimation<P>;
   /** See {@link LayerAnimation.stepped}. */
   stepped(frames?: number): this;
-  static fromTo<P extends AnimatableProp = AnimatableProp>(prop: P, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): LayerAnimation<P>;
+  static fromTo<P extends AnimatableProp | AnimatablePropAlias = AnimatableProp>(prop: P, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): LayerAnimation<CanonicalAnimatableProp<P>>;
   /** A track from a list of `[frame, value, ease?]` keyframes; see {@link LayerAnimation.keys}. */
-  static keys<P extends AnimatableProp = AnimatableProp>(prop: P, keyframes: readonly KeyframeTuple[], options?: TrackKeyOptions): LayerAnimation<P>;
-  static signal<P extends AnimatableProp = AnimatableProp>(prop: P, signalOrHandleId: unknown, options?: SignalTrackOptions): LayerAnimation<P>;
-  static colorSignal<P extends AnimatableProp = AnimatableProp>(prop: P, signalOrHandleId: unknown, options: ColorSignalOptions): LayerAnimation<P>;
+  static keys<P extends AnimatableProp | AnimatablePropAlias = AnimatableProp>(prop: P, keyframes: readonly KeyframeTuple[], options?: TrackKeyOptions): LayerAnimation<CanonicalAnimatableProp<P>>;
+  static signal<P extends AnimatableProp | AnimatablePropAlias = AnimatableProp>(prop: P, signalOrHandleId: unknown, options?: SignalTrackOptions): LayerAnimation<CanonicalAnimatableProp<P>>;
+  static colorSignal<P extends AnimatableProp | AnimatablePropAlias = AnimatableProp>(prop: P, signalOrHandleId: unknown, options: ColorSignalOptions): LayerAnimation<CanonicalAnimatableProp<P>>;
   static kineticSweep(fromOffset?: number, toOffset?: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
   static typewriter(startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
   static letterSpacing(fromSpacing: number, toSpacing: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
-  static wiggle(prop: AnimatableProp, options?: WiggleOptions): LayerAnimation;
-  static spring(prop: AnimatableProp, options?: SpringOptions): LayerAnimation;
+  static wiggle(prop: AnimatableProp | AnimatablePropAlias, options?: WiggleOptions): LayerAnimation;
+  static spring(prop: AnimatableProp | AnimatablePropAlias, options?: SpringOptions): LayerAnimation;
   static firstMargin(fromMargin: number, toMargin: number, options?: FromToOptions): LayerAnimation;
   static strokeWidth(fromWidth: number, toWidth: number, options?: FromToOptions): LayerAnimation;
   static rotateX(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
   static rotateY(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
   static rotateZ(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  static rotationX(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  static rotationY(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  static rotationZ(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
   static rotation(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
   static scale(fromScale: number, toScale: number, options?: FromToOptions): LayerAnimation;
   static scaleX(fromScale: number, toScale: number, options?: FromToOptions): LayerAnimation;
@@ -1462,32 +1868,32 @@ declare class LayerAnimation<TProp extends AnimatableProp = AnimatableProp> impl
    * - `-1`: loops indefinitely.
    * - `N`: repeats N times after the initial iteration (total N + 1 iterations).
    */
-  repeat(count?: number, prop?: AnimatableProp): this;
+  repeat(count?: number, prop?: AnimatableProp | AnimatablePropAlias): this;
   /**
    * Enables or disables yoyo (alternate playback direction on each repeat iteration).
    */
-  yoyo(enable?: boolean, prop?: AnimatableProp): this;
+  yoyo(enable?: boolean, prop?: AnimatableProp | AnimatablePropAlias): this;
   /**
    * Shorthand to loop keyframed animation continuously (infinite repeat).
    * If `options.yoyo` is true, oscillates back and forth.
    */
   loop(options?: {
     yoyo?: boolean;
-  }, prop?: AnimatableProp): this;
+  }, prop?: AnimatableProp | AnimatablePropAlias): this;
   /**
    * Creates a keyframed track animating from fromValue to toValue.
    */
-  fromTo(prop: AnimatableProp, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): this;
+  fromTo(rawProp: AnimatableProp | AnimatablePropAlias, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): this;
   /**
    * Appends a keyframe to an existing track for prop, or creates a new track.
    */
-  keyframe(prop: AnimatableProp, frame: number, value: number | string | boolean, ease?: string | EaseRef): this;
+  keyframe(rawProp: AnimatableProp | AnimatablePropAlias, frame: number, value: number | string | boolean, ease?: string | EaseRef): this;
   /**
    * Adds several keyframes to prop's track at once:
    * `.keys("scale", [[0, 0], [12, 1.1, "back.out"], [20, 1]])`.
    * Frames are rounded to whole frames, so beat math can be passed straight in.
    */
-  keys(prop: AnimatableProp, keyframes: readonly KeyframeTuple[], options?: TrackKeyOptions): this;
+  keys(rawProp: AnimatableProp | AnimatablePropAlias, keyframes: readonly KeyframeTuple[], options?: TrackKeyOptions): this;
   /**
    * Animates opacity from 0 to 1 between startFrame and endFrame.
    */
@@ -1541,6 +1947,12 @@ declare class LayerAnimation<TProp extends AnimatableProp = AnimatableProp> impl
    * Animate rotateZ from fromAngle to toAngle.
    */
   rotateZ(fromAngle: number, toAngle: number, options?: FromToOptions): this;
+  /** Alias for {@link rotateX}. */
+  rotationX(fromAngle: number, toAngle: number, options?: FromToOptions): this;
+  /** Alias for {@link rotateY}. */
+  rotationY(fromAngle: number, toAngle: number, options?: FromToOptions): this;
+  /** Alias for {@link rotateZ}. */
+  rotationZ(fromAngle: number, toAngle: number, options?: FromToOptions): this;
   /**
    * Animate scale along the X axis.
    */
@@ -1573,20 +1985,20 @@ declare class LayerAnimation<TProp extends AnimatableProp = AnimatableProp> impl
    * registered with the program automatically — or the name of a signal
    * registered with `comp.addSignal(name, signal)`.
    */
-  signal(prop: AnimatableProp, signalOrHandleId: unknown, options?: SignalTrackOptions): this;
+  signal(rawProp: AnimatableProp | AnimatablePropAlias, signalOrHandleId: unknown, options?: SignalTrackOptions): this;
   /**
    * Modulates color interpolation based on an active signal (object or
    * registered name, as in {@link LayerAnimation.signal}).
    */
-  colorSignal(prop: AnimatableProp, signalOrHandleId: unknown, options: ColorSignalOptions): this;
+  colorSignal(rawProp: AnimatableProp | AnimatablePropAlias, signalOrHandleId: unknown, options: ColorSignalOptions): this;
   /**
    * Adds organic Perlin noise wiggling to a property.
    */
-  wiggle(prop: AnimatableProp, options?: WiggleOptions): this;
+  wiggle(rawProp: AnimatableProp | AnimatablePropAlias, options?: WiggleOptions): this;
   /**
    * Adds physical harmonic spring overshoot behavior to a property transition.
    */
-  spring(prop: AnimatableProp, options?: SpringOptions): this;
+  spring(rawProp: AnimatableProp | AnimatablePropAlias, options?: SpringOptions): this;
   /**
    * Follows a 2D or 3D path with constant arc-length velocity, automatic orientation,
    * banking into turns, and optional easing.
@@ -1720,14 +2132,26 @@ interface LintOptions {
    * the emoji would draw nothing. Unknown (omitted): not checked.
    */
   emojiFont?: boolean;
+  /**
+   * Share of a scatter's surface area its slope and altitude filters keep
+   * (0..1), or undefined when the surface can't be measured here (a model
+   * file not loaded yet). framefields passes the real mesher; this module
+   * has no geometry of its own.
+   */
+  scatterCoverage?: (scatter: Scatter3DSpec) => number | undefined;
 }
 declare function lintComposition(config: Pick<CompositorProgramConfig, "width" | "height" | "layout"> & {
   backgroundColor?: string;
 }, options?: LintOptions): RenderDiagnostic[];
 //#endregion
 //#region src/program/mattes.d.ts
-/** Returns the tree with every `matte` and `relief` turned into a sibling companion layer. */
-declare function hoistMattes<T extends LayoutNode>(nodes: readonly T[]): T[];
+/** The picture a mesh's UVs read: the frame's size from the top-left corner unless placed. */
+interface HoistOptions {
+  width?: number;
+  height?: number;
+}
+/** Returns the tree with every `matte`, `relief` and `textureLayer` turned into a sibling companion layer. */
+declare function hoistMattes<T extends LayoutNode>(nodes: readonly T[], size?: HoistOptions): T[];
 //#endregion
 //#region src/program/media-signal.d.ts
 /** Where a signal-driven media layer sits on the composition clock. */
@@ -1944,158 +2368,428 @@ declare function compositorToProgram(config: CompositorProgramConfig, options: C
  * Recursively gather every node op from a render tree (in order), stopping at
  * nested scene compositions: their layers belong to their own render.
  */
-declare function collectNodeOps(nodes: VirtualMediaData[]): VirtualMediaData[];
-//#endregion
-//#region src/program/validate.d.ts
-//#endregion
-//#region ../components/dist/toolkit-HF1uj72e.d.mts
-//#region src/core/audio.d.ts
-
-/** A track's spectrum and loudness per frame, every value 0–1. */
-interface AudioLevels {
-  fps: number;
-  /** Length in frames. */
-  frames: number;
-  /** `[band][frame]`, low → high frequencies. */
-  bands: number[][];
-  /** Loudness envelope, `[frame]`. */
-  level: number[];
-  /** Onset frames (kicks, plosives), from low-band flux. */
-  beats: number[];
-}
-interface AnalyzeOptions {
-  /** Frame rate of the composition. Default 30. */
-  fps?: number;
-  /** Log-spaced bands. Default 32. */
-  bands?: number;
-  /** Lowest band edge, Hz. Default 50. */
-  minHz?: number;
-  /** Highest band edge, Hz. Default 12 000 (or Nyquist). */
-  maxHz?: number;
-}
-/** Band edges in Hz, log-spaced. */
-declare function bandEdges(count: number, minHz: number, maxHz: number): number[];
 /**
- * Analyse decoded audio: a Hann-windowed FFT per frame into log-spaced
- * bands, each normalised to its own 98th percentile (floored 30 dB under the
- * loudest band's, so a quiet band is not stretched into noise), an RMS level
- * envelope, and onsets from low-band spectral flux.
+ * Every layer, 3D scenes' layers included, with its start on the
+ * composition's clock. A scene's layers run on the scene's own clock, which
+ * starts where the scene's layer does, so their starts are offset by it.
  */
-declare function analyzeChannels(channels: readonly Float32Array[], sampleRate: number, options?: AnalyzeOptions): AudioLevels;
-/** Average adjacent bands down (or repeat them up) to `count` bands. */
-declare function resampleBands(bands: readonly (readonly number[])[], count: number): number[][];
-/** Each value falls no faster than `release` frames from its peak (attack is instant). */
-declare function smoothRelease(values: readonly number[], release: number): number[];
-/** The schema for `AudioLevels` props (Waveform, Captions `pulse`). */
-declare function audioLevelsSchema(): z.ZodType<AudioLevels>;
+
+declare function collectNodeOps(nodes: VirtualMediaData[]): VirtualMediaData[];
 //#endregion
-//#region src/core/bake.d.ts
-/**
- * Turn per-frame values into a few linear keyframes. Components solve motion
- * offline (springs, camera follow, arc-length travel) and bake it, so the
- * output stays plain keyframe JSON that seeks exactly.
- */
-/** `[frame, value]`: a linear keyframe, as `LayerAnimation.keys` takes it. */
-type BakedKey = [frame: number, value: number];
-interface BakeOptions {
-  /** Max deviation (in the value's units) of the simplified curve. Default 0.25. */
-  tolerance?: number;
-}
-/**
- * Simplify `values` (one per frame, starting at `startFrame`) to linear keys
- * whose interpolation stays within `tolerance` of every sample
- * (Ramer–Douglas–Peucker on the frame/value polyline). First and last
- * samples are always kept.
- */
-declare function bakeSamples(values: readonly number[], startFrame?: number, options?: BakeOptions): BakedKey[];
-/** Sample `fn` on every frame in [start, end] and bake it. */
-declare function bakeFunction(fn: (frame: number) => number, start: number, end: number, options?: BakeOptions): BakedKey[];
-/**
- * Damped spring from 0 to 1 in closed form: `stiffness` (k), `damping` (c),
- * `mass` (m), sampled in seconds. Under-damped springs overshoot.
- */
-declare function springAt(seconds: number, {
-  stiffness,
-  damping,
-  mass
-}?: {
-  stiffness?: number | undefined;
-  damping?: number | undefined;
-  mass?: number | undefined;
-}): number;
-/**
- * Frames until a spring stays within `epsilon` of rest, at `fps`; capped at
- * `max` frames.
- */
-declare function springSettleFrames(fps: number, options?: Parameters<typeof springAt>[1], epsilon?: number, max?: number): number;
+//#region src/program/track-sampler.d.ts
 /**
- * A spring from `from` to `to` starting at frame `start`, baked to linear
- * keys (within `tolerance`, default 0.2 % of the distance).
- */
-declare function springKeys(start: number, from: number, to: number, fps: number, options?: Parameters<typeof springAt>[1], tolerance?: number): BakedKey[];
-/**
- * Per-frame values (frames 0…`length`) that spring to each new target from
- * wherever they are: a retarget mid-flight starts from the current value
- * (velocity isn't carried over). Bake with `bakeSamples` or bind as a signal.
+ * Solves a cubic bezier curve defined by control points (x1, y1) and (x2, y2)
+ * for a given progress parameter t in [0, 1].
  */
-declare function springTrack(changes: ReadonlyArray<readonly [frame: number, target: number]>, initial: number, length: number, fps: number, options?: {
-  stiffness: number;
-  damping: number;
-}): number[];
 //#endregion
-//#region src/core/color.d.ts
+//#region ../components/dist/typing-c419Mp0t.d.mts
+//#region src/core/path.d.ts
 /**
- * Color math for components: parse, fade, mix and judge lightness. Accepts
- * `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, `rgb()` / `rgba()` (comma or
- * space syntax) and `white` / `black` / `transparent`. Anything else (a
- * gradient, `oklch()`, a CSS variable) passes through untouched where a
- * function returns a color, and counts as unknown where it returns a number.
+ * 2D path math: smooth curves through points, arc-length sampling, and SVG
+ * path strings. Used for pointer travel, camera moves and drawn marks.
  */
-/** Red, green, blue (0–255) and alpha (0–1). */
-type Rgba = [r: number, g: number, b: number, a: number];
-/** The color's channels, or null when the format isn't one listed above. */
-declare function parseColor(color: string): Rgba | null;
-/** `color` at `alpha` (replacing its own); unknown formats pass through. */
-declare function withAlpha(color: string, alpha: number): string;
+type Vec2$1 = [x: number, y: number];
+declare const dist: (a: Vec2$1, b: Vec2$1) => number;
+declare const lerp2: (a: Vec2$1, b: Vec2$1, t: number) => Vec2$1;
 /**
- * `color` fully transparent, keeping its hue, so a gradient fading to it has
- * no dark fringe. Unknown formats give plain `rgba(0,0,0,0)`.
+ * Centripetal Catmull-Rom through `points`, flattened to a polyline with
+ * `steps` samples per segment. Centripetal (alpha 0.5) never loops or cusps
+ * between close points, which matters for pointer paths.
  */
-declare function transparent(color: string): string;
-/** Mix `a` toward `b` by `t` (0 → a, 1 → b): `#rrggbb` when both are opaque. */
-declare function mix(a: string, b: string, t: number): string;
-/** WCAG relative luminance (0 black … 1 white), or null for unknown formats. */
-declare function luminance(color: string): number | null;
-/** WCAG contrast ratio of two colors, or null when either is unknown. */
-declare function contrastRatio(a: string, b: string): number | null;
+declare function catmullRom(points: readonly Vec2$1[], steps?: number): Vec2$1[];
+/** A polyline with a cumulative arc-length table, sampled by distance. */
+interface ArcPath {
+  readonly points: readonly Vec2$1[];
+  readonly length: number;
+  /** Point at `u` ∈ [0, 1] of the total length. */
+  at(u: number): Vec2$1;
+  /** Unit tangent direction (radians) at `u`. */
+  angleAt(u: number): number;
+}
+declare function arcPath(points: readonly Vec2$1[]): ArcPath;
+/** SVG path data for a polyline (optionally closed). Rounded to 0.01 px. */
+declare function toPathData(points: readonly Vec2$1[], closed?: boolean): string;
 /**
- * True when black text reads better than white on `color` (luminance above
- * ~0.18). Unknown formats count as dark.
+ * Scale and offset SVG path data: `x' = x × scale + dx`. Absolute commands
+ * move by the offset; relative ones (and arc radii) only scale. Used to
+ * size glyphs designed on a small grid, and logo marks in their viewBox.
  */
-declare function isLight(color: string): boolean;
-/** Whichever of `light` / `dark` ink reads better on `background`. */
-declare function inkOn(background: string, light?: string, dark?: string): string;
+declare function transformPathData(d: string, scale: number, dx?: number, dy?: number): string;
 //#endregion
-//#region src/core/theme.d.ts
-/** A spring, as `springKeys` / `springAt` take it. */
-interface Spring {
-  stiffness: number;
-  damping: number;
+//#region src/core/draw.d.ts
+interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface HandOptions {
+  /** Wobble amount in px at theme scale 1. 0 = clean geometry. */
+  wobble?: number;
+  seed?: number;
 }
+/** Keys for `trimEnd` 0 → 1 between `start` and `start + duration`. */
+declare function drawOnKeys(start: number, duration: number, ease?: string): KeyframeTuple[];
 /**
- * How far a surface sits above what's behind it: a soft drop shadow, plus a
- * faint highlight along its top edge so it reads as a lit object.
+ * Perturb points with seeded, low-frequency noise: neighbouring points move
+ * together, so lines bend instead of jittering.
  */
-interface Elevation {
-  /** Shadow opacity, 0–1. */
-  opacity: number;
-  /** Shadow offset (straight down) and blur, px at theme scale 1. */
-  distance: number;
-  size: number;
-  /** Opacity of the 1 px top-edge highlight, 0–1 (0: none). */
-  edge: number;
-}
-interface Theme {
+declare function wobblePoints(points: readonly Vec2$1[], {
+  wobble,
+  seed
+}?: HandOptions, variant?: number): Vec2$1[];
+/** An ellipse around `rect` (+ padding); hand-drawn ellipses overshoot their start. */
+declare function ellipsePath(rect: Rect, {
+  padding,
+  wobble,
+  seed
+}?: HandOptions & {
+  padding?: number;
+}, variant?: number): string;
+/** A rectangle around `rect` (+ padding). */
+declare function boxPath(rect: Rect, {
+  padding,
+  wobble,
+  seed
+}?: HandOptions & {
+  padding?: number;
+}, variant?: number): string;
+/** A horizontal stroke from `from` to `to`. */
+declare function linePath(from: Vec2$1, to: Vec2$1, {
+  wobble,
+  seed
+}?: HandOptions, variant?: number): string;
+/** A wavy line from `from` to `to`, `waves` crests of `amplitude` px. */
+declare function squigglePath(from: Vec2$1, to: Vec2$1, {
+  amplitude,
+  waves,
+  wobble,
+  seed
+}?: HandOptions & {
+  amplitude?: number;
+  waves?: number;
+}, variant?: number): string;
+type ArrowCurve = "straight" | "arc" | "swoop";
+interface ArrowGeometry {
+  /** The shaft, drawn from `from` to just before `to`. */
+  shaft: string;
+  /** The head, two strokes meeting at `to`. */
+  head: string;
+}
+/** An arrow from `from` to `to` with a separate head path. */
+declare function arrowPaths(from: Vec2$1, to: Vec2$1, {
+  curve,
+  headSize,
+  wobble,
+  seed
+}?: HandOptions & {
+  curve?: ArrowCurve;
+  headSize?: number;
+}, variant?: number): ArrowGeometry;
+/**
+ * Hand-drawn "boil": `d` keys that switch between `variants` poses every
+ * `every` frames with hold interpolation, from `start` to `end`.
+ * `makePath(variant)` must be deterministic for a variant index.
+ */
+declare function boilKeys(makePath: (variant: number) => string, {
+  start,
+  end,
+  every,
+  variants
+}: {
+  start: number;
+  end: number;
+  every: number;
+  variants?: number;
+}): KeyframeTuple[];
+//#endregion
+//#region src/core/text.d.ts
+/** The subset of `FontManager.measure` options components pass. */
+interface MeasureOptions {
+  fontFamily: string;
+  fontSize?: number;
+  fontWeight?: string | number;
+  letterSpacing?: number;
+  lineHeight?: number;
+  width?: number;
+  align?: "left" | "center" | "right";
+  direction?: "ltr" | "rtl" | "auto";
+}
+interface GlyphBox {
+  char: string;
+  index: number;
+  x: number;
+  width: number;
+  line: number;
+  rtl?: boolean;
+}
+/** The subset of `FontManager.measure` results components read. */
+interface Metrics$1 {
+  width: number;
+  height: number;
+  lines: number;
+  lineHeight: number;
+  glyphs: GlyphBox[];
+  caretX(count: number): number;
+}
+type MeasureFn = (text: string, options: MeasureOptions) => Metrics$1;
+interface WordRange {
+  text: string;
+  /** Index of the first character (code units). */
+  start: number;
+  /** Index after the last character. */
+  end: number;
+  index: number;
+}
+/** Whitespace-separated words with their character ranges. */
+declare function wordRanges(text: string): WordRange[];
+/** Character range of the `nth` match of `match` in `text`, or null. */
+declare function findRange(text: string, match: string | RegExp, nth?: number): [number, number] | null;
+/**
+ * Per-line x offset that `align` adds inside a box of `options.width`
+ * (measurement itself lays every line out from the left edge).
+ */
+declare function lineShift(metrics: Metrics$1, line: number, options: MeasureOptions): number;
+/**
+ * The boxes characters [start, end) cover: one rect per line, spanning the
+ * glyphs' advances, `lineHeight` tall. Whitespace at a line's ends is
+ * excluded.
+ */
+declare function rangeRects(metrics: Metrics$1, start: number, end: number, options: MeasureOptions): Rect[];
+//#endregion
+//#region src/core/targets.d.ts
+type Anchor = "center" | "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right"
+/** Where a pointer should land: the centre, or mid-left for text. */ | "tip";
+/** A node as targets read it: absolute numeric geometry, or text. */
+interface TargetNode {
+  id?: string;
+  kind?: string;
+  x?: unknown;
+  y?: unknown;
+  width?: unknown;
+  height?: unknown;
+  text?: unknown;
+  content?: unknown;
+  [key: string]: unknown;
+}
+/** The frame context signals are read with. */
+interface FrameContextLike {
+  frame: number;
+  fps: number;
+  time: number;
+  duration: number;
+  durationMs: number;
+  progress: number;
+  deltaTime: number;
+}
+/** A per-frame value: a signal (what tracked objects expose) or a function. */
+type FrameValue = {
+  get(ctx?: FrameContextLike): number;
+} | ((frame: number) => number);
+interface TrackedObjectLike {
+  x: FrameValue;
+  y: FrameValue;
+  width: FrameValue;
+  height: FrameValue;
+}
+type Target = Vec2$1 | Rect | {
+  node: TargetNode;
+  anchor?: Anchor;
+} | {
+  text: TargetNode;
+  match?: string | RegExp;
+  range?: [number, number];
+  nth?: number;
+  anchor?: Anchor;
+} | {
+  track: TrackedObjectLike;
+  anchor?: Anchor;
+} | ((frame: number) => Vec2$1 | Rect);
+interface TargetContext {
+  measure?: MeasureFn;
+  /** Frame rate signals are sampled at (tracked targets). Default 30. */
+  fps?: number;
+  /** Font defaults for text nodes that don't set them. */
+  textDefaults?: Partial<MeasureOptions>;
+}
+type ResolvedTarget = {
+  kind: "static";
+  rects: Rect[];
+  anchor: Anchor;
+} | {
+  kind: "dynamic";
+  at: (frame: number) => Rect;
+  anchor: Anchor;
+};
+/** Resolve a target to rects (static) or a per-frame rect (dynamic). */
+declare function resolveTarget(target: Target, ctx?: TargetContext): ResolvedTarget;
+/** A text target's string, measured glyphs and range, and where the node sits. */
+interface TextLayout {
+  content: string;
+  metrics: ReturnType<MeasureFn>;
+  options: MeasureOptions;
+  range: [number, number];
+  /** The node's x / y: add to measured glyph positions. */
+  x: number;
+  y: number;
+}
+/** Measure a text target the way the renderer lays it out. */
+declare function textLayout(target: Extract<Target, {
+  text: TargetNode;
+}>, ctx: TargetContext): TextLayout;
+/** The union rect of `rects`. */
+declare function boundsOf(rects: readonly Rect[]): Rect;
+/** The point of `rect` named by `anchor`. `tip` on text = start of the first line, mid-height. */
+declare function anchorPoint(rect: Rect, anchor?: Anchor, isText?: boolean): Vec2$1;
+/** The point a resolved target names at `frame` (static targets ignore frame). */
+declare function targetPoint(resolved: ResolvedTarget, frame?: number, isText?: boolean): Vec2$1;
+//#endregion
+//#region src/core/audio.d.ts
+/** A track's spectrum and loudness per frame, every value 0–1. */
+interface AudioLevels {
+  fps: number;
+  /** Length in frames. */
+  frames: number;
+  /** `[band][frame]`, low → high frequencies. */
+  bands: number[][];
+  /** Loudness envelope, `[frame]`. */
+  level: number[];
+  /** Onset frames (kicks, plosives), from low-band flux. */
+  beats: number[];
+}
+interface AnalyzeOptions {
+  /** Frame rate of the composition. Default 30. */
+  fps?: number;
+  /** Log-spaced bands. Default 32. */
+  bands?: number;
+  /** Lowest band edge, Hz. Default 50. */
+  minHz?: number;
+  /** Highest band edge, Hz. Default 12 000 (or Nyquist). */
+  maxHz?: number;
+}
+/** Band edges in Hz, log-spaced. */
+declare function bandEdges(count: number, minHz: number, maxHz: number): number[];
+/**
+ * Analyse decoded audio: a Hann-windowed FFT per frame into log-spaced
+ * bands, each normalised to its own 98th percentile (floored 30 dB under the
+ * loudest band's, so a quiet band is not stretched into noise), an RMS level
+ * envelope, and onsets from low-band spectral flux.
+ */
+declare function analyzeChannels(channels: readonly Float32Array[], sampleRate: number, options?: AnalyzeOptions): AudioLevels;
+/** Average adjacent bands down (or repeat them up) to `count` bands. */
+declare function resampleBands(bands: readonly (readonly number[])[], count: number): number[][];
+/** Each value falls no faster than `release` frames from its peak (attack is instant). */
+declare function smoothRelease(values: readonly number[], release: number): number[];
+/** The schema for `AudioLevels` props (Waveform, Captions `pulse`). */
+declare function audioLevelsSchema(): z.ZodType<AudioLevels>;
+//#endregion
+//#region src/core/bake.d.ts
+/**
+ * Turn per-frame values into a few linear keyframes. Components solve motion
+ * offline (springs, camera follow, arc-length travel) and bake it, so the
+ * output stays plain keyframe JSON that seeks exactly.
+ */
+/** `[frame, value]`: a linear keyframe, as `LayerAnimation.keys` takes it. */
+type BakedKey = [frame: number, value: number];
+interface BakeOptions {
+  /** Max deviation (in the value's units) of the simplified curve. Default 0.25. */
+  tolerance?: number;
+}
+/**
+ * Simplify `values` (one per frame, starting at `startFrame`) to linear keys
+ * whose interpolation stays within `tolerance` of every sample
+ * (Ramer–Douglas–Peucker on the frame/value polyline). First and last
+ * samples are always kept.
+ */
+declare function bakeSamples(values: readonly number[], startFrame?: number, options?: BakeOptions): BakedKey[];
+/** Sample `fn` on every frame in [start, end] and bake it. */
+declare function bakeFunction(fn: (frame: number) => number, start: number, end: number, options?: BakeOptions): BakedKey[];
+/**
+ * Damped spring from 0 to 1 in closed form: `stiffness` (k), `damping` (c),
+ * `mass` (m), sampled in seconds. Under-damped springs overshoot.
+ */
+declare function springAt(seconds: number, {
+  stiffness,
+  damping,
+  mass
+}?: {
+  stiffness?: number | undefined;
+  damping?: number | undefined;
+  mass?: number | undefined;
+}): number;
+/**
+ * Frames until a spring stays within `epsilon` of rest, at `fps`; capped at
+ * `max` frames.
+ */
+declare function springSettleFrames(fps: number, options?: Parameters<typeof springAt>[1], epsilon?: number, max?: number): number;
+/**
+ * A spring from `from` to `to` starting at frame `start`, baked to linear
+ * keys (within `tolerance`, default 0.2 % of the distance).
+ */
+declare function springKeys(start: number, from: number, to: number, fps: number, options?: Parameters<typeof springAt>[1], tolerance?: number): BakedKey[];
+/**
+ * Per-frame values (frames 0…`length`) that spring to each new target from
+ * wherever they are: a retarget mid-flight starts from the current value
+ * (velocity isn't carried over). Bake with `bakeSamples` or bind as a signal.
+ */
+declare function springTrack(changes: ReadonlyArray<readonly [frame: number, target: number]>, initial: number, length: number, fps: number, options?: {
+  stiffness: number;
+  damping: number;
+}): number[];
+//#endregion
+//#region src/core/color.d.ts
+/**
+ * Color math for components: parse, fade, mix and judge lightness. Accepts
+ * `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, `rgb()` / `rgba()` (comma or
+ * space syntax) and `white` / `black` / `transparent`. Anything else (a
+ * gradient, `oklch()`, a CSS variable) passes through untouched where a
+ * function returns a color, and counts as unknown where it returns a number.
+ */
+/** Red, green, blue (0–255) and alpha (0–1). */
+type Rgba = [r: number, g: number, b: number, a: number];
+/** The color's channels, or null when the format isn't one listed above. */
+declare function parseColor(color: string): Rgba | null;
+/** `color` at `alpha` (replacing its own); unknown formats pass through. */
+declare function withAlpha(color: string, alpha: number): string;
+/**
+ * `color` fully transparent, keeping its hue, so a gradient fading to it has
+ * no dark fringe. Unknown formats give plain `rgba(0,0,0,0)`.
+ */
+declare function transparent(color: string): string;
+/** Mix `a` toward `b` by `t` (0 → a, 1 → b): `#rrggbb` when both are opaque. */
+declare function mix(a: string, b: string, t: number): string;
+/** WCAG relative luminance (0 black … 1 white), or null for unknown formats. */
+declare function luminance(color: string): number | null;
+/** WCAG contrast ratio of two colors, or null when either is unknown. */
+declare function contrastRatio(a: string, b: string): number | null;
+/**
+ * True when black text reads better than white on `color` (luminance above
+ * ~0.18). Unknown formats count as dark.
+ */
+declare function isLight(color: string): boolean;
+/** Whichever of `light` / `dark` ink reads better on `background`. */
+declare function inkOn(background: string, light?: string, dark?: string): string;
+//#endregion
+//#region src/core/theme.d.ts
+/** A spring, as `springKeys` / `springAt` take it. */
+interface Spring {
+  stiffness: number;
+  damping: number;
+}
+/**
+ * How far a surface sits above what's behind it: a soft drop shadow, plus a
+ * faint highlight along its top edge so it reads as a lit object.
+ */
+interface Elevation {
+  /** Shadow opacity, 0–1. */
+  opacity: number;
+  /** Shadow offset (straight down) and blur, px at theme scale 1. */
+  distance: number;
+  size: number;
+  /** Opacity of the 1 px top-edge highlight, 0–1 (0: none). */
+  edge: number;
+}
+interface Theme {
   /** Whether `bg` is dark or light; components pick shadows and chrome by it. */
   mode: "dark" | "light";
   color: {
@@ -2318,257 +3012,83 @@ declare const themes: {
       mid: Elevation;
       high: Elevation;
     };
-    readonly motion: {
-      readonly ease: {
-        readonly enter: "back.out(1.8)";
-        readonly exit: string;
-        readonly move: string;
-        readonly snap: string;
-      };
-      readonly speed: {
-        readonly fast: 6;
-        readonly base: 12;
-        readonly slow: 24;
-      };
-      readonly spring: {
-        readonly settle: {
-          readonly stiffness: 300;
-          readonly damping: 26;
-        };
-        readonly base: {
-          readonly stiffness: 340;
-          readonly damping: 22;
-        };
-        readonly pop: {
-          readonly stiffness: 400;
-          readonly damping: 14;
-        };
-      };
-    };
-    readonly scale: 1;
-    readonly radius: {
-      sm: number;
-      md: number;
-      lg: number;
-      pill: number;
-    };
-    readonly stroke: {
-      hair: number;
-      base: number;
-      bold: number;
-    };
-    readonly mode: "dark";
-    readonly color: {
-      readonly bg: "#000000";
-      readonly surface: "#111111";
-      readonly raised: "#1c1c1c";
-      readonly line: "#333333";
-      readonly ink: "#ffffff";
-      readonly muted: "#a3a3a3";
-      readonly accent: "#c6ff00";
-      readonly accent2: "#ff2e88";
-      readonly positive: "#00e676";
-      readonly negative: "#ff1744";
-      readonly highlight: "#c6ff00";
-      readonly shadow: "#000000";
-    };
-    readonly font: {
-      display: string;
-      body: string;
-      mono: string;
-      hand?: string;
-    };
-    readonly weight: {
-      regular: number;
-      medium: number;
-      semibold: number;
-      bold: number;
-      heavy: number;
-    };
-  };
-};
-type ThemeName = keyof typeof themes;
-/**
- * Merge a partial theme over a base (default `themes.graphite`). Throws when
- * `ink` on `surface` falls below WCAG 4.5:1 and both are hex colors.
- */
-declare function defineTheme(input?: ThemeInput | Theme, base?: Theme): Theme;
-/** A theme's duration token in frames at `fps`. */
-declare function themeFrames(theme: Theme, speed: keyof Theme["motion"]["speed"], fps?: number): number;
-//#endregion
-//#region src/core/path.d.ts
-/**
- * 2D path math: smooth curves through points, arc-length sampling, and SVG
- * path strings. Used for pointer travel, camera moves and drawn marks.
- */
-type Vec2$1 = [x: number, y: number];
-declare const dist: (a: Vec2$1, b: Vec2$1) => number;
-declare const lerp2: (a: Vec2$1, b: Vec2$1, t: number) => Vec2$1;
-/**
- * Centripetal Catmull-Rom through `points`, flattened to a polyline with
- * `steps` samples per segment. Centripetal (alpha 0.5) never loops or cusps
- * between close points, which matters for pointer paths.
- */
-declare function catmullRom(points: readonly Vec2$1[], steps?: number): Vec2$1[];
-/** A polyline with a cumulative arc-length table, sampled by distance. */
-interface ArcPath {
-  readonly points: readonly Vec2$1[];
-  readonly length: number;
-  /** Point at `u` ∈ [0, 1] of the total length. */
-  at(u: number): Vec2$1;
-  /** Unit tangent direction (radians) at `u`. */
-  angleAt(u: number): number;
-}
-declare function arcPath(points: readonly Vec2$1[]): ArcPath;
-/** SVG path data for a polyline (optionally closed). Rounded to 0.01 px. */
-declare function toPathData(points: readonly Vec2$1[], closed?: boolean): string;
-/**
- * Scale and offset SVG path data: `x' = x × scale + dx`. Absolute commands
- * move by the offset; relative ones (and arc radii) only scale. Used to
- * size glyphs designed on a small grid, and logo marks in their viewBox.
- */
-declare function transformPathData(d: string, scale: number, dx?: number, dy?: number): string;
-//#endregion
-//#region src/core/draw.d.ts
-interface Rect {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-interface HandOptions {
-  /** Wobble amount in px at theme scale 1. 0 = clean geometry. */
-  wobble?: number;
-  seed?: number;
-}
-/** Keys for `trimEnd` 0 → 1 between `start` and `start + duration`. */
-declare function drawOnKeys(start: number, duration: number, ease?: string): KeyframeTuple[];
-/**
- * Perturb points with seeded, low-frequency noise: neighbouring points move
- * together, so lines bend instead of jittering.
- */
-declare function wobblePoints(points: readonly Vec2$1[], {
-  wobble,
-  seed
-}?: HandOptions, variant?: number): Vec2$1[];
-/** An ellipse around `rect` (+ padding); hand-drawn ellipses overshoot their start. */
-declare function ellipsePath(rect: Rect, {
-  padding,
-  wobble,
-  seed
-}?: HandOptions & {
-  padding?: number;
-}, variant?: number): string;
-/** A rectangle around `rect` (+ padding). */
-declare function boxPath(rect: Rect, {
-  padding,
-  wobble,
-  seed
-}?: HandOptions & {
-  padding?: number;
-}, variant?: number): string;
-/** A horizontal stroke from `from` to `to`. */
-declare function linePath(from: Vec2$1, to: Vec2$1, {
-  wobble,
-  seed
-}?: HandOptions, variant?: number): string;
-/** A wavy line from `from` to `to`, `waves` crests of `amplitude` px. */
-declare function squigglePath(from: Vec2$1, to: Vec2$1, {
-  amplitude,
-  waves,
-  wobble,
-  seed
-}?: HandOptions & {
-  amplitude?: number;
-  waves?: number;
-}, variant?: number): string;
-type ArrowCurve = "straight" | "arc" | "swoop";
-interface ArrowGeometry {
-  /** The shaft, drawn from `from` to just before `to`. */
-  shaft: string;
-  /** The head, two strokes meeting at `to`. */
-  head: string;
-}
-/** An arrow from `from` to `to` with a separate head path. */
-declare function arrowPaths(from: Vec2$1, to: Vec2$1, {
-  curve,
-  headSize,
-  wobble,
-  seed
-}?: HandOptions & {
-  curve?: ArrowCurve;
-  headSize?: number;
-}, variant?: number): ArrowGeometry;
-/**
- * Hand-drawn "boil": `d` keys that switch between `variants` poses every
- * `every` frames with hold interpolation, from `start` to `end`.
- * `makePath(variant)` must be deterministic for a variant index.
- */
-declare function boilKeys(makePath: (variant: number) => string, {
-  start,
-  end,
-  every,
-  variants
-}: {
-  start: number;
-  end: number;
-  every: number;
-  variants?: number;
-}): KeyframeTuple[];
-//#endregion
-//#region src/core/text.d.ts
-/** The subset of `FontManager.measure` options components pass. */
-interface MeasureOptions {
-  fontFamily: string;
-  fontSize?: number;
-  fontWeight?: string | number;
-  letterSpacing?: number;
-  lineHeight?: number;
-  width?: number;
-  align?: "left" | "center" | "right";
-  direction?: "ltr" | "rtl" | "auto";
-}
-interface GlyphBox {
-  char: string;
-  index: number;
-  x: number;
-  width: number;
-  line: number;
-  rtl?: boolean;
-}
-/** The subset of `FontManager.measure` results components read. */
-interface Metrics$1 {
-  width: number;
-  height: number;
-  lines: number;
-  lineHeight: number;
-  glyphs: GlyphBox[];
-  caretX(count: number): number;
-}
-type MeasureFn = (text: string, options: MeasureOptions) => Metrics$1;
-interface WordRange {
-  text: string;
-  /** Index of the first character (code units). */
-  start: number;
-  /** Index after the last character. */
-  end: number;
-  index: number;
-}
-/** Whitespace-separated words with their character ranges. */
-declare function wordRanges(text: string): WordRange[];
-/** Character range of the `nth` match of `match` in `text`, or null. */
-declare function findRange(text: string, match: string | RegExp, nth?: number): [number, number] | null;
-/**
- * Per-line x offset that `align` adds inside a box of `options.width`
- * (measurement itself lays every line out from the left edge).
- */
-declare function lineShift(metrics: Metrics$1, line: number, options: MeasureOptions): number;
+    readonly motion: {
+      readonly ease: {
+        readonly enter: "back.out(1.8)";
+        readonly exit: string;
+        readonly move: string;
+        readonly snap: string;
+      };
+      readonly speed: {
+        readonly fast: 6;
+        readonly base: 12;
+        readonly slow: 24;
+      };
+      readonly spring: {
+        readonly settle: {
+          readonly stiffness: 300;
+          readonly damping: 26;
+        };
+        readonly base: {
+          readonly stiffness: 340;
+          readonly damping: 22;
+        };
+        readonly pop: {
+          readonly stiffness: 400;
+          readonly damping: 14;
+        };
+      };
+    };
+    readonly scale: 1;
+    readonly radius: {
+      sm: number;
+      md: number;
+      lg: number;
+      pill: number;
+    };
+    readonly stroke: {
+      hair: number;
+      base: number;
+      bold: number;
+    };
+    readonly mode: "dark";
+    readonly color: {
+      readonly bg: "#000000";
+      readonly surface: "#111111";
+      readonly raised: "#1c1c1c";
+      readonly line: "#333333";
+      readonly ink: "#ffffff";
+      readonly muted: "#a3a3a3";
+      readonly accent: "#c6ff00";
+      readonly accent2: "#ff2e88";
+      readonly positive: "#00e676";
+      readonly negative: "#ff1744";
+      readonly highlight: "#c6ff00";
+      readonly shadow: "#000000";
+    };
+    readonly font: {
+      display: string;
+      body: string;
+      mono: string;
+      hand?: string;
+    };
+    readonly weight: {
+      regular: number;
+      medium: number;
+      semibold: number;
+      bold: number;
+      heavy: number;
+    };
+  };
+};
+type ThemeName = keyof typeof themes;
 /**
- * The boxes characters [start, end) cover: one rect per line, spanning the
- * glyphs' advances, `lineHeight` tall. Whitespace at a line's ends is
- * excluded.
+ * Merge a partial theme over a base (default `themes.graphite`). Throws when
+ * `ink` on `surface` falls below WCAG 4.5:1 and both are hex colors.
  */
-declare function rangeRects(metrics: Metrics$1, start: number, end: number, options: MeasureOptions): Rect[];
+declare function defineTheme(input?: ThemeInput | Theme, base?: Theme): Theme;
+/** A theme's duration token in frames at `fps`. */
+declare function themeFrames(theme: Theme, speed: keyof Theme["motion"]["speed"], fps?: number): number;
 //#endregion
 //#region src/core/host.d.ts
 /** Photoshop-style layer styles (framefields' `LayerStyle`). Omitted styles are off. */
@@ -3470,97 +3990,6 @@ interface FontNeed {
 }
 declare function defineMeta(meta: ComponentMeta): ComponentMeta;
 //#endregion
-//#region src/core/targets.d.ts
-type Anchor = "center" | "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right"
-/** Where a pointer should land: the centre, or mid-left for text. */ | "tip";
-/** A node as targets read it: absolute numeric geometry, or text. */
-interface TargetNode {
-  id?: string;
-  kind?: string;
-  x?: unknown;
-  y?: unknown;
-  width?: unknown;
-  height?: unknown;
-  text?: unknown;
-  content?: unknown;
-  [key: string]: unknown;
-}
-/** The frame context signals are read with. */
-interface FrameContextLike {
-  frame: number;
-  fps: number;
-  time: number;
-  duration: number;
-  durationMs: number;
-  progress: number;
-  deltaTime: number;
-}
-/** A per-frame value: a signal (what tracked objects expose) or a function. */
-type FrameValue = {
-  get(ctx?: FrameContextLike): number;
-} | ((frame: number) => number);
-interface TrackedObjectLike {
-  x: FrameValue;
-  y: FrameValue;
-  width: FrameValue;
-  height: FrameValue;
-}
-type Target = Vec2$1 | Rect | {
-  node: TargetNode;
-  anchor?: Anchor;
-} | {
-  text: TargetNode;
-  match?: string | RegExp;
-  range?: [number, number];
-  nth?: number;
-  anchor?: Anchor;
-} | {
-  track: TrackedObjectLike;
-  anchor?: Anchor;
-} | ((frame: number) => Vec2$1 | Rect);
-interface TargetContext {
-  measure?: MeasureFn;
-  /** Frame rate signals are sampled at (tracked targets). Default 30. */
-  fps?: number;
-  /** Font defaults for text nodes that don't set them. */
-  textDefaults?: Partial<MeasureOptions>;
-}
-type ResolvedTarget = {
-  kind: "static";
-  rects: Rect[];
-  anchor: Anchor;
-} | {
-  kind: "dynamic";
-  at: (frame: number) => Rect;
-  anchor: Anchor;
-};
-/** Resolve a target to rects (static) or a per-frame rect (dynamic). */
-declare function resolveTarget(target: Target, ctx?: TargetContext): ResolvedTarget;
-/** A text target's string, measured glyphs and range, and where the node sits. */
-interface TextLayout {
-  content: string;
-  metrics: ReturnType<MeasureFn>;
-  options: MeasureOptions;
-  range: [number, number];
-  /** The node's x / y: add to measured glyph positions. */
-  x: number;
-  y: number;
-}
-/** Measure a text target the way the renderer lays it out. */
-declare function textLayout(target: Extract<Target, {
-  text: TargetNode;
-}>, ctx: TargetContext): TextLayout;
-/** The union rect of `rects`. */
-declare function boundsOf(rects: readonly Rect[]): Rect;
-/** The point of `rect` named by `anchor`. `tip` on text = start of the first line, mid-height. */
-declare function anchorPoint(rect: Rect, anchor?: Anchor, isText?: boolean): Vec2$1;
-/** The point a resolved target names at `frame` (static targets ignore frame). */
-declare function targetPoint(resolved: ResolvedTarget, frame?: number, isText?: boolean): Vec2$1;
-//#endregion
-//#region src/core/schemas.d.ts
-/** Any `Target`: [x, y], a rect, { node }, { text }, { track }, or (frame) => point. */
-declare function targetSchema(): z.ZodType<Target>;
-//#endregion
 //#region src/core/surface.d.ts
 type ElevationLevel = keyof Theme["elevation"];
 /** Layer styles for `level`: a drop shadow and, when the theme asks, a top-edge highlight. */
@@ -3617,6 +4046,13 @@ declare function chain(durations: readonly number[], start?: number, gap?: numbe
 declare function typingFrames(text: string, cps: number, fps: number, r: Rng, start?: number): number[];
 //#endregion
 //#endregion
+//#region ../components/dist/toolkit.d.mts
+//#region src/core/schemas.d.ts
+
+/** Any `Target`: [x, y], a rect, { node }, { text }, { track }, or (frame) => point. */
+declare function targetSchema(): z.ZodType<Target>;
+//#endregion
+//#endregion
 //#region ../ai/dist/index.d.mts
 //#region src/types.d.ts
 /** Model input or output when its shape isn't declared. Pass a type argument to name it. */
@@ -3930,6 +4366,86 @@ interface ChartOptions {
 }
 declare const DEFAULT_CHART_COLORS: readonly ["#6366f1", "#22d3ee", "#f59e0b", "#ec4899", "#10b981", "#8b5cf6", "#f97316", "#3b82f6"];
 //#endregion
+//#region src/retarget.d.ts
+/** Anything that answers where a keypoint is at a frame (a vision `PersonTrack`, a mocap reader). */
+interface PoseSource {
+  point(name: PoseKeypointName, frame: number): {
+    x: number;
+    y: number;
+    visibility: number;
+  };
+}
+/** The bones a performer's 2D pose can aim. */
+type RetargetBone = "spine" | "neck" | "leftUpperArm" | "leftLowerArm" | "rightUpperArm" | "rightLowerArm" | "leftUpperLeg" | "leftLowerLeg" | "rightUpperLeg" | "rightLowerLeg";
+/** Joint names per bone; names match without a namespace prefix and case (`"LeftArm"` finds `"mixamorig:LeftArm"`). */
+type RigMap = Partial<Record<RetargetBone, string>>;
+/** Joint names of common rigs. */
+declare const RIG_PRESETS: {
+  /** Mixamo (`mixamorig:` prefix, any number). */
+  readonly mixamo: {
+    readonly spine: "Spine";
+    readonly neck: "Neck";
+    readonly leftUpperArm: "LeftArm";
+    readonly leftLowerArm: "LeftForeArm";
+    readonly rightUpperArm: "RightArm";
+    readonly rightLowerArm: "RightForeArm";
+    readonly leftUpperLeg: "LeftUpLeg";
+    readonly leftLowerLeg: "LeftLeg";
+    readonly rightUpperLeg: "RightUpLeg";
+    readonly rightLowerLeg: "RightLeg";
+  };
+  /** Unity humanoid / VRM bone names. */
+  readonly humanoid: {
+    readonly spine: "Spine";
+    readonly neck: "Neck";
+    readonly leftUpperArm: "LeftUpperArm";
+    readonly leftLowerArm: "LeftLowerArm";
+    readonly rightUpperArm: "RightUpperArm";
+    readonly rightLowerArm: "RightLowerArm";
+    readonly leftUpperLeg: "LeftUpperLeg";
+    readonly leftLowerLeg: "LeftLowerLeg";
+    readonly rightUpperLeg: "RightUpperLeg";
+    readonly rightLowerLeg: "RightLowerLeg";
+  };
+  /** Blender Rigify deform bones. */
+  readonly rigify: {
+    readonly spine: "spine";
+    readonly neck: "neck";
+    readonly leftUpperArm: "upper_arm.L";
+    readonly leftLowerArm: "forearm.L";
+    readonly rightUpperArm: "upper_arm.R";
+    readonly rightLowerArm: "forearm.R";
+    readonly leftUpperLeg: "thigh.L";
+    readonly leftLowerLeg: "shin.L";
+    readonly rightUpperLeg: "thigh.R";
+    readonly rightLowerLeg: "shin.R";
+  };
+};
+interface RetargetOptions {
+  /** The character's joint names: a preset or a map. Default "mixamo". */
+  rig?: keyof typeof RIG_PRESETS | RigMap;
+  /** Only these bones (e.g. arms, over a walk clip). Default: every mapped bone. */
+  bones?: RetargetBone[];
+  /**
+   * Drive the character's right side with the performer's left: for a
+   * character seen from behind. Default false (both face the camera).
+   */
+  mirror?: boolean;
+  /**
+   * Keypoints less sure than this hand their bone back to the animated
+   * pose, fading over the next 0.2 of confidence. Default 0.3.
+   */
+  minVisibility?: number;
+  /** Overall blend over the animated pose, 0..1: a number, keys, function or signal. Default 1. */
+  weight?: NumberTrack;
+}
+/**
+ * Aim constraints that make a character copy `source`'s pose: put them on
+ * a glTF model's `aim`. Bones whose joints the rig map doesn't name, or
+ * whose keypoints the vision isn't sure of, keep the animated pose.
+ */
+declare function retargetPose(source: PoseSource, options?: RetargetOptions): AimConstraint[];
+//#endregion
 //#region src/clip-vision.d.ts
 type PoseKeypointName = (typeof COCO17_KEYPOINT_NAMES)[number];
 interface ClipVisionOptions {
@@ -3962,6 +4478,14 @@ interface ClipVisionOptions {
    * clip tracks no pose or silhouette unless `pose` / `mask` ask for them.
    */
   depth?: boolean;
+  /**
+   * Resolve the subject's edge to soft alpha (ViTMatte Small): hair, motion
+   * blur and see-through parts that a hard mask cuts off. `true`, or
+   * `{ band, resolution }` (see `MatteRefineOptions`). Matte layers, `signals`
+   * masks and `subject` read the soft alpha; each prompted track keeps its own.
+   * Mattes persist apart from the masks, so turning this on reuses them.
+   */
+  matting?: boolean | MatteRefineOptions;
   /** Silhouette cell size in source pixels (default 8: a 1920×1080 clip gives a 240×135 grid). */
   maskCell?: number;
   /** Keypoints are averaged over ±`smoothing` frames, weighted by confidence (default 2; 0 = raw). */
@@ -4052,6 +4576,10 @@ declare class ClipVision implements ClipSubjectSource {
   private readonly subjects;
   private wantSubjects;
   private subjectsLoaded?;
+  /** Soft alpha per source frame (`matting`); null when the frame holds no subject. */
+  private readonly mattes;
+  private mattesLoaded?;
+  private unsavedMattes;
   /** Depth per source frame; null when the frame did not decode. Bounded when on disk. */
   private readonly depths;
   /** Source frames whose depth is on disk. */
@@ -4101,6 +4629,14 @@ declare class ClipVision implements ClipSubjectSource {
   get tracksPose(): boolean;
   /** Whether frames carry the person's silhouette: on by default, off for depth clips. */
   get tracksMask(): boolean;
+  /** Whether subjects are matted to soft alpha. */
+  get tracksMatting(): boolean;
+  private get matteSettings();
+  /**
+   * A stored subject's alpha at a source frame: the matte when the clip mattes
+   * (undefined until matted), else the mask. With `id`, that track only.
+   */
+  private alpha;
   /** Whether frames carry relative depth. */
   get tracksDepth(): boolean;
   /**
@@ -4129,7 +4665,15 @@ declare class ClipVision implements ClipSubjectSource {
   /** Loads `@framefields/vision-sam` and validates the prompts once, on first use. */
   private prompted;
   private compute;
+  /** Pose, silhouette and subject of every frame in `from…to` not analysed yet. */
+  private computeSubjects;
   private visionRunner;
+  /**
+   * The soft alpha of every subject in `from…to` not matted yet: one
+   * ViTMatte pass per frame over every track's edge. Prompted label maps grow
+   * into the soft edge, so each track keeps its own alpha.
+   */
+  private computeMattes;
   /** Depth of every source frame in `from…to` not analysed yet, saved one file per frame. */
   private computeDepth;
   private hasDepth;
@@ -4178,6 +4722,13 @@ declare class ClipVision implements ClipSubjectSource {
   /** Subjects live beside the results: large, and only matte layers read them. */
   private subjectsPath;
   private loadSubjects;
+  /**
+   * Mattes live beside the subjects they refine, keyed by the matting model
+   * and settings, so toggling matting never recomputes the masks.
+   */
+  private mattesPath;
+  private loadMattes;
+  private saveMattes;
   private saveSubjects;
 }
 /**
@@ -4201,6 +4752,12 @@ declare class PersonTrack {
     y: number;
     visibility: number;
   };
+  /**
+   * Aim constraints that make a 3D character copy this person's pose, for
+   * a glTF model's `aim`: `Layer.glb(src, { aim: person.retarget({ rig: "mixamo" }) })`.
+   * Place the person first (`place()`), so directions read in composition px.
+   */
+  retarget(options?: RetargetOptions): AimConstraint[];
   /** Signals for a keypoint, for `.signal("x", …)`; read while rendering. */
   signals(name: PoseKeypointName): {
     x: FrameSignal<number>;
@@ -4396,6 +4953,11 @@ type Shape3D = {
 /** Flat [x0, y0, z0, …] around the body origin. */ | {
   kind: "hull";
   points: number[];
+}
+/** Exact triangle mesh (static / kinematic bodies: terrain, sculptures). */ | {
+  kind: "trimesh";
+  vertices: number[];
+  indices: number[];
 };
 interface BodySpecBase extends MaterialSpec {
   type: BodyType;
@@ -4460,6 +5022,10 @@ interface SimBody<V, R> {
   mass(): number;
   setEnabled(enabled: boolean): void;
   applyImpulse(impulse: V): void;
+  /** Teleports the body (wakes it): position, and rotation. */
+  setPose(position: V, rotation: R): void;
+  /** Sets linear and angular velocity (wakes the body). */
+  setVelocity(linear: V, angular: R extends number ? number : Vec3): void;
   setKinematicTarget(position: V, rotation: R): void;
 }
 type SimBody2D = SimBody<Vec2, number>;
@@ -4626,6 +5192,10 @@ declare abstract class WorldCore<V extends number[], R, B extends CoreBody<V, R>
     targets?: Set<B>;
     accel: (body: B, frame: number) => V | null | undefined;
   }>;
+  /** Run after each simulated frame with the pairs that started touching in it. */
+  protected readonly stepHooks: Array<(frame: number, pairs: Array<[B, B]>) => void>;
+  /** Run once the whole simulation has finished (not in live worlds). */
+  protected readonly simulatedHooks: Array<() => void>;
   private readonly worldRecording;
   private readonly allCollisions;
   /** No more bodies, joints or forces: the world has started (or finished). */
@@ -4790,6 +5360,49 @@ declare class Particles extends Effect$1<Record<string, never>> implements Parti
   particleFrame(frame: number, fps: number): ParticleFrame;
 }
 //#endregion
+//#region src/physics/fracture3d.d.ts
+interface Fracture3DOptions {
+  /** Voronoi pieces (2..256). Default 48. */
+  cells?: number;
+  /** Same seed, same pieces. Default 1. */
+  seed?: number;
+  /** Scene point (px) the pieces crowd around and fly from. */
+  impactPoint?: [number, number, number];
+  /**
+   * Composition frame the layer breaks at, or `"onImpact"` (default): the
+   * first frame a body hits it. An animated layer (position, rotation)
+   * collides along its path while whole and breaks where it is, its pieces
+   * carrying its motion.
+   */
+  fractureFrame?: number | "onImpact";
+  /** Color of the faces the break exposes. Default "#d8d2c4". */
+  interiorColor?: string;
+  /** Roughness of the exposed faces. Default 0.9. */
+  interiorRoughness?: number;
+  /** Outward speed at the impact point, px/s, fading with distance. Default 0. */
+  explosionSpeed?: number;
+  /** Random tumble, degrees per second. Default a third of `explosionSpeed`. */
+  spin?: number;
+  /** Share of the hitting body's velocity the nearest pieces take. Default 0.35. */
+  momentumTransfer?: number;
+  density?: number;
+  friction?: number;
+  restitution?: number;
+}
+/** A fractured layer: its pieces, and the collider that stands in for it while whole. */
+declare class Fracture3D {
+  readonly node: LayoutNode;
+  readonly pieces: readonly PhysicsBody3D[];
+  readonly intact: PhysicsBody3D;
+  private readonly world;
+  /** @internal */
+  brokeAt?: number;
+  /** @internal */
+  constructor(node: LayoutNode, pieces: readonly PhysicsBody3D[], intact: PhysicsBody3D, world: PhysicsWorld3D);
+  /** Composition frame it broke at (after simulating); undefined if it never did. */
+  get frame(): number | undefined;
+}
+//#endregion
 //#region src/physics/world3d.d.ts
 interface World3DOptions extends PhysicsWorldOptions {
   /** px/s², y down. A number pulls straight down. Default 2400. */
@@ -4831,10 +5444,12 @@ interface Body3DOptions extends Omit<BodyCommonOptions, "lockRotation"> {
   };
   /**
    * Collider: `"auto"` (default) reads the Layer3D primitive (box, sphere,
-   * cylinder) and falls back to the mesh's convex hull for models and
-   * tapered or uneven shapes. Force `"box"`, `"sphere"`, `"cylinder"` or `"hull"`.
+   * cylinder), uses the exact triangles of `Layer3D.terrain` / `Layer3D.sdf`
+   * on static bodies, and falls back to the mesh's convex hull for models and
+   * tapered or uneven shapes. Force `"box"`, `"sphere"`, `"cylinder"`,
+   * `"hull"` or `"mesh"` (exact triangles; static or kinematic bodies only).
    */
-  shape?: "auto" | "box" | "sphere" | "cylinder" | "hull";
+  shape?: "auto" | "box" | "sphere" | "cylinder" | "hull" | "mesh";
   /** Collider size override `[width, height, depth]`, px (before the layer's scale). */
   size?: [number, number, number];
   /** px/s. */
@@ -4851,11 +5466,10 @@ interface Body3DOptions extends Omit<BodyCommonOptions, "lockRotation"> {
     rotateZ?: PhysicsDriver;
   };
 }
+/** @internal */
 type LayerLike$1 = Record<string, unknown> & {
   kind?: string;
 };
-/** Quaternion of the renderer's Euler order: R = Rz · Ry · Rx (degrees). */
-
 /**
  * A simulated 3D body. Like {@link PhysicsBody2D}, its signals hold one
  * value per composition frame and reading one runs the simulation.
@@ -4877,6 +5491,16 @@ declare class PhysicsBody3D implements CoreBody<Vec3, Quat> {
     rotation: Vec3;
   }, options: Body3DOptions, recording: Recording);
   get startFrame(): number;
+  private wokeAt?;
+  /**
+   * @internal Starts the body now, mid-simulation (`frame` relative to the
+   * world's start): it moves from the next frame, at this velocity (px/s,
+   * degrees per second), from `pose` (px) when given.
+   */
+  wake(frame: number, velocity: Vec3, angularVelocity: Vec3, pose?: {
+    position: Vec3;
+    rotation: Quat;
+  }): void;
   get gravityScale(): number;
   get output(): Body3DOptions["output"];
   /** Center, px (what Layer3D's `x` / `y` / `z` mean). */
@@ -4944,6 +5568,20 @@ declare class PhysicsWorld3D extends WorldCore<Vec3, Quat, PhysicsBody3D> {
   constructor(backend: PhysicsBackend, options: World3DOptions);
   /** Adds a body for a Layer3D primitive or model (centered on its `x/y/z`), or a plain box. */
   body(target: LayoutNode | PhysicsBox3D, options?: Body3DOptions): PhysicsBody3D;
+  /** @internal A body with an explicit collider (px), at a pose in px and degrees. */
+  shapedBody(layer: LayerLike$1 | undefined, position: Vec3, rotation: Vec3, shape: Shape3D, options: Body3DOptions): PhysicsBody3D;
+  /** @internal Runs after each simulated frame (frame relative to the world's start). */
+  onStep(hook: (frame: number, pairs: Array<[PhysicsBody3D, PhysicsBody3D]>) => void): void;
+  /** @internal Runs once the simulation has finished. */
+  onSimulated(hook: () => void): void;
+  /**
+   * Breaks a Layer3D primitive, extruded text or loaded model into Voronoi
+   * pieces that stay together, looking intact, until the fracture frame (or
+   * until something hits it), then fly apart as rigid bodies. The node is
+   * changed in place: add it to the composition as usual. All pieces draw
+   * in one call per material, the cut faces in `interiorColor`.
+   */
+  fracture(target: LayoutNode, options?: Fracture3DOptions): Fracture3D;
   /** A fixed, very large floor whose top face sits at `y`. */
   ground(options: {
     y: number;
@@ -4988,6 +5626,47 @@ declare class PhysicsWorld3D extends WorldCore<Vec3, Quat, PhysicsBody3D> {
   private endpoints;
 }
 //#endregion
+//#region src/procedural3d.d.ts
+type GeometryKeys = "type" | "color" | "material";
+type Terrain3DOptions = Primitive3DNodeOptions & Omit<TerrainGeometryOptions, GeometryKeys> & {
+  /**
+   * Custom heights: `(u, v) => 0..1` over the grid (u across x, v across
+   * z, both 0..1 from the near-left corner). Sampled into `heights`.
+   */
+  heightFn?: (u: number, v: number) => number;
+};
+type Sdf3DOptions = Primitive3DNodeOptions & Omit<SdfGeometryOptions, GeometryKeys>;
+type Scatter3DOptions = Omit<Instances3DOptions, "count" | "instanceAt" | "transforms" | "bodies"> & ScatterOptions & {
+  /** The surface: `Layer3D.terrain`, `Layer3D.sdf`, any primitive or `Layer.model`. */
+  surface: AnimatableNode<Model3DNode>;
+  /** Push each instance this far into the surface, px. Default 0. */
+  sink?: number;
+  /** Procedural wind sway; the meshes bend from their base. */
+  wind?: WindConfig;
+};
+/** A terrain node's helpers for standing other layers on it. */
+interface TerrainSurface {
+  /**
+   * Surface y at (x, z) in the terrain's parent space (where its own x, y,
+   * z live), so a camera, light, video screen or model can stand on it.
+   * Follows the terrain's position and scale; rotation is not applied.
+   */
+  heightAt(x: number, z: number): number;
+  /** Unit surface normal at (x, z), parent space (unrotated). */
+  normalAt(x: number, z: number): [number, number, number];
+  /** Normalized altitude 0..1 at (x, z). */
+  elevationAt(x: number, z: number): number;
+}
+type Terrain3DNode = AnimatableNode<Model3DNode> & TerrainSurface;
+type Scatter3DNode = AnimatableNode<Model3DNode> & {
+  /**
+   * The scattered points (surface position, normal, rotation, scale) in the
+   * surface's parent space, for placing other layers among the instances.
+   * Empty for a surface loaded from a file (its mesh is read at render).
+   */
+  points(): ScatterPoint[];
+};
+//#endregion
 //#region src/swarm3d.d.ts
 interface Swarm3DOptions extends Surface3DOptions {
   id?: string;
@@ -5122,6 +5801,36 @@ interface Surface3DOptions {
   emissiveIntensity?: number;
   /** Falls into a `castShadow` light's shadow map (meshes default on, flat layers off). */
   castShadow?: boolean;
+  /** Clear varnish layer over the base 0..1 (car paint, lacquer, wet coats). */
+  clearcoat?: SignalOrNumber;
+  /** Roughness of the clearcoat layer 0..1. Default 0.08. */
+  clearcoatRoughness?: SignalOrNumber;
+  /** Stretched highlight -1..1 (brushed metal, satin, hair). 0 = round. */
+  anisotropy?: SignalOrNumber;
+  /** Brush direction in degrees around the surface normal. Default 0. */
+  anisotropyRotation?: SignalOrNumber;
+  /** Light bleeding through the surface 0..1 (wax, jade, skin, leaves). */
+  subsurface?: SignalOrNumber;
+  /** Color of the scattered light (CSS color). Default "#ff6b4a". */
+  subsurfaceColor?: string;
+  /** Velvet / cloth rim glow at grazing angles 0..1. */
+  sheen?: SignalOrNumber;
+  /** Sheen tint (CSS color). Default "#ffffff". */
+  sheenColor?: string;
+  /** Sheen fiber roughness 0.05..1. Default 0.5. */
+  sheenRoughness?: SignalOrNumber;
+  /** Thin-film rainbow (soap, oil, beetle shells): 0..1 or `{ intensity, thickness, ior }`. */
+  iridescence?: SignalOrNumber | IridescenceConfig;
+  /** Film thickness in nanometers 100..1200. Default 400. */
+  iridescenceThickness?: SignalOrNumber;
+  /** Film refractive index 1.05..2.5. Default 1.3. */
+  iridescenceIor?: SignalOrNumber;
+  /** Project textures in world space instead of UVs: `true` or `{ scale, sharpness }`. */
+  triplanar?: boolean | TriplanarConfig;
+  /** Triplanar tiling: repeats per 256 world px (> 0 turns triplanar on). */
+  triplanarScale?: SignalOrNumber;
+  /** Triplanar axis blend sharpness 1..16. Default 4. */
+  triplanarSharpness?: SignalOrNumber;
 }
 interface CubeFaceConfig extends Surface3DOptions {
   background?: string;
@@ -5152,6 +5861,12 @@ interface Cube3DOptions extends Surface3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   faces?: {
     front?: CubeFaceInput;
     back?: CubeFaceInput;
@@ -5184,6 +5899,12 @@ interface Carousel3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   faceInward?: boolean;
   itemWidth?: number;
   itemHeight?: number;
@@ -5198,8 +5919,12 @@ interface Prism3DOptions extends Surface3DOptions {
   radius?: number;
   /** Optional top (-y) radius; defaults to `radius`. */
   radiusTop?: number;
+  /** Alias for `radiusTop`. */
+  topRadius?: number;
   /** Optional bottom (+y) radius; defaults to `radius`. */
   radiusBottom?: number;
+  /** Alias for `radiusBottom`. */
+  bottomRadius?: number;
   /** Height along Y (default 100). */
   height?: number;
   x?: number;
@@ -5208,6 +5933,12 @@ interface Prism3DOptions extends Surface3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   scale?: number;
   scaleX?: number;
   scaleY?: number;
@@ -5248,6 +5979,8 @@ interface Pyramid3DOptions extends Surface3DOptions {
   radius?: number;
   /** Optional top (-y) truncation radius for a frustum pyramid (default 0 = sharp apex). */
   radiusTop?: number;
+  /** Alias for `radiusTop`. */
+  topRadius?: number;
   /** Height from base (+y) to apex (-y) (default 100). */
   height?: number;
   /** Leave the base cap off (default false = solid capped pyramid). */
@@ -5260,6 +5993,12 @@ interface Pyramid3DOptions extends Surface3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   scale?: number;
   scaleX?: number;
   scaleY?: number;
@@ -5293,6 +6032,12 @@ interface Plane3DOptions extends Surface3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   background?: string;
   borderRadius?: number;
   twoSided?: boolean;
@@ -5324,6 +6069,12 @@ interface Grid3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   opacity?: number;
 }
 interface Text3DOptions extends Surface3DOptions {
@@ -5340,6 +6091,12 @@ interface Text3DOptions extends Surface3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   scale?: number;
   scaleX?: number;
   scaleY?: number;
@@ -5400,6 +6157,12 @@ interface Primitive3DNodeOptions extends Surface3DOptions {
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   scale?: number;
   scaleX?: number;
   scaleY?: number;
@@ -5429,6 +6192,16 @@ interface Primitive3DNodeOptions extends Surface3DOptions {
   opacity?: number;
   startFrame?: number;
   durationFrames?: number;
+  /**
+   * Base-color texture wrapped by the mesh's UVs: an image path, or any
+   * layer (`Layer.video`, `Layer.image`, a layout tree with text…) drawn
+   * fresh every frame, so video plays on the surface. Without its own
+   * x / y / width / height the layer fills the frame, which maps to the
+   * whole UV square. Combine with `triplanar` to project it in world space.
+   */
+  texture?: string | LayoutNode;
+  /** Procedural wind sway: vertices bend downwind by height above the mesh base. */
+  wind?: WindConfig;
 }
 type RoundedBox3DOptions = Primitive3DNodeOptions & Omit<RoundedBoxGeometryOptions, "type" | "color" | "material">;
 type Sphere3DOptions = Primitive3DNodeOptions & Omit<SphereGeometryOptions, "type" | "color" | "material">;
@@ -5470,6 +6243,12 @@ interface InstanceTransform3D {
   color?: string | [number, number, number, number];
   emissive?: string | [number, number, number];
   emissiveIntensity?: number;
+  /** Crowds: index into `crowd.clips` (default: instance index % clip count). */
+  clip?: number;
+  /** Crowds: seconds into the clip at frame 0 (default: seeded random, or 0 with `phase: "sync"`). */
+  animOffset?: number;
+  /** Crowds: playback speed (default: seeded within `crowd.speedRange`). */
+  animSpeed?: number;
 }
 interface Instances3DOptions extends Surface3DOptions {
   id?: string;
@@ -5493,12 +6272,27 @@ interface Instances3DOptions extends Surface3DOptions {
     color: string;
     intensity?: number;
   };
+  /** Procedural wind sway: each instance bends downwind from its base. */
+  wind?: WindConfig;
+  /**
+   * Skinned crowd: the mesh is an animated model (`Layer.glb`, `Layer.gltf`)
+   * and every instance plays one of `clips` at its own phase and speed,
+   * skinned on the GPU from a palette baked once: thousands of characters,
+   * one draw call per mesh.
+   */
+  crowd?: CrowdConfig;
   x?: number;
   y?: number;
   z?: number;
   rotateX?: number;
   rotateY?: number;
   rotateZ?: number;
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
   scale?: number;
   color?: string;
   colorTint?: string;
@@ -5538,12 +6332,12 @@ declare const Layer3D: {
    * outward flat-shaded facet normals, and full material options.
    * If `sideConfigs` are provided, builds a multi-panel preserve-3d container with all material props applied.
    */
-  prism(options: Prism3DOptions): Shape3DContainer;
+  prism(options?: Prism3DOptions): SolidShape3DNode;
   /**
    * Creates a solid N-sided regular polygonal pyramid (or truncated pyramid when `radiusTop > 0`)
    * with a bottom cap and crisp flat-shaded side facets.
    */
-  pyramid(options: Pyramid3DOptions): AnimatableNode<Model3DNode>;
+  pyramid(options?: Pyramid3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Creates a standalone planar 3D card/quad.
    */
@@ -5638,6 +6432,30 @@ declare const Layer3D: {
    * Renders hundreds or thousands of 3D meshes in 1 draw call per mesh variant,
    * driven by Physics.world3d rigid bodies, procedural callbacks, or transform arrays.
    */
+  /**
+   * Procedural terrain: seeded fractal noise ("fbm" hills, "ridged"
+   * mountains, "terrace" plateaus) or your own heights, optional cliff
+   * overhangs, biome colors by altitude and slope, closed underneath into a
+   * solid block. The node's y is the valley floor; peaks rise `height` px
+   * above it. The node carries `heightAt(x, z)` / `normalAt(x, z)` for
+   * standing cameras, lights, video screens and models on the ground.
+   */
+  terrain(options: Terrain3DOptions): Terrain3DNode;
+  /**
+   * A sculpture of signed-distance primitives (sphere, box, cylinder,
+   * capsule, torus, gyroid) joined in order by union / subtract /
+   * intersect, hard or smooth (`smoothness` px), meshed watertight inside
+   * `bounds`. Colored primitives blend where their joins blend.
+   */
+  sdf(options: Sdf3DOptions): AnimatableNode<Model3DNode>;
+  /**
+   * Scatters instances of one or more meshes over a surface (terrain, SDF,
+   * any primitive or `Layer.model` file): area-weighted, deterministic per
+   * `seed`, filtered by slope / altitude / exclusion zones, spaced by
+   * `minDistance`, each standing on its base. One draw call per mesh
+   * variant. `wind` sways them; `.points()` returns where they stand.
+   */
+  scatter(options: Scatter3DOptions): Scatter3DNode;
   instances(options: Instances3DOptions): AnimatableNode<Model3DNode>;
   /**
    * GPU-simulated 3D particle swarm and shard system.
@@ -5648,43 +6466,43 @@ declare const Layer3D: {
   /**
    * Creates a 3D model node rendered natively with WebGPU mesh shaders.
    */
-  model(options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  model(options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D Wavefront OBJ model node.
    */
-  obj(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  obj(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D Autodesk FBX model node with skeletal animation support.
    */
-  fbx(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  fbx(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D glTF 2.0 model node.
    */
-  gltf(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  gltf(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D GLB binary container model node.
    */
-  glb(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  glb(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D STL CAD / 3D printing model node.
    */
-  stl(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  stl(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D Stanford PLY scan model node.
    */
-  ply(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  ply(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D MagicaVoxel VOX model node.
    */
-  vox(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  vox(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D Studio (3DS) binary model node.
    */
-  threeDS(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  threeDS(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
   /**
    * Convenience helper to create a 3D Object File Format (OFF) model node.
    */
-  off(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  off(src: string, options?: Model3DOptions): AnimatableNode<Model3DNode>;
 };
 //#endregion
 //#region src/transitions.d.ts
@@ -5884,6 +6702,8 @@ interface TextMeasureStyle {
   fontSize?: number;
   fontWeight?: string | number;
   fontStyle?: string;
+  /** Variable font axes, as `TextNode.fontVariations`. */
+  fontVariations?: Record<string, number>;
   letterSpacing?: number;
   lineHeight?: number;
   padding?: number;
@@ -5936,6 +6756,12 @@ interface LightingRigOptions {
   shadowSoftness?: number;
   /** Fog fading into the background, e.g. `{ color: BG, start: 2500, end: 6000 }`. */
   fog?: EnvironmentOptions["fog"];
+  /** Volumetric fog & shadowed light shafts (god rays): `true` or settings. */
+  volumetricFog?: EnvironmentOptions["volumetricFog"];
+  /** Screen-space reflections of nearby geometry on glossy surfaces: `true` or settings. */
+  ssr?: EnvironmentOptions["ssr"];
+  /** Screen-space diffuse GI (contact occlusion and color bleeding): `true` or settings. */
+  gi?: EnvironmentOptions["gi"];
   /** Glow around emissive surfaces and highlights: `true` or settings. */
   bloom?: EnvironmentOptions["bloom"];
   /** Prefix for the rig's node ids. */
@@ -6425,13 +7251,15 @@ declare class Media {
    */
   toVirtualMedia(): VirtualMediaData;
   /**
-   * Renders a single frame from this media pipeline to a PNG Buffer.
+   * Renders a single frame from this media pipeline to an image or raw RGBA Buffer.
    * Can render either by timestamp in milliseconds (`atMs`) or by frame index (`frame`).
    */
   renderFrame(options?: {
     atMs?: number;
     frame?: number;
     fps?: number;
+    renderId?: string;
+    format?: "png" | "rgba" | "raw" | "jpeg" | "jpg" | "webp";
     renderer?: HeadlessMediaRenderer;
   }): Promise<Buffer>;
   get fps(): number | undefined;
@@ -6702,13 +7530,15 @@ declare class Composition {
    */
   toVirtualMediaAsync(options?: Partial<CompositorToProgramOptions>): Promise<VirtualMediaData>;
   /**
-   * Renders a single frame from the composition to a PNG Buffer.
+   * Renders a single frame from the composition to an image or raw RGBA Buffer.
    * Can render either by timestamp in milliseconds (`atMs`) or by frame index (`frame`).
    */
-  renderFrame(options?: {
+  renderFrame(frameOrOptions?: number | {
     atMs?: number;
     fps?: number;
     frame?: number;
+    renderId?: string;
+    format?: "png" | "rgba" | "raw" | "jpeg" | "jpg" | "webp";
     renderer?: HeadlessMediaRenderer;
   }): Promise<Buffer>;
   /**
@@ -6861,9 +7691,9 @@ declare const Layer: {
    * `props` applies to that box: position, id, timing, effects.
    */
   chart: (options: ChartOptions, props?: Partial<BoxNode>) => AnimatableNode<BoxNode>;
-  camera: (options?: Partial<CameraNode>) => AnimatableNode<CameraNode>;
-  light: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
-  ambientLight: (color?: string | Partial<LightNode>, intensity?: number, options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  camera: (options?: CameraOptions) => AnimatableNode<CameraNode>;
+  light: (options?: LightOptions) => AnimatableNode<LightNode>;
+  ambientLight: (color?: string | LightOptions, intensity?: SignalOrNumber, options?: LightOptions) => AnimatableNode<LightNode>;
   /**
    * Scenes back to back with transitions between them; see `Transition`.
    * `comp.add(Layer.sequence([{ scene: hero(), duration: 90 },
@@ -6871,40 +7701,115 @@ declare const Layer: {
    * The result's `totalFrames` is the sequence length.
    */
   sequence: (entries: SequenceEntry[], options?: SceneSequenceOptions) => SequenceNode;
-  /** See {@link Light.environment}: `Layer.environment("studio", { exposure: 0.3 })`. */
-  environment: (presetOrOptions?: EnvironmentPreset | EnvironmentOptions, options?: EnvironmentOptions) => AnimatableNode<LightNode>;
-  directionalLight: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
-  pointLight: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
-  spotLight: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  /** See {@link Light.environment}: `Layer.environment("studio", { exposure: 0.3 })` or `Layer.environment("sky.hdr")`. */
+  environment: (presetOrOptions?: EnvironmentPreset | HdriPath | EnvironmentOptions, options?: EnvironmentOptions) => AnimatableNode<LightNode>;
+  directionalLight: (options?: LightOptions) => AnimatableNode<LightNode>;
+  pointLight: (options?: LightOptions) => AnimatableNode<LightNode>;
+  spotLight: (options?: LightOptions) => AnimatableNode<LightNode>;
+  rectLight: (options?: LightOptions) => AnimatableNode<LightNode>;
   cube: (options: Cube3DOptions) => AnimatableNode<BoxNode>;
   carousel3d: (options: Carousel3DOptions) => AnimatableNode<BoxNode>;
   plane3d: (options: Plane3DOptions) => AnimatableNode<BoxNode>;
   prism3d: (options?: Prism3DOptions) => SolidShape3DNode;
-  model: (options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  obj: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  fbx: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  gltf: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  glb: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  stl: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  ply: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  vox: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  threeDS: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
-  off: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  model: (options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  obj: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  fbx: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  gltf: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  glb: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  stl: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  ply: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  vox: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  threeDS: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+  off: (src: string, options?: Model3DOptions) => AnimatableNode<Model3DNode>;
+};
+interface CameraOptions extends Partial<CameraNode> {
+  /** Top-level shorthand for `lens.fov` (vertical field of view in degrees). */
+  fov?: number;
+  /** Top-level shorthand for `lens.focalLength` (mm). */
+  focalLength?: number;
+  /** Top-level shorthand for `lens.sensorWidth` (mm). */
+  sensorWidth?: number;
+  /** Top-level shorthand for `lens.near` clipping plane. */
+  near?: number;
+  /** Top-level shorthand for `lens.far` clipping plane. */
+  far?: number;
+  /** Top-level shorthand for `lens.zoom` multiplier. */
+  zoom?: number;
+}
+interface Model3DOptions extends Partial<Model3DNode> {
+  /** Alias for `rotateX`. */
+  rotationX?: number;
+  /** Alias for `rotateY`. */
+  rotationY?: number;
+  /** Alias for `rotateZ`. */
+  rotationZ?: number;
+}
+type SignalOrNumber = number | ProgrammaticSignal | Signal<number> | {
+  get: (ctx: FrameContext) => number;
 };
+interface VolumetricFogNoiseOptions extends Omit<EnvironmentVolumetricFogNoise, "strength"> {
+  strength?: SignalOrNumber;
+}
+interface VolumetricFogOptions extends Omit<EnvironmentVolumetricFog, "density" | "anisotropy" | "noise"> {
+  density?: SignalOrNumber;
+  anisotropy?: SignalOrNumber;
+  noise?: boolean | VolumetricFogNoiseOptions;
+}
+/** An equirectangular panorama path (Radiance `.hdr` or OpenEXR `.exr`), usable in place of a preset name. */
+type HdriPath = `${string}.hdr` | `${string}.HDR` | `${string}.exr` | `${string}.EXR`;
 /** World settings for `Layer.environment` (see `LightNode` for every field). */
-type EnvironmentOptions = Partial<Pick<LightNode, "id" | "preset" | "top" | "horizon" | "bottom" | "intensity" | "softboxes" | "rotation" | "exposure" | "toneMapping" | "fog" | "floor" | "outlines" | "bloom" | "startFrame" | "durationFrames">>;
+interface EnvironmentOptions extends Partial<Pick<LightNode, "id" | "preset" | "hdri" | "color" | "top" | "horizon" | "bottom" | "softboxes" | "toneMapping" | "fog" | "floor" | "outlines" | "ssr" | "gi" | "bloom" | "startFrame" | "durationFrames">> {
+  intensity?: SignalOrNumber;
+  rotation?: SignalOrNumber;
+  exposure?: SignalOrNumber;
+  volumetricFog?: boolean | VolumetricFogOptions;
+  volumetricFogDensity?: SignalOrNumber;
+  volumetricFogAnisotropy?: SignalOrNumber;
+  volumetricFogNoiseStrength?: SignalOrNumber;
+}
+/** Options for `Light.*` and `Layer.*Light` (numeric fields also accept live `Signal`s). */
+interface LightOptions extends Omit<Partial<LightNode>, "intensity" | "x" | "y" | "z" | "targetX" | "targetY" | "targetZ" | "radius" | "angle" | "penumbra" | "decay" | "width" | "height" | "rotation" | "exposure" | "volumetricFog" | "volumetricFogDensity" | "volumetricFogAnisotropy" | "volumetricFogNoiseStrength"> {
+  intensity?: SignalOrNumber;
+  x?: SignalOrNumber;
+  y?: SignalOrNumber;
+  z?: SignalOrNumber;
+  targetX?: SignalOrNumber;
+  targetY?: SignalOrNumber;
+  targetZ?: SignalOrNumber;
+  radius?: SignalOrNumber;
+  angle?: SignalOrNumber;
+  penumbra?: SignalOrNumber;
+  decay?: SignalOrNumber;
+  width?: SignalOrNumber;
+  height?: SignalOrNumber;
+  rotation?: SignalOrNumber;
+  exposure?: SignalOrNumber;
+  volumetricFog?: boolean | VolumetricFogOptions;
+  volumetricFogDensity?: SignalOrNumber;
+  volumetricFogAnisotropy?: SignalOrNumber;
+  volumetricFogNoiseStrength?: SignalOrNumber;
+}
 declare const Light: {
   /**
    * The scene's world: a procedural studio environment that lights and
-   * reflects off every surface, plus exposure, tone mapping and fog. Adding
-   * one switches the scene to physically based shading (GGX, real
-   * `roughness` / `metallic`, `emissive` that blooms past white).
-   */
-  environment: (presetOrOptions?: EnvironmentPreset | EnvironmentOptions, options?: EnvironmentOptions) => AnimatableNode<LightNode>;
-  ambient: (color?: string | Partial<LightNode>, intensity?: number, options?: Partial<LightNode>) => AnimatableNode<LightNode>;
-  directional: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
-  point: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
-  spot: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+   * reflects off every surface, plus exposure, tone mapping, fog and
+   * volumetric light shafts. Adding one switches the scene to physically
+   * based shading (GGX, real `roughness` / `metallic`, `emissive` that
+   * blooms past white). Pass a `.hdr` or `.exr` path instead of a preset name to light
+   * and reflect from a captured equirectangular panorama:
+   * `Light.environment("assets/hdri/studio.hdr", { intensity: 1.5 })`.
+   */
+  environment: (presetOrOptions?: EnvironmentPreset | HdriPath | EnvironmentOptions, options?: EnvironmentOptions) => AnimatableNode<LightNode>;
+  ambient: (color?: string | LightOptions, intensity?: SignalOrNumber, options?: LightOptions) => AnimatableNode<LightNode>;
+  directional: (options?: LightOptions) => AnimatableNode<LightNode>;
+  point: (options?: LightOptions) => AnimatableNode<LightNode>;
+  spot: (options?: LightOptions) => AnimatableNode<LightNode>;
+  /**
+   * A rectangular area light (studio softbox / LED panel / neon window)
+   * with solid-angle diffuse illumination and representative-point GGX
+   * specular reflections.
+   */
+  rect: (options?: LightOptions) => AnimatableNode<LightNode>;
 };
 declare function section(source: string | MediaNode | Composition, targetOrOptions?: ObjectTrackSignals | SectionOptions, options?: SectionOptions): SectionNode;
 declare function blurRegion(sourceOrLayer: string | AnimatableNode<MediaNode>, target: ObjectTrackSignals, options?: Partial<BlurProps> & {
@@ -7003,5 +7908,5 @@ type ComponentNode<C extends Cues = Cues> = AnimatableNode<BoxNode> & ComponentE
  */
 declare function bindComponent<S$1 extends z.ZodRawShape, C extends Cues, E extends object = object>(definition: ComponentDefinition<S$1, C, E>): (props: z.input<z.ZodObject<S$1>> & BaseProps) => ComponentNode<C> & E;
 //#endregion
-export { mapBlendModeToSkia as $, withDefaults as $a, exitAnimation as $i, Animatable as $n, Model3DAnimatableProp as $o, ResolvedTarget as $r, World3DOptions as $t, Physics as A, springKeys as Aa, basePropsSchema as Ai, bold as An, EnvironmentFogSchema as Ao, GlyphProps as Ar, calculateSequenceTimeline as As, Points3DOptions as At, World2DOptions as B, targetSchema as Ba, cover as Bi, sub as Bn, LayoutNode as Bo, MediaOptions as Br, lintComposition as Bs, Sphere3DOptions as Bt, TrackEditing as C, rng as Ca, arcPath as Ci, ChartSlice as Cn, CompositorProgramConfig as Co, FontNeed as Cr, TextSpanSchema as Cs, Icosphere3DOptions as Ct, section as D, scheduleExpression as Da, bakeFunction as Di, MarkOptions as Dn, EnvironmentFloor as Do, FrameWindow as Dr, TrackSource as Ds, Layer3D as Dt, editTrackedRegion as E, scaleFrames as Ea, audioLevelsSchema as Ei, DEFAULT_CHART_COLORS as En, EaseRef as Eo, FrameValue as Er, ToonShadingSchema as Es, Lathe3DOptions as Et, PhysicsRect as F, staggerRanks as Fa, boxPath as Fi, normalizeTextSpans as Fn, FromToOptions as Fo, KeyBook as Fr, computeLayoutSync as Fs, Ring3DOptions as Ft, InterpolateOptions as G, toPathData as Ga, drawOnKeys as Gi, FRAMEFIELDS_AI_PROXY_URL as Gn, LightTypeSchema as Go, MotionSize as Gr, Swarm3DOptions as Gt, LightingRig as H, themeFrames as Ha, defineMeta as Hi, Ai as Hn, LightNode as Ho, MotionOptions as Hr, Text3DOptions as Ht, PhysicsRopeOptions as I, stepExpression as Ia, catmullRom as Ii, parseMarkup as In, GeometryOutlineOptionsSchema as Io, LayerStyleConfig as Ir, computeStaggerDelay as Is, RoundedBox3DOptions as It, TextMeasureResult as J, transparent as Ja, elevationStyle as Ji, RunOptions as Jn, MatteMode as Jo, ProjectDefaults as Jr, PhysicsBody3D as Jt, SpringConfig as K, toSeconds as Ka, ease$1 as Ki, QueueStatus as Kn, MaterialType as Ko, ParticleOptions as Kr, Body3DOptions as Kt, PhysicsSpringOptions as L, supersede as La, chain as Li, rich as Ln, Keyframe as Lo, MOTION_PRESETS as Lr, evaluateAnimationAtFrame as Ls, Shape3DContainer as Lt, FieldSample2D as M, springTrack as Ma, bind as Mi, color as Mn, EnvironmentPresetSchema as Mo, GrainOptions as Mr, compositorToProgram as Ms, Primitive3DNodeOptions as Mt, PhysicsBody2D as N, squigglePath as Na, boilKeys as Ni, italic as Nn, FlexNode as No, HandOptions as Nr, computeCarrierContinuity as Ns, Prism3DOptions as Nt, StyleName as O, smoothRelease as Oa, bakeSamples as Oi, TextSpanItem as On, EnvironmentFloorSchema as Oo, GlyphAnimator as Or, WiggleOptions as Os, Line3DOptions as Ot, PhysicsGroundOptions as P, staggerOffsets as Pa, boundsOf as Pi, mark as Pn, FlexNodeSchema as Po, Host as Pr, computeLayout as Ps, Pyramid3DOptions as Pt, interpolate as Q, withAlpha as Qa, evaluateGlyphExpression as Qi, Anchor as Qn, MediaNodeSchema as Qo, ResolvedMotion as Qr, PhysicsWorld3D as Qt, PhysicsWallsOptions as R, surfaceFill as Ra, constantExpression as Ri, size as Rn, KeyframeTuple as Ro, MeasureFn as Rr, evaluateTrackAtFrame as Rs, Shard3DOptions as Rt, SubjectSandwichOptions as S, resolveTarget as Sa, anchorPoint as Si, ChartSeries as Sn, ColorStopSchema as So, ExtrudedTextOptions as Sr, TextSpanMarkSchema as Ss, Grid3DOptions as St, blurRegion as T, safeArea as Ta, ascending as Ti, ChartX as Tn, CompositorToProgramOptions as To, FrameContextLike as Tr, ToneMappingSchema as Ts, Instances3DOptions as Tt, LightingRigOptions as U, themes as Ua, defineTheme as Ui, AiConfig as Un, LightNodeSchema as Uo, MotionPreset as Ur, Torus3DOptions as Ut, Lighting as V, textLayout as Va, defineComponent as Vi, sup as Vn, LayoutNodeSchema as Vo, Metrics$1 as Vr, mergeAnimationTracks as Vs, Surface3DOptions as Vt, Easing as W, toFrames as Wa, dist as Wi, ApiError as Wn, LightType as Wo, MotionPresetName as Wr, Tube3DOptions as Wt, bezier as X, valueAt as Xa, enterAnimation as Xi, ai as Xn, MediaAnimatableProp as Xo, PulseOptions as Xr, PhysicsRope3DOptions as Xt, TextMeasureStyle as Y, typingFrames as Ya, ellipsePath as Yi, ValidationError as Yn, MatteModeSchema as Yo, PropsOf as Yr, PhysicsBox3D as Yt, computeStrokeRect as Z, windowExpression as Za, evaluateEase as Zi, AnalyzeOptions as Zn, MediaNode as Zo, Rect as Zr, PhysicsSpring3DOptions as Zt, RenderVideoResult as _, quantize as _a, UnitSchedule as _i, ChartAxisOptions as _n, CarrierHandoffConfig as _o, CuesOf as _r, TextAnimatableProp as _s, CubeFaceConfig as _t, AnimatableNode as a, holdFirstKeys as aa, StaggerOrder as ai, PhysicsDriver as an, AnimationTrack as ao, BakeOptions as ar, SceneOptions as as, requiresIsolation as at, SmartFramingOptions as b, resampleBands as ba, after as bi, ChartOptions as bn, ColorSignalOptions as bo, Elevation as br, TextNode as bs, ExtrudeShape3DOptions as bt, CompositionOptions as c, last as ca, TargetContext as ci, ParticleBlend as cn, BloomConfigSchema as co, BuildContext as cr, Sequence as cs, SceneSequenceOptions as ct, EnvironmentOptions as d, lineShift as da, Theme as di, ClipVision as dn, CameraAnimation as do, ComponentDefaults as dr, ShapeAnimatableProp as ds, Transition as dt, findRange as ea, Rgba as ei, Particles as en, within as eo, AnimatableMethods as er, Model3DNode as es, measureSpring as et, Layer as f, luminance as fa, ThemeInput as fi, ClipVisionOptions as fn, CameraDoF as fo, ComponentDefinition as fr, ShapeNode as fs, TransitionDirection as ft, RenderVideoOptions as g, pulseKeys as ga, UNIT_INDEX as gi, ChartAnimationOptions as gn, CameraShake as go, Cues as gr, SpringOptions as gs, Cube3DOptions as gt, NodeCapability as h, parseColor as ha, TrackedObjectLike as hi, PoseKeypointName as hn, CameraNodeSchema as ho, Cue as hr, SizeSpec as hs, Carousel3DOptions as ht, analyzeAudio as i, hashString as ia, Spring as ii, PhysicsCollision as in, AnimatablePropsFor as io, AudioLevels as ir, SceneDefinitionSchema as is, preloadFont as it, Body2DOptions as j, springSettleFrames as ja, beats as ji, code as jn, EnvironmentPreset as jo, GlyphUnit as jr, collectNodeOps as js, Polyhedron3DOptions as jt, Styles as k, springAt as ka, bandEdges as ki, accent as kn, EnvironmentFog as ko, GlyphBox as kr, applyStaggerToChildren as ks, Plane3DOptions as kt, EditableObjectTrack as l, lerp2 as la, TargetNode as li, ParticleBounds as ln, BoxNode as lo, BuildResult as lr, SequenceOptions as ls, SequenceEntry as lt, Media as m, offsetCues as ma, Track as mi, PersonTrack as mn, CameraNode as mo, ComponentMeta as mr, SignalTrackOptions as ms, Capsule3DOptions as mt, bindComponent as n, glyphAnimator as na, SAFE_INSETS as ni, BodyCommonOptions as nn, wordRanges as no, ArrowCurve as nr, Scene as ns, measureTextAsync as nt, CompatibleEffect as o, inkOn as oa, SyntaxKind as oi, PhysicsWorldOptions as on, BlockNode as oo, BakedKey as or, SceneTransitionType as os, spring as ot, Light as p, mix as pa, ThemeName as pi, PersonPlacement as pn, CameraLens as po, ComponentExtras as pr, ShapeNodeSchema as ps, TransitionSpec as pt, StrokeRect as q, transformPathData as qa, elevate as qi, Result as qn, MaterialTypeSchema as qo, Placement as qr, FieldSample3D as qt, z$2 as r, hashRng as ra, SafeInsets as ri, PhysicsBakeOptions as rn, AnimatableProp as ro, ArrowGeometry as rr, SceneDefinition as rs, preloadCompositionFonts as rt, Composition as s, isLight as sa, Target as si, EmitterShape as sn, BloomConfig as so, BaseProps as sr, SceneTransitionTypeSchema as ss, springCalculation as st, ComponentNode as t, frameSpan as ta, Rng as ti, ParticlesOptions as tn, wobblePoints as to, ArcPath as tr, Model3DNodeSchema as ts, measureText as tt, Effect as u, linePath as ua, TextLayout as ui, ParticleShape as un, BoxNodeSchema as uo, CanvasSize as ur, SequenceTimelineResult as us, SequenceNode as ut, SectionNode as v, rangeRects as va, Vec2$1 as vi, ChartCandle as vn, CarrierHandoffConfigSchema as vo, CutoutOptions as vr, TextAnimator as vs, CubeFaceInput as vt, TrackedRegionOptions as w, round as wa, arrowPaths as wi, ChartType as wn, CompositorProgramSchema as wo, FontRole as wr, ToneMapping as ws, InstanceTransform3D as wt, SubjectOutlineOptions as x, resolveMotion as xa, analyzeChannels as xi, ChartPadding as xn, ColorStop as xo, ElevationLevel as xr, TextNodeSchema as xs, ExtrudedText3DOptions as xt, SectionOptions as y, rendererChars as ya, WordRange as yi, ChartDatum as yn, CarrierState as yo, EaseFn as yr, TextAnimatorSchema as ys, Cylinder3DOptions as yt, PhysicsWorld2D as z, targetPoint as za, contrastRatio as zi, span as zn, LayerAnimation as zo, MeasureOptions as zr, hoistMattes as zs, SolidShape3DNode as zt };
-//# sourceMappingURL=index-9xte4JgL.d.mts.map
+export { SpringConfig as $, springSettleFrames as $a, beats as $i, color as $n, EnvironmentFogSchema as $o, GlyphUnit as $r, SpringOptions as $s, Scatter3DNode as $t, VolumetricFogNoiseOptions as A, last as Aa, type TargetContext as Ai, PoseKeypointName as An, BloomConfigSchema as Ao, BuildContext as Ar, MediaAnimatableProp as As, Icosphere3DOptions as At, PhysicsBody2D as B, rangeRects as Ba, Vec2$1 as Bi, ChartDatum as Bn, CarrierHandoffConfigSchema as Bo, CutoutOptions as Br, SceneDefinitionSchema as Bs, Prism3DOptions as Bt, SectionOptions as C, frameSpan as Ca, computeStaggerDelay as Cc, Rng as Ci, ParticleBlend as Cn, wordRanges as Co, ArcPath as Cr, LightType as Cs, Cube3DOptions as Ct, SubjectSandwichOptions as D, holdFirstKeys as Da, lintComposition as Dc, StaggerOrder as Di, ClipVisionOptions as Dn, AnimationTrack as Do, BakeOptions as Dr, MaterialTypeSchema as Ds, ExtrudeShape3DOptions as Dt, SubjectOutlineOptions as E, hashString as Ea, hoistMattes as Ec, Spring as Ei, ClipVision as En, AnimatablePropsFor as Eo, AudioLevels as Er, MaterialType as Es, Cylinder3DOptions as Et, StyleName as F, mix as Fa, ThemeName as Fi, RigMap as Fn, CameraLens as Fo, ComponentExtras as Fr, Model3DNodeSchema as Fs, Line3DOptions as Ft, PhysicsWallsOptions as G, rng as Ga, arcPath as Gi, ChartType as Gn, CompositorProgramConfig as Go, FontNeed as Gr, SequenceOptions as Gs, Shard3DOptions as Gt, PhysicsRect as H, resampleBands as Ha, after as Hi, ChartPadding as Hn, ColorSignalOptions as Ho, Elevation as Hr, SceneTransitionType as Hs, Ring3DOptions as Ht, Styles as I, offsetCues as Ia, Track as Ii, retargetPose as In, CameraNode as Io, ComponentMeta as Ir, ModelAnimationLayer as Is, Plane3DOptions as It, Lighting as J, scaleFrames as Ja, audioLevelsSchema as Ji, MarkOptions as Jn, CrowdConfig as Jo, FrameValue as Jr, ShapeNode as Js, Surface3DOptions as Jt, PhysicsWorld2D as K, round as Ka, arrowPaths as Ki, ChartX as Kn, CompositorProgramSchema as Ko, FontRole as Kr, SequenceTimelineResult as Ks, SolidShape3DNode as Kt, Physics as L, parseColor as La, TrackedObjectLike as Li, ChartAnimationOptions as Ln, CameraNodeSchema as Lo, Cue as Lr, NumberTrack as Ls, Points3DOptions as Lt, blurRegion as M, linePath as Ma, TextLayout as Mi, RIG_PRESETS as Mn, BoxNodeSchema as Mo, CanvasSize as Mr, MediaNodeSchema as Ms, Instances3DOptions as Mt, editTrackedRegion as N, lineShift as Na, Theme as Ni, RetargetBone as Nn, CameraAnimation as No, ComponentDefaults as Nr, Model3DAnimatableProp as Ns, Lathe3DOptions as Nt, TrackEditing as O, inkOn as Oa, mergeAnimationTracks as Oc, SyntaxKind as Oi, PersonPlacement as On, BlockNode as Oo, BakedKey as Or, MatteMode as Os, ExtrudedText3DOptions as Ot, section as P, luminance as Pa, ThemeInput as Pi, RetargetOptions as Pn, CameraDoF as Po, ComponentDefinition as Pr, Model3DNode as Ps, Layer3D as Pt, InterpolateOptions as Q, springKeys as Qa, basePropsSchema as Qi, code as Qn, EnvironmentFog as Qo, GlyphProps as Qr, SpringBoneChain as Qs, Swarm3DOptions as Qt, Body2DOptions as R, pulseKeys as Ra, UNIT_INDEX as Ri, ChartAxisOptions as Rn, CameraShake as Ro, Cues as Rr, Scene as Rs, Polyhedron3DOptions as Rt, SectionNode as S, findRange as Sa, computeLayoutSync as Sc, Rgba as Si, EmitterShape as Sn, wobblePoints as So, AnimatableMethods as Sr, LightNodeSchema as Ss, Carousel3DOptions as St, SmartFramingOptions as T, hashRng as Ta, evaluateTrackAtFrame as Tc, SafeInsets as Ti, ParticleShape as Tn, AnimatableProp as To, ArrowGeometry as Tr, LookAtConstraint as Ts, CubeFaceInput as Tt, PhysicsRopeOptions as U, resolveMotion as Ua, analyzeChannels as Ui, ChartSeries as Un, ColorStop as Uo, ElevationLevel as Ur, SceneTransitionTypeSchema as Us, RoundedBox3DOptions as Ut, PhysicsGroundOptions as V, rendererChars as Va, WordRange as Vi, ChartOptions as Vn, CarrierState as Vo, EaseFn as Vr, SceneOptions as Vs, Pyramid3DOptions as Vt, PhysicsSpringOptions as W, resolveTarget as Wa, anchorPoint as Wi, ChartSlice as Wn, ColorStopSchema as Wo, ExtrudedTextOptions as Wr, Sequence as Ws, Shape3DContainer as Wt, LightingRigOptions as X, smoothRelease as Xa, bakeSamples as Xi, accent as Xn, EnvironmentFloor as Xo, GlyphAnimator as Xr, SignalTrackOptions as Xs, Torus3DOptions as Xt, LightingRig as Y, scheduleExpression as Ya, bakeFunction as Yi, TextSpanItem as Yn, EaseRef as Yo, FrameWindow as Yr, ShapeNodeSchema as Ys, Text3DOptions as Yt, Easing as Z, springAt as Za, bandEdges as Zi, bold as Zn, EnvironmentFloorSchema as Zo, GlyphBox as Zr, SizeSpec as Zs, Tube3DOptions as Zt, Media as _, ellipsePath as _a, calculateSequenceTimeline as _c, PropsOf as _i, BodyCommonOptions as _n, valueAt as _o, ai as _r, LayerAnimation as _s, SequenceNode as _t, AnimatableNode as a, chain as aa, TextSpanMarkSchema as ac, MOTION_PRESETS as ai, Body3DOptions as an, supersede as ao, size as ar, EnvironmentSsrSchema as as, interpolate as at, RenderVideoOptions as b, evaluateGlyphExpression as ba, computeCarrierContinuity as bc, ResolvedMotion as bi, PhysicsDriver as bn, withDefaults as bo, Anchor as br, LightAnimatableProp as bs, TransitionSpec as bt, Composition as c, cover as ca, ToneMappingSchema as cc, MediaOptions as ci, PhysicsBox3D as cn, textLayout as co, sup as cr, EnvironmentVolumetricFogNoiseSchema as cs, measureText as ct, Effect as d, defineTheme as da, TrackSource as dc, MotionPreset as di, PhysicsWorld3D as dn, toFrames as do, ApiError as dr, FlexNodeSchema as ds, preloadFont as dt, bind as ea, TextAnimatableProp as ec, GrainOptions as ei, Scatter3DOptions as en, springTrack as eo, italic as er, EnvironmentGi as es, StrokeRect as et, EnvironmentOptions as f, dist as fa, TwoBoneIkConstraint as fc, MotionPresetName as fi, World3DOptions as fn, toPathData as fo, FRAMEFIELDS_AI_PROXY_URL as fr, FromToOptions as fs, requiresIsolation as ft, LightOptions as g, elevationStyle as ga, applyStaggerToChildren as gc, ProjectDefaults as gi, ParticlesOptions as gn, typingFrames as go, ValidationError as gr, KeyframeTuple as gs, SequenceEntry as gt, Light as h, elevate as ha, WindConfig as hc, Placement as hi, Particles as hn, transparent as ho, RunOptions as hr, Keyframe as hs, SceneSequenceOptions as ht, analyzeAudio as i, catmullRom as ia, TextNodeSchema as ic, LayerStyleConfig as ii, TerrainSurface as in, stepExpression as io, rich as ir, EnvironmentSsr as is, computeStrokeRect as it, VolumetricFogOptions as j, lerp2 as ja, TargetNode as ji, PoseSource as jn, BoxNode as jo, BuildResult as jr, MediaNode as js, InstanceTransform3D as jt, TrackedRegionOptions as k, isLight as ka, Target as ki, PersonTrack as kn, BloomConfig as ko, BaseProps as kr, MatteModeSchema as ks, Grid3DOptions as kt, CompositionOptions as l, defineComponent as la, ToonShadingSchema as lc, Metrics$1 as li, PhysicsRope3DOptions as ln, themeFrames as lo, Ai as lr, EnvironmentVolumetricFogSchema as ls, measureTextAsync as lt, Layer as m, ease$1 as ma, WiggleOptions as mc, ParticleOptions as mi, Fracture3DOptions as mn, transformPathData as mo, Result as mr, JointPose as ms, springCalculation as mt, bindComponent as n, boundsOf as na, TextAnimatorSchema as nc, Host as ni, Terrain3DNode as nn, staggerOffsets as no, normalizeTextSpans as nr, EnvironmentPreset as ns, TextMeasureStyle as nt, CameraOptions as o, constantExpression as oa, TextSpanSchema as oc, MeasureFn as oi, FieldSample3D as on, surfaceFill as oo, span as or, EnvironmentVolumetricFog as os, mapBlendModeToSkia as ot, HdriPath as p, drawOnKeys as pa, Vec3Track as pc, MotionSize as pi, Fracture3D as pn, toSeconds as po, QueueStatus as pr, GeometryOutlineOptionsSchema as ps, spring as pt, World2DOptions as q, safeArea as qa, ascending as qi, DEFAULT_CHART_COLORS as qn, CompositorToProgramOptions as qo, FrameContextLike as qr, ShapeAnimatableProp as qs, Sphere3DOptions as qt, z$2 as r, boxPath as ra, TextNode as rc, KeyBook as ri, Terrain3DOptions as rn, staggerRanks as ro, parseMarkup as rr, EnvironmentPresetSchema as rs, bezier as rt, CompatibleEffect as s, contrastRatio as sa, ToneMapping as sc, MeasureOptions as si, PhysicsBody3D as sn, targetPoint as so, sub as sr, EnvironmentVolumetricFogNoise as ss, measureSpring as st, ComponentNode as t, boilKeys as ta, TextAnimator as tc, HandOptions as ti, Sdf3DOptions as tn, squigglePath as to, mark as tr, EnvironmentGiSchema as ts, TextMeasureResult as tt, EditableObjectTrack as u, defineMeta as ua, TrackSignal as uc, MotionOptions as ui, PhysicsSpring3DOptions as un, themes as uo, AiConfig as ur, FlexNode as us, preloadCompositionFonts as ut, Model3DOptions as v, enterAnimation as va, collectNodeOps as vc, PulseOptions as vi, PhysicsBakeOptions as vn, windowExpression as vo, targetSchema as vr, LayoutNode as vs, Transition as vt, SignalOrNumber as w, glyphAnimator as wa, evaluateAnimationAtFrame as wc, SAFE_INSETS as wi, ParticleBounds as wn, AimConstraint as wo, ArrowCurve as wr, LightTypeSchema as ws, CubeFaceConfig as wt, RenderVideoResult as x, exitAnimation as xa, computeLayout as xc, ResolvedTarget as xi, PhysicsWorldOptions as xn, within as xo, Animatable as xr, LightNode as xs, Capsule3DOptions as xt, NodeCapability as y, evaluateEase as ya, compositorToProgram as yc, Rect as yi, PhysicsCollision as yn, withAlpha as yo, AnalyzeOptions as yr, LayoutNodeSchema as ys, TransitionDirection as yt, FieldSample2D as z, quantize as za, UnitSchedule as zi, ChartCandle as zn, CarrierHandoffConfig as zo, CuesOf as zr, SceneDefinition as zs, Primitive3DNodeOptions as zt };
+//# sourceMappingURL=index-DkAjKnhW.d.mts.map