framefields 2.13.1 → 2.15.0

package/dist/{index-C2yaponf.d.mts → index-s2qQ8ifZ.d.mts}

@@ -1,9 +1,10 @@
-import { Pt as MeshAudioDeformConfig, an as OutputItem, bt as MediaOperation, ur as VirtualMediaData } from "./index-a6JrbAK0.mjs";
+import { $n as ToonShading, Ft as MeshAudioDeformConfig, fr as VirtualMediaData, it as GeometryOutlineOptions, on as OutputItem, xt as MediaOperation } from "./index-C-V6CAhP.mjs";
 import { z } from "zod";
 import { Input, VideoSample } from "mediabunny";
 import "fontkit";
 
 //#region ../webgpu-renderers/dist/math3d/index.d.mts
+
 //#region src/math3d/vector3.d.ts
 /**
  * 3D Vector mathematics for camera kinematics, scene projections, and spatial transforms.
@@ -179,6 +180,53 @@ declare const Camera3D: {
   isBoxInFrustum(min: Vec3, max: Vec3, planes: FrustumPlanes): boolean;
 };
 //#endregion
+//#region src/math3d/cube-lens.d.ts
+/** The picture a cube camera's lens draws. */
+type LensProjection = "perspective" | "equirectangular" | "fisheye";
+/** World direction ↔ cube-space direction (a reflection, its own inverse). */
+declare const CUBE_FLIP: (v: Vec3) => Vec3;
+/**
+ * The six cameras that draw a cube map around `eye`: 90° square frusta in
+ * layer order. Their faces meet edge to edge, so the cube covers every
+ * direction once.
+ */
+declare function cubeFaceCameras(eye: Vec3, near: number, far: number): Camera3DPose[];
+/**
+ * Where WebGPU samples a cube for world direction `dir`: the layer and its
+ * (u, v), v down. The selection rule of the WebGPU (Vulkan) spec.
+ */
+declare function cubeTexel(dir: Vec3): {
+  face: number;
+  u: number;
+  v: number;
+};
+/** A camera's orthonormal frame: screen right, screen up and forward. */
+declare function cameraBasis(camera: Camera3DPose): {
+  right: Vec3;
+  up: Vec3;
+  forward: Vec3;
+};
+/** What a lens needs to turn an output pixel into a ray. */
+interface CubeLensOptions {
+  projection: LensProjection;
+  /**
+   * Perspective: vertical field of view. Fisheye: the full angle across the
+   * frame's height (equidistant, up to 360°). Ignored by equirectangular,
+   * which always shows the whole sphere.
+   */
+  fov: number;
+  /** Optical zoom (perspective and fisheye). */
+  zoom: number;
+}
+/** Output pixels per radian at the centre of the view. */
+declare function lensCenterDensity(lens: CubeLensOptions, width: number, height: number): number;
+/**
+ * Face size that matches the lens's pixel density at the centre of the view:
+ * a face holds `size / 2` pixels per radian at its centre. Rounded up to a
+ * power of two (so a moving lens reuses its targets) and clamped.
+ */
+declare function defaultCubeFaceSize(lens: CubeLensOptions, width: number, height: number, maxSize: number): number;
+//#endregion
 //#region src/math3d/environment3d.d.ts
 /**
  * "neutral" (default, Khronos PBR Neutral): colors as authored, highlights
@@ -186,7 +234,7 @@ declare const Camera3D: {
  * hot highlights gracefully. "aces": punchy film contrast, shifts hues.
  */
 type ToneMapping = "neutral" | "agx" | "aces" | "none";
-type EnvironmentPreset = "studio" | "soft" | "sunset" | "night" | "neutral";
+type EnvironmentPreset = "studio" | "soft" | "warm" | "sunset" | "night" | "neon" | "neutral";
 interface Environment3DFog {
   /** Display color surfaces fade into; match the background for a seamless horizon. */
   color: string;
@@ -211,8 +259,62 @@ interface Environment3DFloor {
   /** Optional overall opacity of the floor plane, 0..1 (default 1; 0 draws only the additive reflection over background). */
   opacity?: number;
 }
+interface Environment3DVolumetricFogNoise {
+  /** World-space noise frequency (1 / period in px). Default 0.003. */
+  scale?: number;
+  /** Density modulation depth 0..1. Default 0.45. */
+  strength?: number;
+  /** Wind drift velocity [vx, vy, vz] in world px/sec. Default [20, -8, 12]. */
+  speed?: [number, number, number];
+  /** FBM octaves 1..3. Default 2. */
+  octaves?: number;
+}
+interface Environment3DVolumetricFog {
+  /** Base extinction/scattering density (typical range 0.002..0.15, default 0.02). */
+  density?: number;
+  /** In-scattering albedo tint (default: environment horizon color). */
+  color?: string;
+  /** Henyey-Greenstein forward/back scatter asymmetry g in (-0.95..0.95). Default 0.55. */
+  anisotropy?: number;
+  /** Exponential height falloff rate (0 = uniform, >0 = ground mist). Default 0.0015. */
+  heightFalloff?: number;
+  /** Reference world Y height for ground fog (px, y down). Default 540. */
+  baseHeight?: number;
+  /** Raymarch step count per half-res pixel (8..64, default 28). */
+  steps?: number;
+  /** Maximum raymarch distance from camera in world px. Default 2800. */
+  maxDistance?: number;
+  /** Multiplier on direct-light in-scattering / god rays. Default 1.5. */
+  lightIntensity?: number;
+  /** Multiplier on ambient / sky in-scattering. Default 0.35. */
+  ambientIntensity?: number;
+  /** Optional 3D procedural FBM turbulence in the fog medium. */
+  noise?: boolean | Environment3DVolumetricFogNoise;
+}
+/** Screen-space reflections: glossy surfaces reflect what the camera sees. */
+interface Environment3DSsrOptions {
+  /** How fully a found reflection replaces the environment's, 0..1. Default 0.85. */
+  intensity?: number;
+  /** Roughest surface that traces reflections (0..1); rougher ones keep the environment. Default 0.6. */
+  maxRoughness?: number;
+  /** How far behind a surface, in world px, a ray still counts as hitting it. Default 120. */
+  thickness?: number;
+  /** Hi-Z march iterations per ray (16..64). Default 32. */
+  steps?: number;
+}
+/** Screen-space diffuse GI: ambient occlusion plus one bounce of visible light. */
+interface Environment3DGiOptions {
+  /** Strength of the bounced light, 0..4. Default 1. */
+  intensity?: number;
+  /** Gather radius in world px. Default 400. */
+  radius?: number;
+  /** Horizon-scan directions per pixel (4..16). Default 6. */
+  samples?: number;
+}
 interface Environment3DOptions {
   preset?: EnvironmentPreset;
+  /** Equirectangular panorama for real HDRI IBL: a `.hdr` (Radiance RGBE) or `.exr` (OpenEXR) path, or the file's bytes. */
+  hdri?: string | Uint8Array;
   /** Overrides the preset's sky (above), horizon and ground colors. */
   top?: string;
   horizon?: string;
@@ -229,6 +331,13 @@ interface Environment3DOptions {
   toneMapping?: ToneMapping;
   fog?: Environment3DFog;
   floor?: Environment3DFloor;
+  outlines?: boolean | GeometryOutlineOptions;
+  /** Froxel-style volumetric participating media & shadowed light shafts (god rays). */
+  volumetricFog?: boolean | Environment3DVolumetricFog;
+  /** Screen-space reflections of nearby geometry and emissives on glossy surfaces. */
+  ssr?: boolean | Environment3DSsrOptions;
+  /** Screen-space diffuse GI: occlusion and color bleeding from visible surfaces. */
+  gi?: boolean | Environment3DGiOptions;
 }
 interface PresetDef {
   top: string;
@@ -238,11 +347,28 @@ interface PresetDef {
 }
 declare const ENVIRONMENT_PRESETS: Record<EnvironmentPreset, PresetDef>;
 declare function linearRgb(color: string): [number, number, number];
+interface ResolvedVolumetricFog {
+  density: number;
+  color: [number, number, number];
+  anisotropy: number;
+  heightFalloff: number;
+  baseHeight: number;
+  steps: number;
+  maxDistance: number;
+  lightIntensity: number;
+  ambientIntensity: number;
+  noiseScale: number;
+  noiseStrength: number;
+  noiseSpeed: [number, number, number];
+  noiseOctaves: number;
+}
 interface ResolvedEnvironment {
   top: [number, number, number];
   horizon: [number, number, number];
   bottom: [number, number, number];
   softboxes: number;
+  intensity: number;
+  hdri?: string | Uint8Array;
   rotationRad: number;
   exposureMultiplier: number;
   toneMapping: number;
@@ -260,12 +386,29 @@ interface ResolvedEnvironment {
     fadeDistance: number;
     opacity: number;
   };
+  volumetricFog?: ResolvedVolumetricFog;
+  ssr?: ResolvedSsr;
+  gi?: ResolvedGi;
+}
+interface ResolvedSsr {
+  intensity: number;
+  maxRoughness: number;
+  thickness: number;
+  steps: number;
 }
+interface ResolvedGi {
+  intensity: number;
+  radius: number;
+  samples: number;
+}
+declare function resolveSsr(ssr: boolean | Environment3DSsrOptions | undefined): ResolvedSsr | undefined;
+declare function resolveGi(gi: boolean | Environment3DGiOptions | undefined): ResolvedGi | undefined;
+declare function resolveVolumetricFog(vf: boolean | Environment3DVolumetricFog | undefined, defaultColor: [number, number, number]): ResolvedVolumetricFog | undefined;
 /** Linear radiance and shader codes for an environment. */
 declare function resolveEnvironment(opts: Environment3DOptions): ResolvedEnvironment;
 /** Where a shadow-casting light's depth map lives, for the lit shaders. */
 interface ShadowUniformInfo {
-  /** Light view-projection (world → shadow clip). */
+  /** Light view-projection (world → shadow clip). For omnidirectional point shadows, element [0] stores far plane. */
   matrix: ArrayLike<number>;
   /** Index of the casting light among the packed (non-ambient) lights. */
   lightIndex: number;
@@ -279,10 +422,20 @@ interface ShadowUniformInfo {
   normalOffset: number;
   /** 0 = invisible shadows, 1 = fully dark. */
   darkness: number;
+  /** Starting layer index in the shadow depth 2D array texture. */
+  baseLayer?: number;
+  /** Number of array layers consumed by this shadow entry (1 for directional/spot/rect, 6 for point). */
+  layerCount?: number;
+  /** Shadow projection mode: 1 = 2D frustum, 2 = 6-face omnidirectional cube. */
+  mode?: 1 | 2;
+  /** Near plane distance in world px (used by mode=2 omnidirectional point shadows). */
+  near?: number;
+  /** Far plane distance in world px (used by mode=2 omnidirectional point shadows). */
+  far?: number;
 }
 //#endregion
 //#region src/math3d/light3d.d.ts
-type LightKind = "ambient" | "directional" | "point" | "spot";
+type LightKind = "ambient" | "directional" | "point" | "spot" | "rect";
 interface Light3DOptions {
   id?: string;
   lightType?: LightKind;
@@ -307,7 +460,15 @@ interface Light3DOptions {
   decay?: number;
   angle?: number;
   penumbra?: number;
-  /** Directional or spot: render a shadow map (the first such light wins). */
+  /** 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;
+  /** In-plane roll angle in degrees around the light's forward axis (default 0). */
+  rotation?: number;
+  /** Directional, spot, point, or rect: render a shadow map. */
   castShadow?: boolean;
   /** Shadow edge blur in shadow-map texels (default 2). */
   shadowSoftness?: number;
@@ -315,22 +476,40 @@ interface Light3DOptions {
   shadowDarkness?: number;
 }
 interface GPULightData {
-  /** xyz = position, w = type (0=ambient, 1=directional, 2=point, 3=spot) */
+  /** xyz = position, w = type (0=ambient, 1=directional, 2=point, 3=spot, 4=rect) */
   posType: [number, number, number, number];
   /** xyz = normalized direction, w = radius */
   dirRadius: [number, number, number, number];
   /** rgb = linear color, w = intensity */
   colorIntensity: [number, number, number, number];
-  /** x = cos(outer), y = cos(inner), z = decay, w = 0 */
+  /** x = cos(outer), y = cos(inner), z = decay, w = twoSided (rect) */
   spotParams: [number, number, number, number];
+  /** xyz = normalized right axis of rect area light, w = halfWidth */
+  rectRight: [number, number, number, number];
+  /** xyz = normalized up axis of rect area light, w = halfHeight */
+  rectUp: [number, number, number, number];
 }
 /** Slots retained in the legacy uniform prefix; actual direct lights use storage. */
 declare const MAX_LIGHTS = 8;
 /**
  * 16 (ambient) + 16 (params) + 8 * 64 (lights), then the physical-shading
- * block appended after them: 8 vec4 (128) + shadow matrix (64) + floorParams (16).
+ * block appended after them: 8 vec4 (128) + shadow matrix (64) +
+ * floorParams (16) + HDRI irradiance SH (9 vec4, 144) + screen indirect (16).
  */
 declare const LIGHT_UNIFORM_SIZE_BYTES: number;
+/**
+ * Which half of a screen-space indirect (SSR / GI) frame a pass draws:
+ * `radiance` writes the unfogged scene radiance the traces read; `apply`
+ * shades with the traced reflections and bounce light.
+ */
+type ScreenIndirectPass = "radiance" | "apply";
+/** A prefiltered HDRI as the lights uniform describes it. */
+interface HdriUniforms {
+  /** Highest mip of the radiance cubemap (roughness 1). */
+  maxMip: number;
+  /** 9 L2 irradiance SH coefficients, one vec4 (rgb + pad) each. */
+  sh: Float32Array;
+}
 interface LightsUniformData {
   ambientColor: [number, number, number, number];
   params: [number, number, number, number];
@@ -345,6 +524,7 @@ declare function parseColorToRgb(color?: string | [number, number, number] | [nu
   b: number;
   a?: number;
 } | unknown): [number, number, number];
+declare const DIRECT_LIGHT_FLOATS = 48;
 declare const Light3D: {
   /**
    * Computes the 3x3 normal matrix (stored in 4x4 layout) from a 4x4 Model matrix.
@@ -358,15 +538,49 @@ declare const Light3D: {
   /**
    * Packs active scene lights into a Float32Array matching WGSL LightsUniforms layout.
    */
-  packLightsUniforms(lights: Light3DOptions[], environment?: Environment3DOptions | null, shadow?: ShadowUniformInfo | null, isReflectionPass?: boolean): Float32Array;
+  packLightsUniforms(lights: Light3DOptions[], environment?: Environment3DOptions | null, shadow?: ShadowUniformInfo | null, isReflectionPass?: boolean, hdri?: HdriUniforms, screenIndirect?: ScreenIndirectPass): Float32Array;
   /** Packs every direct light for the variable-length GPU storage binding. */
   packDirectLights(lights: Light3DOptions[], shadows?: ShadowUniformInfo[]): Float32Array;
   /** Index (among non-ambient lights) of the light that should cast shadows, or -1. */
   shadowCasterIndex(lights: Light3DOptions[]): number;
   /** Fills params.zw and the appended physical-shading block (offset 136 on). */
-  packPhysicalBlock(buffer: Float32Array, lights: Light3DOptions[], environment?: Environment3DOptions | null, shadow?: ShadowUniformInfo | null, isReflectionPass?: boolean): void;
+  packPhysicalBlock(buffer: Float32Array, lights: Light3DOptions[], environment?: Environment3DOptions | null, shadow?: ShadowUniformInfo | null, isReflectionPass?: boolean, hdri?: HdriUniforms, screenIndirect?: ScreenIndirectPass): void;
 };
 //#endregion
+//#region src/math3d/noise.d.ts
+/**
+ * Seeded, deterministic gradient noise (Perlin, improved) and the fractal
+ * sums procedural geometry is built from. Same seed, same field: on every
+ * machine and every frame.
+ */
+/** mulberry32: a small, fast, well-distributed 32-bit PRNG. Returns [0, 1). */
+declare function createRandom(seed: number): () => number;
+interface Noise {
+  /** Gradient noise in about [-1, 1]. */
+  noise2(x: number, y: number): number;
+  /** Gradient noise in about [-1, 1]. */
+  noise3(x: number, y: number, z: number): number;
+}
+/** A gradient noise field whose lattice is shuffled by `seed`. */
+declare function createNoise(seed?: number): Noise;
+type FractalMode = "fbm" | "ridged" | "terrace";
+interface FractalOptions {
+  octaves: number;
+  persistence: number;
+  lacunarity: number;
+  mode: FractalMode;
+}
+/**
+ * Fractal sum of `octaves` noise layers at (x, y), in [0, 1] before any
+ * normalization: "fbm" rolls, "ridged" folds each octave into sharp crests
+ * (Musgrave's ridged multifractal: each octave weighted by the last, so
+ * detail gathers on ridges, not in valleys). Terracing is applied later,
+ * over the normalized field.
+ */
+declare function fractal2(noise: Noise, x: number, y: number, o: FractalOptions): number;
+/** Stepped plateaus: each step flat for most of its width, then a steep riser. */
+declare function terrace(h: number, steps: number): number;
+//#endregion
 //#region src/math3d/path3d.d.ts
 interface Path3DPoint {
   /** Position in 3D world space [x, y, z] */
@@ -470,6 +684,53 @@ declare class Path3D {
   static circle(options: CirclePathOptions): Path3D;
 }
 //#endregion
+//#region src/math3d/relativistic-doppler.d.ts
+/**
+ * Relativistic observer: what a camera moving at a fraction `β` of the speed
+ * of light sees of a scene at rest.
+ *
+ * Aberration: a ray arriving at angle θ' from the direction of motion left
+ * the scene at θ, with cos θ = (cos θ' − β) / (1 − β cos θ'). The Doppler
+ * factor D = γ (1 + β cos θ') scales every frequency, and spectral radiance
+ * transforms as L'(λ') = D⁵ L(D λ') (the "searchlight": ahead is brighter).
+ *
+ * A pixel only stores a colour, so its spectrum is modelled: the colour is a
+ * reflectance (three smooth bands that sum to one, held flat past the visible
+ * range, so red surfaces stay red into the infrared) lit by daylight (a
+ * 5778 K black body). Shifting that spectrum and integrating it against the
+ * CIE 1931 observer gives the colour seen. `dopplerColorMatrix(D)` is the
+ * resulting linear map on linear sRGB, exactly the identity at D = 1.
+ */
+/**
+ * The linear-sRGB matrix (row-major 3×3) that turns a colour at rest into the
+ * colour seen at Doppler factor `d` (> 1 towards the direction of motion).
+ */
+declare function dopplerColorMatrix(d: number, beaming?: boolean): number[][];
+/** Largest Doppler factor the lookup table covers (β ≈ 0.99995). */
+declare const DOPPLER_LUT_MAX = 200;
+/** Entries in the lookup table, evenly spaced in ln D. */
+declare const DOPPLER_LUT_SIZE = 256;
+/**
+ * `dopplerColorMatrix` sampled at DOPPLER_LUT_SIZE factors evenly spaced in
+ * ln D over [1/DOPPLER_LUT_MAX, DOPPLER_LUT_MAX]: three vec4 rows per entry.
+ */
+declare function dopplerLut(beaming: boolean): Float32Array;
+/**
+ * How much brighter a neutral surface looks at Doppler factor `d`: the gain
+ * an exposure meter would compensate for.
+ */
+declare function dopplerLuminanceGain(d: number, doppler: boolean, beaming: boolean): number;
+/** Lorentz factor of speed β. */
+declare function lorentzFactor(beta: number): number;
+/**
+ * Where a ray seen at angle `observedCos` (cosine to the direction of motion)
+ * left the scene at rest, and its Doppler factor.
+ */
+declare function aberrate(observedCos: number, beta: number): {
+  sourceCos: number;
+  doppler: number;
+};
+//#endregion
 //#endregion
 //#region ../webgpu-renderers/dist/text-animations/index.d.mts
 //#region src/text-animations/advanced-types.d.ts
@@ -2257,6 +2518,8 @@ interface SlugFont {
   fontFamily?: string;
   hasTrueWeight?: boolean;
   weight?: number;
+  /** The variable axes this instance was asked for (spans inherit them). */
+  variableAxes?: Record<string, number>;
 }
 //#endregion
 //#region src/slug/slug-pipeline.d.ts
@@ -2638,6 +2901,18 @@ declare class InputStore {
 declare const inputStore: InputStore;
 //#endregion
 //#region src/loaders/types.d.ts
+/**
+ * One morph target's deltas. Dense: 3 floats per vertex. Sparse (with
+ * `indices`): 3 floats per listed vertex, every other vertex unmoved.
+ */
+interface MorphTarget3D {
+  positions?: Float32Array;
+  normals?: Float32Array;
+  /** The moved vertices, ascending; absent for dense deltas. */
+  indices?: Uint32Array;
+}
+/** A morph target's position (or normal) deltas as a dense array. */
+
 interface Mesh3DData {
   id?: string;
   name?: string;
@@ -2645,12 +2920,11 @@ interface Mesh3DData {
   normals: Float32Array;
   uvs: Float32Array;
   /** Object-space morph deltas, applied before skinning. */
-  morphTargets?: {
-    positions?: Float32Array;
-    normals?: Float32Array;
-  }[];
+  morphTargets?: MorphTarget3D[];
   /** Default morph weights for this mesh instance. */
   morphWeights?: number[];
+  /** Morph target names (glTF mesh `extras.targetNames`), one per target. */
+  morphTargetNames?: string[];
   /** Per-map UVs, with the map's own texture transform already applied. */
   mapUvs?: {
     normal?: Float32Array;
@@ -2665,12 +2939,24 @@ interface Mesh3DData {
   tangents?: Float32Array;
   jointIndices?: Float32Array;
   jointWeights?: Float32Array;
+  /** A second set of 4 influences per vertex (glTF JOINTS_1 / WEIGHTS_1): up to 8 in all, the weights of both sets summing to 1. */
+  jointIndices1?: Float32Array;
+  jointWeights1?: Float32Array;
   materialName?: string;
   /** Scene node that places this mesh (Model3DData.nodes); its world matrix applies unless the mesh is skinned. */
   node?: number;
   /** Skin (Model3DData.skins) whose joints deform this mesh; jointIndices index its `joints`. */
   skin?: number;
 }
+/** The maps of a material besides its base color. */
+type MaterialMapSlot = "normal" | "metallicRoughness" | "occlusion" | "emissive";
+/** Addressing and filtering of one texture. */
+interface TextureSampling {
+  wrapU: "repeat" | "clamp" | "mirror";
+  wrapV: "repeat" | "clamp" | "mirror";
+  /** Magnification filter. */
+  filter: "linear" | "nearest";
+}
 interface Material3D {
   name: string;
   diffuseColor?: [number, number, number, number];
@@ -2693,13 +2979,22 @@ interface Material3D {
   textureWrap?: "repeat" | "clamp" | "mirror";
   /** Magnification filter (glTF sampler magFilter); "nearest" keeps texels sharp. */
   textureFilter?: "linear" | "nearest";
+  /**
+   * How each other map is sampled, when it says (glTF: its own sampler).
+   * A map without an entry samples like the base color map.
+   */
+  mapSampling?: Partial<Record<MaterialMapSlot, TextureSampling>>;
   normalTexture?: string;
   twoSided?: boolean;
   /** "mask" discards texels below `alphaCutoff`; "blend" draws after the opaque meshes. */
   alphaMode?: "opaque" | "mask" | "blend";
   alphaCutoff?: number;
   /** How the material wants to be lit when the layer leaves `material` unset. */
-  shading?: "lit" | "unlit" | "toon";
+  shading?: "lit" | "unlit" | "toon" | "glass";
+  /** Glass (KHR_materials_transmission): index of refraction (KHR_materials_ior). */
+  ior?: number;
+  /** Glass: thickness in model units (KHR_materials_volume thicknessFactor). */
+  thickness?: number;
   /** Toon shading: the color multiplier of the shadowed side. */
   shadeColor?: [number, number, number];
   /** Linear-ish emissive color 0..1 (glTF emissiveFactor). */
@@ -2716,6 +3011,29 @@ interface Material3D {
   occlusionStrength?: number;
   /** Encoded emissive color map (multiplies `emissive`). */
   emissiveTextureBuffer?: Uint8Array;
+  /** Layered shading lobes from the file's material extensions (display colors, degrees). */
+  surface?: MaterialSurface;
+}
+/**
+ * Physical lobes a model file's material asks for, in the units layers use:
+ * KHR_materials_clearcoat / _sheen / _anisotropy / _iridescence, and
+ * subsurface from `extras.framefields.subsurface` (glTF has no skin lobe).
+ */
+interface MaterialSurface {
+  clearcoat?: number;
+  clearcoatRoughness?: number;
+  sheen?: number;
+  sheenColor?: [number, number, number];
+  sheenRoughness?: number;
+  anisotropy?: number;
+  /** Degrees. */
+  anisotropyRotation?: number;
+  iridescence?: number;
+  iridescenceIor?: number;
+  /** Film thickness, nm. */
+  iridescenceThickness?: number;
+  subsurface?: number;
+  subsurfaceColor?: [number, number, number];
 }
 /** A scene-graph node: its rest transform and parent (glTF node semantics). */
 interface ModelNode3D {
@@ -2776,6 +3094,19 @@ interface Model3DData {
   skins?: Skin3D[];
   /** Centering and size normalization, applied above the scene graph instead of baked into vertices. */
   rootTransform?: Mat4;
+  /**
+   * Joints the file drives from other joints (scene `extras.framefields.drivers`):
+   * eyelids following the eyes, twist bones, correctives.
+   */
+  drivers?: {
+    joint: string;
+    from: string;
+    rotate: {
+      x?: number;
+      y?: number;
+      z?: number;
+    };
+  }[];
   animations: AnimationClip3D[];
   bounds: {
     min: Vec3;
@@ -2795,18 +3126,23 @@ interface LoadModelOptions {
   mtlText?: string;
 }
 //#endregion
-//#region src/loaders/obj-loader.d.ts
+//#region src/loaders/3ds-loader.d.ts
+
+declare function parseFBX(bufferOrText: ArrayBuffer | Uint8Array | string, options?: LoadModelOptions): Model3DData;
+declare function loadFBX(srcOrData: string | ArrayBuffer | Uint8Array, options?: LoadModelOptions): Model3DData;
+//#endregion
+//#region src/loaders/gltf-loader.d.ts
 
 declare function parseOBJ(objText: string, mtlText?: string, options?: LoadModelOptions): Model3DData;
 declare function parseMTL(mtlText: string): Record<string, Material3D>;
 declare function loadOBJ(srcOrData: string | ArrayBuffer | Uint8Array, mtlText?: string, options?: LoadModelOptions): Model3DData;
 //#endregion
-//#region src/loaders/fbx-loader.d.ts
+//#region src/loaders/off-loader.d.ts
 
-declare function parseFBX(bufferOrText: ArrayBuffer | Uint8Array | string, options?: LoadModelOptions): Model3DData;
-declare function loadFBX(srcOrData: string | ArrayBuffer | Uint8Array, options?: LoadModelOptions): Model3DData;
 //#endregion
-//#region src/loaders/stl-loader.d.ts
+//#region src/loaders/pose.d.ts
+type Quat = [number, number, number, number];
+/** Column-major translate · rotate(quaternion) · scale. */
 
 //#endregion
 //#region src/lut-store.d.ts
@@ -2889,12 +3225,18 @@ declare class AudioMeshDeformPipeline {
   pipeline: GPUComputePipeline;
   bindGroupLayout: GPUBindGroupLayout;
   private uniformPool;
-  private deformedBuffers;
+  /**
+   * One output per dispatch this frame: layers sharing a mesh deform it
+   * differently, and each draw (and motion blur's copy) reads its own.
+   */
+  private outputs;
+  private outputIndex;
   private uniformData;
   private uniformUint32;
   private uniformFloat32;
   constructor(device: GPUDevice);
-  getOrCreateDeformedBuffer(srcBuffer: GPUBuffer, byteLength: number): GPUBuffer;
+  /** The next output of this frame, at least `byteLength` bytes. */
+  private nextOutput;
   execute(encoder: GPUCommandEncoder, srcVertexBuffer: GPUBuffer, options: DeformDispatchOptions): GPUBuffer;
   resetPools(): void;
   destroy(): void;
@@ -2947,6 +3289,9 @@ declare class FloorReflectionPipeline {
   draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, reflectionTexture: GPUTexture, floor: Environment3DFloor, useMrt?: boolean, useBloom?: boolean): void;
   destroy(): void;
 }
+//#endregion
+//#region src/renderer3d/fracture-geometry.d.ts
+
 //#endregion
 //#region src/renderer3d/glass-pipeline.d.ts
 /**
@@ -2990,13 +3335,60 @@ declare class GlassPipeline {
   destroy(): void;
 }
 //#endregion
-//#region src/renderer3d/matte3d.d.ts
-/** The per-draw matte binding of the 3D pipelines (see `shaders/matte3d.ts`). */
+//#region src/renderer3d/hdr-environment.d.ts
+/** A captured panorama, ready for image-based lighting. */
 
+//#endregion
+//#region src/renderer3d/lens-remap-pipeline.d.ts
+/** An observer moving at `speed` (a fraction of c) through a scene at rest. */
+interface RelativisticObserver {
+  /** β = v / c, 0 ≤ β < 1. */
+  speed: number;
+  /** Unit direction of motion in world space. */
+  direction: Vec3;
+  /** Shift colours along the spectrum (blue ahead, red behind). */
+  doppler: boolean;
+  /** Brighten ahead and dim behind (relativistic beaming). */
+  beaming: boolean;
+  /**
+   * Exposure for the shifted light: stops, or "auto" to meter the centre of
+   * the view, so what the camera looks at keeps its brightness at rest.
+   */
+  exposure: number | "auto";
+}
+interface LensRemapOptions {
+  projection: LensProjection;
+  /** Degrees; see `CubeLensOptions.fov`. */
+  fov: number;
+  zoom: number;
+  /** The camera's frame: screen right, screen up, forward (world space). */
+  basis: {
+    right: Vec3;
+    up: Vec3;
+    forward: Vec3;
+  };
+  observer?: RelativisticObserver | null;
+}
 //#endregion
 //#region src/renderer3d/surface-params.d.ts
+interface IridescenceOptions {
+  /** Thin-film interference blend intensity 0..1 (default 1 when object is passed). */
+  intensity?: number;
+  /** Thin-film thickness in nanometers 100..1000 (default 400). */
+  thickness?: number;
+  /** Thin-film refractive index 1.05..2.5 (default 1.3). */
+  ior?: number;
+}
+interface TriplanarOptions {
+  /** Tiling scale (repeats per 256 world px, or raw UV/px if < 0.05; default 1). */
+  scale?: number;
+  /** Normal blend exponent across projection axes 1..16 (default 4). */
+  sharpness?: number;
+}
 /** Physically based surface inputs every 3D draw (quad, text, mesh) accepts. */
 interface SurfaceParams {
+  toon?: ToonShading;
+  outline?: boolean;
   /** Microsurface roughness 0 (mirror) .. 1 (chalk). Physical scenes default to 0.5. */
   roughness?: number;
   /** 0 = dielectric (plastic, paint, wood), 1 = metal. */
@@ -3007,8 +3399,38 @@ interface SurfaceParams {
   emissiveIntensity?: number;
   /** Casts into a `castShadow` light's shadow map (meshes default on, quads off). */
   castShadow?: boolean;
-}
-/** Floats appended to each 3D model uniform block: pbr vec4 + emissive vec4. */
+  /** Secondary dielectric clearcoat/varnish lobe 0..1 (car paint, wet coats, polished lacquer). */
+  clearcoat?: number;
+  /** Roughness of the clearcoat layer 0..1 (default 0.08). */
+  clearcoatRoughness?: number;
+  /** Anisotropic GGX highlight stretch -1..1 (brushed metal, satin, hair; 0 = isotropic). */
+  anisotropy?: number;
+  /** Brush tangent rotation in degrees around the surface normal (default 0). */
+  anisotropyRotation?: number;
+  /** Subsurface wrap diffuse and translucent back-scattering 0..1 (wax, jade, skin, foliage). */
+  subsurface?: number;
+  /** Subsurface scatter & transmission tint color (default "#ff6b4a"). */
+  subsurfaceColor?: string | Color | [number, number, number];
+  /** Charlie cloth / velvet grazing retro-reflection lobe 0..1. */
+  sheen?: number;
+  /** Cloth sheen tint color (default "#ffffff"). */
+  sheenColor?: string | Color | [number, number, number];
+  /** Cloth sheen microfiber roughness 0.05..1 (default 0.5). */
+  sheenRoughness?: number;
+  /** Thin-film spectral iridescence 0..1 or `{ intensity, thickness, ior }`. */
+  iridescence?: number | IridescenceOptions;
+  /** Thin-film thickness in nanometers 100..1000 (default 400). */
+  iridescenceThickness?: number;
+  /** Thin-film refractive index 1.05..2.5 (default 1.3). */
+  iridescenceIor?: number;
+  /** Seamless world-space triplanar texture projection for UV-less or procedural meshes. */
+  triplanar?: boolean | TriplanarOptions;
+  /** World-space triplanar tiling scale (repeats per 256 world px; >0 enables triplanar). */
+  triplanarScale?: number;
+  /** World-space triplanar axis blend sharpness 1..16 (default 4). */
+  triplanarSharpness?: number;
+}
+/** Shared model uniforms: PBR, emissive, three art-direction vec4s, and four Substrate multi-lobe vec4s. */
 
 //#endregion
 //#region src/renderer3d/mesh3d-pipeline.d.ts
@@ -3024,6 +3446,8 @@ interface MeshMaterialMaps {
   occlusionStrength?: number;
   /** Multiplies the emissive color. */
   emissive?: GPUTexture;
+  /** Each map's own sampler; a map without one samples like the base color. */
+  samplers?: Partial<Record<"normal" | "metallicRoughness" | "occlusion" | "emissive", GPUSampler>>;
 }
 interface MeshGlass {
   /** Index of refraction (1.5 glass, 1.33 water). */
@@ -3035,6 +3459,38 @@ interface MeshGlass {
   /** Frosted blur, 0–1. */
   frost: number;
 }
+/**
+ * Procedural wind: vertices bend downwind by how far they sit above the
+ * mesh's base, swaying in a traveling wave (instances sway out of phase).
+ */
+interface MeshWind {
+  /** Peak lean, degrees. */
+  amplitudeDeg: number;
+  /** Sways per second. */
+  frequency: number;
+  /** Downwind direction on the ground plane [x, z]. */
+  direction: [number, number];
+  /** Gust wavelength across the field, px. */
+  waveScale: number;
+  /** Seconds. */
+  time: number;
+  /** The mesh's base (its largest local y: up is -y) and height, px. */
+  baseY: number;
+  height: number;
+}
+/** Floats in the mesh `ModelUniforms` struct. */
+
+/**
+ * Skinned crowd (vertex animation): every instance skins from a baked
+ * joint palette at its own clip, phase and speed (`bakeCrowdPalette`).
+ */
+interface MeshCrowd {
+  /** `palette` uploaded once: `frames × jointCount` model-space joint matrices. */
+  palette: GPUBuffer;
+  jointCount: number;
+  /** Seconds. */
+  time: number;
+}
 interface MeshUniformData extends SurfaceParams {
   modelMatrix: Float32Array | number[];
   normalMatrix?: Float32Array | number[];
@@ -3046,6 +3502,8 @@ interface MeshUniformData extends SurfaceParams {
   transparent?: boolean;
   /** Extra per-map UV vertex attributes are present. */
   hasMapUvs?: boolean;
+  /** The mesh binds a second set of four skin influences. */
+  hasSkin1?: boolean;
   isSkinned?: boolean;
   skinningMatrices?: Float32Array;
   /** Hardware-instanced draw path. */
@@ -3075,7 +3533,26 @@ interface MeshUniformData extends SurfaceParams {
   specularIntensity?: number;
   ambientIntensity?: number;
   metallic?: number;
+  /** Base-color UV window [x, y, width, height]: uv' = xy + uv · wh. */
+  uvRect?: [number, number, number, number];
+  wind?: MeshWind;
+  /** Instances carry a second record each and skin from a baked palette. */
+  crowd?: MeshCrowd;
 }
+/**
+ * A mesh's state one frame earlier, for the velocity pass; unset fields
+ * repeat this frame's (no motion from them).
+ */
+type MeshMotionPrev = Pick<MeshUniformData, "modelMatrix" | "normalMatrix" | "skinningMatrices" | "instanceBuffer" | "wind" | "crowd"> & {
+  /**
+   * The mesh's vertices as the GPU deformed them a frame earlier (morph
+   * targets, audio deformation), in the vertex buffer's layout. Absent:
+   * the vertices did not change shape, so this frame's buffer stands in.
+   */
+  vertexBuffer?: GPUBuffer;
+};
+/** Format of the velocity target: motion px (rg), linear depth (b), coverage (a). */
+
 interface GPUMeshBuffers {
   vertexBuffer: GPUBuffer;
   indexBuffer: GPUBuffer;
@@ -3085,6 +3562,8 @@ interface GPUMeshBuffers {
   /** Per-vertex RGBA (display / sRGB), 4 floats each; absent = white. */
   colorBuffer?: GPUBuffer;
   mapUvBuffer?: GPUBuffer;
+  /** Second skin influence set: 4 joints then 4 weights per vertex. */
+  skin1Buffer?: GPUBuffer;
   wireIndexBuffer?: GPUBuffer;
   wireIndexCount?: number;
 }
@@ -3121,11 +3600,27 @@ declare class Mesh3DPipeline {
   /** Outgrown white buffers: earlier draws this frame may still read them. */
   private retiredColorBuffers;
   private modelData;
+  private readonly vertexBuffers;
+  /** Velocity-pass camera: this and the previous view-projection. */
+  readonly velocityCameraLayout: GPUBindGroupLayout;
+  private velocityModule?;
+  private readonly velocityPipelines;
   constructor(device: GPUDevice, format: GPUTextureFormat, depthFormat?: GPUTextureFormat, cameraLayout?: GPUBindGroupLayout, lightsLayout?: GPUBindGroupLayout, /** Samples per pixel of the pass this draws into (MSAA). */
   sampleCount?: number);
   resetPools(): void;
   private packModel;
   draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, meshBuffers: GPUMeshBuffers, texture: GPUTexture | undefined, sampler: GPUSampler, data: MeshUniformData, useMrt?: boolean, useBloom?: boolean, instanceCount?: number, firstInstance?: number): void;
+  /**
+   * Draws the mesh's screen motion since `prev` into a velocity pass
+   * (`VELOCITY_FORMAT`): the vertex runs this frame's and the previous
+   * frame's deformation, so skinning, instances, wind and crowds move it
+   * too.
+   */
+  drawVelocity(pass: GPURenderPassEncoder, velocityCameraBindGroup: GPUBindGroup, meshBuffers: GPUMeshBuffers, texture: GPUTexture | undefined, sampler: GPUSampler, data: MeshUniformData, prev: MeshMotionPrev | undefined, instanceCount?: number, firstInstance?: number): void;
+  private velocityPipeline;
+  private textureGroup;
+  /** Binds the vertex and index buffers and draws (instanced when asked). */
+  private issue;
   /** Draws the mesh into a shadow map (`lightCameraBindGroup` holds the light's view-projection). */
   drawShadow(pass: GPURenderPassEncoder, lightCameraBindGroup: GPUBindGroup, meshBuffers: GPUMeshBuffers, data: MeshUniformData, instanceCount?: number, firstInstance?: number): void;
   private colorsFor;
@@ -3133,30 +3628,157 @@ declare class Mesh3DPipeline {
 }
 //#endregion
 //#region src/renderer3d/motion-blur-pipeline.d.ts
-/**
- * @file packages/webgpu-renderers/src/renderer3d/motion-blur-pipeline.ts
- * WebGPU render pipeline for camera shutter motion blur using screen-space velocity buffers.
- */
 interface MotionBlurPassOptions {
+  /** Shutter angle, degrees. Default 180. */
   shutterAngle?: number;
+  /** Taps along each pixel's motion. Default 20. */
   sampleCount?: number;
-  maxVelocity?: number;
-  depthThreshold?: number;
-  curveType?: "box" | "gaussian" | "triangle";
-  width: number;
-  height: number;
+  /** Longest blur from a pixel (and the tile size), px. Default 48. */
+  maxBlur?: number;
+  /** Depth softness between in front and behind, scene px. Default 20. */
+  softDepth?: number;
 }
+/** Format of the tile textures `render` takes. */
+
 declare class MotionBlurPipeline {
-  private device;
-  private pipeline;
-  private bindGroupLayout;
-  private uniformBuffer;
-  private sampler;
+  private readonly device;
+  private readonly module;
+  private readonly tileMax;
+  private readonly neighborMax;
+  private readonly reconstruct;
+  /** One uniform block per blur this frame: an encoder may blur several scenes. */
+  private readonly params;
   constructor(device: GPUDevice);
-  render(commandEncoder: GPUCommandEncoder, colorView: GPUTextureView, velocityView: GPUTextureView, depthView: GPUTextureView, targetView: GPUTextureView, options: MotionBlurPassOptions): void;
+  private pipeline;
+  /**
+   * Blurs `color` (premultiplied) by `velocity` (`VELOCITY_FORMAT`, same
+   * size) into `target` (a view of `targetFormat`, same size). `tiles`
+   * returns a render-attachment texture of the tile grid's size: the
+   * caller owns them, since one frame may blur scenes of several sizes.
+   */
+  render(encoder: GPUCommandEncoder, color: GPUTexture, velocity: GPUTexture, target: GPUTextureView, targetFormat: GPUTextureFormat, options: MotionBlurPassOptions, tiles: (label: string, width: number, height: number) => GPUTexture): void;
+  private pass;
+  resetPools(): void;
   destroy(): void;
 }
 //#endregion
+//#region src/renderer3d/geometry-arrays.d.ts
+/**
+ * Flat vertex arrays procedural meshes are assembled in before they become a
+ * Mesh3DData. Winding follows the primitives': for a triangle (a, b, c),
+ * cross(b - a, c - a) points out of the surface.
+ */
+
+//#endregion
+//#region src/renderer3d/sdf-geometry.d.ts
+type SdfOp = "union" | "subtract" | "intersect";
+interface SdfPrimitiveBase {
+  /** How this shape combines with everything before it. Default "union". */
+  op?: SdfOp;
+  /** Blend radius of the join, px (0 = a hard edge). Default 0. */
+  smoothness?: number;
+  /** Center, px, in the sculpture's local space. Default [0, 0, 0]. */
+  center?: [number, number, number];
+  /** Euler degrees [x, y, z]. */
+  rotation?: [number, number, number];
+  /** Surface color where this shape forms the surface (cuts too). */
+  color?: string;
+}
+type SdfPrimitive = SdfPrimitiveBase & ({
+  shape: "sphere";
+  radius: number;
+} | {
+  shape: "box";
+  size: [number, number, number];
+  /** Corner rounding, px. */
+  radius?: number;
+} | {
+  shape: "cylinder" | "capsule";
+  radius: number;
+  height: number;
+} | {
+  shape: "torus";
+  radius: number;
+  tube: number;
+} | {
+  shape: "gyroid";
+  /** Period of the lattice, px. */
+  scale: number;
+  /** Wall thickness, px. */
+  thickness: number;
+});
+interface SdfGeometryOptions {
+  type: "sdf";
+  primitives: SdfPrimitive[];
+  /** The sculpture is clipped to this box [width, height, depth], px. */
+  bounds: [number, number, number];
+  /** Cells along the longest side of `bounds`, 16..160. Default 64. */
+  resolution?: number;
+  /** Faceted shading. */
+  flatShaded?: boolean;
+  color?: string;
+  material?: "lit" | "unlit" | "toon";
+  shininess?: number;
+  roughness?: number;
+  metallic?: number;
+}
+//#endregion
+//#region src/renderer3d/terrain-geometry.d.ts
+interface TerrainNoiseOptions {
+  seed?: number;
+  /** Size of the largest landforms, px. Default: a third of the longer side. */
+  scale?: number;
+  /** Noise layers summed, 1..10. Default 6. */
+  octaves?: number;
+  /** Amplitude kept per octave, 0..1. Default 0.5. */
+  persistence?: number;
+  /** Frequency gained per octave, 1..4. Default 2. */
+  lacunarity?: number;
+  /** "fbm" rolling hills, "ridged" sharp crests, "terrace" stepped plateaus. Default "fbm". */
+  ridgeMode?: FractalMode;
+  /** Plateaus for "terrace", 2..32. Default 6. */
+  terraceSteps?: number;
+}
+interface TerrainColorByElevation {
+  lowColor: string;
+  midColor?: string;
+  highColor: string;
+  /** Steep faces (slope cosine below `cliffThreshold`) blend to this. */
+  cliffColor?: string;
+  /** Slope cosine (1 = flat) below which cliffs show. Default 0.65. */
+  cliffThreshold?: number;
+  /** Normalized altitudes where low turns mid and mid turns high. Default [0.35, 0.7]. */
+  bands?: [number, number];
+}
+interface TerrainGeometryOptions {
+  type: "terrain";
+  width: number;
+  depth: number;
+  /** Peak-to-valley relief, px. Default 300. */
+  height?: number;
+  /** Grid cells along x and z (or both), 1..512. Default 128. */
+  segments?: number | [number, number];
+  noise?: TerrainNoiseOptions;
+  /**
+   * Heights 0..1 on the (segments + 1)² grid, row by row from the near
+   * edge (-z) and left to right: a DEM, or a sampled height function.
+   * Replaces the noise.
+   */
+  heights?: number[];
+  /** Sideways warp of steep faces into overhangs, px. Default 0. */
+  overhangWarp?: number;
+  colorByElevation?: TerrainColorByElevation;
+  /** Faceted, low-poly shading. */
+  flatShaded?: boolean;
+  /** Thickness of the solid under the valley floor, px. Default 10% of `height`. */
+  base?: number;
+  color?: string;
+  material?: "lit" | "unlit" | "toon";
+  shininess?: number;
+  roughness?: number;
+  metallic?: number;
+}
+//#endregion
 //#region src/renderer3d/text-extruder.d.ts
 interface Point2D {
   x: number;
@@ -3184,6 +3806,10 @@ interface RoundedBoxGeometryOptions extends PrimitiveSurface {
   depth: number;
   /** Corner and edge radius, clamped to half the smallest side. Default 0 (a sharp box). */
   radius?: number;
+  /** Alias for `radius`. */
+  cornerRadius?: number;
+  /** Alias for `radius`. */
+  borderRadius?: number;
   /** Segments per rounded quarter (default 4). */
   segments?: number;
   /**
@@ -3202,8 +3828,12 @@ interface CylinderGeometryOptions extends PrimitiveSurface {
   type: "cylinder";
   /** Radius of the top (-y) cap; defaults to `radius`. */
   radiusTop?: number;
+  /** Alias for `radiusTop`. */
+  topRadius?: number;
   /** Radius of the bottom (+y) cap; defaults to `radius`. */
   radiusBottom?: number;
+  /** Alias for `radiusBottom`. */
+  bottomRadius?: number;
   radius?: number;
   height: number;
   /** Segments around (default 32). */
@@ -3217,8 +3847,14 @@ interface TorusGeometryOptions extends PrimitiveSurface {
   type: "torus";
   /** Major radius from the torus center to the center of the tube (default 60). */
   radius?: number;
+  /** Alias for `radius`. */
+  majorRadius?: number;
   /** Minor radius of the circular tube cross-section (default 20). */
   tube?: number;
+  /** Alias for `tube`. */
+  minorRadius?: number;
+  /** Alias for `tube`. */
+  tubeRadius?: number;
   /** Segments around the tube cross-section (default 24). */
   radialSegments?: number;
   /** Segments around the main ring (default 48). */
@@ -3431,7 +4067,7 @@ interface ModelUniformData extends SurfaceParams {
   height?: number;
   /** Fraction of the texture the layer covers, [u, v] (default the whole texture) */
   textureExtent?: [number, number];
-  material?: "lit" | "unlit";
+  material?: "lit" | "unlit" | "toon";
   /** Screen-space track matte: the layer shows where this texture's alpha does. */
   matte?: GPUTexture;
   /** Turns the flat quad into a surface lifted by another picture's brightness. */
@@ -3442,7 +4078,7 @@ interface ModelUniformData extends SurfaceParams {
   ambientIntensity?: number;
   metallic?: number;
 }
-type MaterialUniformData = Pick<ModelUniformData, "material" | "shininess" | "roughness" | "specularIntensity" | "ambientIntensity" | "metallic" | "emissive" | "emissiveIntensity">;
+type MaterialUniformData = SurfaceParams & Pick<ModelUniformData, "material" | "shininess" | "specularIntensity" | "ambientIntensity">;
 /** [shininess, specularIntensity, ambientIntensity, materialMode] as the 3D shaders' lighting reads them. */
 
 declare class Quad3DPipeline {
@@ -3497,6 +4133,16 @@ interface Slug3DUniformData extends MaterialUniformData {
   /** Screen-space track matte: the text shows where this texture's alpha does. */
   matte?: GPUTexture;
 }
+/** A text batch's motion for the velocity pass: this and the previous frame. */
+interface SlugMotionData {
+  modelMatrix: Mat4;
+  prevModelMatrix: Mat4;
+  /** The previous frame's glyph records (same glyphs, same order); absent = unchanged. */
+  prevInstances?: Float32Array;
+  opacity: number;
+  slant: number;
+  depthPull: number;
+}
 /** Slug glyphs in the 3D pass: depth-tested, lit and resolution independent. */
 declare class Slug3DPipeline {
   private device;
@@ -3508,10 +4154,19 @@ declare class Slug3DPipeline {
   private modelPool;
   private instancePool;
   private fontBindGroups;
+  private motionPool;
+  private velocity?;
   private modelData;
   constructor(device: GPUDevice, format: GPUTextureFormat, depthFormat: GPUTextureFormat, cameraLayout: GPUBindGroupLayout, lightsLayout: GPUBindGroupLayout, /** Samples per pixel of the pass this draws into (MSAA). */
   sampleCount?: number);
   resetPools(): void;
+  /**
+   * Draws a text batch's screen motion into a velocity pass: its glyphs
+   * placed with this and the previous frame's plane and glyph animation,
+   * written where the outline covers the pixel.
+   */
+  drawVelocity(pass: GPURenderPassEncoder, velocityCameraBindGroup: GPUBindGroup, velocityCameraLayout: GPUBindGroupLayout, font: SlugFont, instances: Float32Array, instanceCount: number, data: SlugMotionData): void;
+  private velocityPipeline;
   draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, font: SlugFont, instances: Float32Array, instanceCount: number, data: Slug3DUniformData, useMrt?: boolean, useBloom?: boolean): void;
   /** A font's textures live as long as the font: bind them once, not per draw. */
   private fontBindGroup;
@@ -3682,7 +4337,7 @@ interface DrawQuad3DOpts extends SurfaceParams {
   /** Pre-computed normal matrix */
   normalMatrix?: Mat4;
   /** Material shading mode ("lit" vs "unlit") */
-  material?: "lit" | "unlit";
+  material?: "lit" | "unlit" | "toon";
   /** Blinn-Phong specular shininess exponent */
   shininess?: number;
   /** Roughness factor [0, 1] */
@@ -3708,6 +4363,12 @@ interface DrawMesh3DOpts extends SurfaceParams {
   dispersion?: number;
   /** Edge bend for glass materials, px (default 80). */
   thickness?: number;
+  /**
+   * Glass thickness in world units (model files: KHR_materials_volume):
+   * the refracted ray's exit point is projected, so the bend follows the
+   * object's size on screen. Used when `thickness` (px) is unset.
+   */
+  worldThickness?: number;
   /** Screen-sized picture behind this 3D batch; glass materials refract it. */
   backdrop?: GPUTexture;
   /**
@@ -3780,6 +4441,12 @@ interface DrawMesh3DOpts extends SurfaceParams {
   matrixInstances?: boolean;
   /** Optional overall bounding box (e.g. for instanced clusters or swarms) for shadow frustum fitting. */
   bounds?: Aabb;
+  /** Base-color UV window [x, y, width, height] (a layer texture's place in its pass). */
+  uvRect?: [number, number, number, number];
+  /** Procedural wind sway (`MeshWind`). */
+  wind?: MeshWind;
+  /** Skinned crowd: instances skin from a baked palette (`MeshCrowd`). */
+  crowd?: MeshCrowd;
 }
 /** Scene-wide world settings for a 3D pass. */
 interface Scene3DWorld {
@@ -3787,6 +4454,11 @@ interface Scene3DWorld {
   environment?: Environment3DOptions | null;
   /** From `renderShadowMap`, when a light casts shadows. */
   shadow?: ShadowUniformInfo | ShadowUniformInfo[] | null;
+  /**
+   * Screen-space reflections / GI (`environment.ssr`, `environment.gi`) take
+   * two passes: `radiance`, then `traceScreenIndirect`, then `apply`.
+   */
+  screenIndirect?: ScreenIndirectPass;
 }
 /** Something that can fall into a shadow map. */
 type ShadowCaster3D = {
@@ -3842,19 +4514,42 @@ declare class Renderer3D {
   /** Whether the current pass also writes HDR radiance (bloom). */
   private passWritesHdr;
   private cameraUniformData;
+  private velocityCameraPool;
+  private quadMotionPool;
+  private motionBlurPipeline?;
+  private quadVelocity?;
+  private floorVelocity?;
+  /**
+   * Environments looked up this frame: a pass asks several times, and a
+   * file path is checked on disk (stat) once per frame, not per lookup.
+   */
+  private hdrEnvironments;
+  /** The HDR target blurred by `applyMotionBlur`: what bloom reads after it. */
+  private hdrBlurred;
   private meshBuffersCache;
   private materialTextures;
   private materialMapCache;
   /** Parsed models by source and load options: a model file is read once, not every frame. */
   private modelCache;
-  private lastCameraPose;
+  /** What the cached camera buffer was packed from (pose, lens, surface). */
+  private lastCameraKey;
   private shadowTexture;
   private shadowTextures;
   private placeholderShadowTexture;
   private shadowSampler;
+  private placeholderEnvTexture;
+  private envSampler;
   private meshBounds;
   private bloomPipeline;
+  private outlinePipeline;
+  private geometryResolvePipeline;
+  private volumetricFogPipeline;
+  private ssrGiPipeline;
+  private screenIndirect;
+  private placeholderScreenIndirect;
+  private screenSampler;
   private lastCameraBuffer;
+  private lensPipeline;
   /**
    * Samples per pixel in the 3D pass. Mesh silhouettes (extruded text,
    * models) are rasterized triangles: without MSAA every edge is a hard
@@ -3862,11 +4557,35 @@ declare class Renderer3D {
    */
   readonly sampleCount: number;
   constructor(device: GPUDevice, format: GPUTextureFormat, sampleCount?: number);
+  /**
+   * Size-dependent render targets, by label, size, samples and usage. One
+   * frame (one command buffer) can render 3D scenes of different sizes, so
+   * a target is never destroyed while the frame may use it: targets the last
+   * frame did not use are destroyed at the next `resetPools`.
+   */
+  private attachments;
+  private attachmentsUsed;
+  private attachment;
+  private hdrEnvironment;
   resetPools(): void;
   getOrCreateDepthTexture(width: number, height: number): GPUTexture;
   private getOrCreateMsaaTexture;
   /** The HDR radiance target the last `beginPass(…, writeHdr)` drew into. */
   hdrSource(): GPUTexture | null;
+  /**
+   * A cube camera's target: six `size`² faces with a full mip chain, drawn
+   * into face by face and sampled by `remapLens`. `hdr` holds the scene
+   * radiance (the bloom source) instead of display colour.
+   */
+  getOrCreateCubeTexture(size: number, hdr: boolean): GPUTexture;
+  /** Face `face` (WebGPU layer order) of a cube target, as a render attachment. */
+  cubeFaceView(cube: GPUTexture, face: number): GPUTextureView;
+  /**
+   * Draws a cube camera's picture into `dest` (`width` × `height`) through
+   * its lens. With an `hdr` cube the radiance is remapped too and becomes
+   * `hdrSource()`, so bloom glows where the lens put the light.
+   */
+  remapLens(encoder: GPUCommandEncoder, color: GPUTexture, hdr: GPUTexture | null, dest: GPUTextureView, width: number, height: number, options: LensRemapOptions): void;
   private getOrCreateHdrTexture;
   getOrCreateLinearDepthTexture(width: number, height: number): GPUTexture;
   getOrCreateReflectionTexture(width: number, height: number): GPUTexture;
@@ -3875,22 +4594,35 @@ declare class Renderer3D {
   getOrCreateReflectionTempTexture(width: number, height: number): GPUTexture;
   getOrCreateReflectionBlurredTexture(width: number, height: number): GPUTexture;
   packCameraUniforms(camera: Camera3DPose, surfaceWidth: number, surfaceHeight: number, time?: number): GPUBuffer;
+  /** The environment's prefiltered HDRI, as the lights uniform describes it. */
+  private hdriUniforms;
   createCameraBindGroup(cameraBuffer: GPUBuffer): GPUBindGroup;
   getOrCreateLightsBuffer(lights?: Light3DOptions[], world?: Scene3DWorld): GPUBuffer;
-  /** Lights uniform + shadow map + comparison sampler (group 3 of every lit shader). */
+  /** Lights uniform + shadow map + comparison sampler + environment map (group 3 of every lit shader). */
   private createLightsBindGroup;
+  /** Group 3 bindings 6..9: the traced screen indirect light, or 1×1 stand-ins. */
+  private screenIndirectEntries;
+  /**
+   * Traces screen-space reflections and diffuse GI from the radiance pass
+   * just ended (`beginPass` with `screenIndirect: "radiance"`, a geometry
+   * target and `writeHdr`), for the `apply` pass that follows.
+   */
+  traceScreenIndirect(encoder: GPUCommandEncoder, cameraBuffer: GPUBuffer, environment: Environment3DOptions): void;
   /** Local bounds of a mesh, computed once. */
   private meshAabb;
   /** World bounds of a mesh or quad draw, for fitting shadow frusta. */
   worldBounds(item: ShadowCaster3D): Aabb;
+  private getOrCreateShadowTexture;
+  private renderShadowLayerPass;
   /**
-   * Renders the shadow map for `light` (a directional or spot light with
+   * Renders the shadow map for `light` (a directional, spot, rect, or point light with
    * `castShadow`) from `casters`, fitting its frustum around them and deep
    * enough for `receivers`. Pass the result to `beginPass` as `world.shadow`.
    */
   renderShadowMap(encoder: GPUCommandEncoder, light: Light3DOptions, lightIndex: number, casters: ShadowCaster3D[], receivers: Aabb[], options?: ShadowMapOptions3D): ShadowUniformInfo | null;
   beginPass(encoder: GPUCommandEncoder, colorTargetView: GPUTextureView, surfaceWidth: number, surfaceHeight: number, camera: Camera3DPose, loadOp?: GPULoadOp, clearColor?: GPUColor, linearDepthTargetView?: GPUTextureView, lights?: Light3DOptions[], world?: Scene3DWorld, /** Also write unclamped scene radiance (`hdrTexture()`), the bloom source. */
-  writeHdr?: boolean): {
+  writeHdr?: boolean, /** Where the radiance resolves instead of `hdrSource()` (a cube face). */
+  hdrTargetView?: GPUTextureView): {
     pass: GPURenderPassEncoder;
     cameraBindGroup: GPUBindGroup;
     cameraBuffer: GPUBuffer;
@@ -3905,10 +4637,11 @@ declare class Renderer3D {
   blurReflection(encoder: GPUCommandEncoder, reflectionTexture: GPUTexture, roughness: number): GPUTexture;
   drawFloor(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, reflectionTexture: GPUTexture, floor: Environment3DFloor, useMrt?: boolean, useBloom?: boolean): void;
   /**
-   * A layer's unit quad ([-0.5, 0.5] square) in world space:
-   * T(pos) * Rz * Ry * Rx * S(w * sx, h * sy, sz) * T(0.5 - ax, 0.5 - ay, 0).
+   * A centered unit quad in world space. Translate to the authored pivot,
+   * rotate and scale, then offset the unit quad back from that pivot.
+   * Shared with children in preserve-3d containers.
    */
-  private quadModelMatrix;
+  quadModelMatrix(opts: DrawQuad3DOpts): Mat4;
   /**
    * Draw a text layer's captured Slug glyphs on the plane its texture quad
    * would cover. Glyph coverage is solved per screen pixel, so the text is
@@ -3930,6 +4663,38 @@ declare class Renderer3D {
     sampleRate?: number;
   }, wireframe?: boolean, input?: GPUMeshBuffers): GPUMeshBuffers;
   drawMesh3D(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, meshOrBuffers: Mesh3DData | GPUMeshBuffers, texture: GPUTexture | undefined, opts?: DrawMesh3DOpts, useMrt?: boolean): void;
+  /**
+   * Begins the velocity pass for shutter motion blur: draw the scene's
+   * meshes and planes with `drawMeshVelocity` / `drawQuadVelocity`, end
+   * the pass, then `applyMotionBlur` with the returned texture.
+   */
+  beginVelocityPass(encoder: GPUCommandEncoder, width: number, height: number, camera: Camera3DPose, prevCamera: Camera3DPose): {
+    pass: GPURenderPassEncoder;
+    cameraBindGroup: GPUBindGroup;
+    velocity: GPUTexture;
+  };
+  /** Draws a mesh's motion since `prev` (its state a frame earlier) into the velocity pass. */
+  drawMeshVelocity(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, meshOrBuffers: Mesh3DData | GPUMeshBuffers, texture: GPUTexture | undefined, opts: DrawMesh3DOpts, prev: MeshMotionPrev | undefined): void;
+  /** Draws a 3D layer plane's motion since `prevModelMatrix` into the velocity pass. */
+  drawQuadVelocity(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, texture: GPUTexture, opts: DrawQuad3DOpts, prevModelMatrix: Mat4 | undefined): void;
+  /**
+   * Draws a text layer's glyphs' motion since `prev` (its plane matrix and
+   * glyph batches a frame earlier) into the velocity pass. A batch whose
+   * glyphs changed (another font or count) moves with its plane alone.
+   */
+  drawSlugVelocity(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, batches: SlugGlyphBatch[], opts: DrawQuad3DOpts, stackBase: number, prev: {
+    modelMatrix: Mat4;
+    batches: SlugGlyphBatch[];
+  } | undefined): void;
+  /** Draws the environment floor's motion (camera motion only) into the velocity pass. */
+  drawFloorVelocity(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, floor: Environment3DFloor): void;
+  private fullscreenVelocityPipeline;
+  private quadVelocityPipeline;
+  /**
+   * Shutter motion blur: blurs `color` by the velocity pass's `velocity`
+   * into `target` (a view of a texture in this renderer's format, same size).
+   */
+  applyMotionBlur(encoder: GPUCommandEncoder, color: GPUTexture, velocity: GPUTexture, target: GPUTextureView, options?: MotionBlurPassOptions): void;
   loadModel(srcOrData: string | ArrayBuffer | Uint8Array, format?: "obj" | "fbx" | "gltf" | "glb" | "stl" | "ply" | "vox" | "3ds" | "off" | "auto", options?: LoadModelOptions): Model3DData;
   /** Loads glTF asynchronously so its compressed buffer decoders can initialize. */
   loadModelAsync(srcOrData: string | ArrayBuffer | Uint8Array, format?: Parameters<Renderer3D["loadModel"]>[1], options?: LoadModelOptions): Promise<Model3DData>;
@@ -3943,13 +4708,24 @@ declare class Renderer3D {
    * on the GPU (each decoded once); absent maps are left out.
    */
   materialMaps(material: Material3D): Promise<MeshMaterialMaps>;
+  /** A sampler for each map that says how it is sampled. */
+  private mapSamplers;
   private uploadMaterialTexture;
   /** Decodes an encoded image into a texture with a full mip chain. */
   private uploadImage;
   /** Writes `source` with bloom into `dest` (see `BloomOptions`). */
   applyBloom(encoder: GPUCommandEncoder, source: GPUTexture, dest: GPUTexture, options?: BloomOptions, /** Scene radiance to threshold (from a `writeHdr` pass); default `source`. */
   hdrSource?: GPUTexture | null): void;
+  /** Geometry ink is applied before lens blur, independently of material shading. */
+  resolveGeometry(encoder: GPUCommandEncoder, geometry: GPUTexture): void;
+  applyOutlines(encoder: GPUCommandEncoder, source: GPUTexture, geometry: GPUTexture, dest: GPUTextureView, camera: Camera3DPose, options: GeometryOutlineOptions, fog?: Environment3DFog): void;
   applyDepthOfField(encoder: GPUCommandEncoder, sourceColorTex: GPUTexture, depthTex: GPUTexture, destView: GPUTextureView, cameraBuffer: GPUBuffer): void;
+  /**
+   * Raymarches volumetric fog and shadowed light shafts at half-resolution,
+   * then composites over `sourceColorTex` into `destView` using depth-aware
+   * bilateral upsampling.
+   */
+  applyVolumetricFog(encoder: GPUCommandEncoder, sourceColorTex: GPUTexture, linearDepthTex: GPUTexture, destView: GPUTextureView, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, environment: Environment3DOptions, timeSeconds?: number, frameIndex?: number): void;
   /** Uploads raw `InstanceData` float buffer to a GPU storage buffer from the instance pool. */
   uploadInstanceData(data: Float32Array): GPUBuffer;
   /** Draws instanced 3D meshes in a single hardware-instanced draw call. */
@@ -3958,9 +4734,45 @@ declare class Renderer3D {
 }
 declare function loadModel3D(srcOrData: string | ArrayBuffer | Uint8Array, format?: "obj" | "fbx" | "gltf" | "glb" | "stl" | "ply" | "vox" | "3ds" | "off" | "auto", options?: LoadModelOptions): Model3DData;
 //#endregion
-//#region src/renderer3d/shadow-depth.d.ts
-/** Shadow maps: a depth32float target rendered from a light's point of view. */
-
+//#region src/renderer3d/scatter.d.ts
+type V3 = [number, number, number];
+interface ScatterExclusion {
+  /** Center in the surface's parent space, px. */
+  x: number;
+  z: number;
+  /** Nothing grows inside this radius, px. */
+  radius: number;
+  /** Density ramps back to full over this many px past `radius`. Default 0. */
+  falloff?: number;
+}
+interface ScatterOptions {
+  /** Points to place (fewer when spacing or filters leave no room). */
+  count: number;
+  /** Poisson-disk spacing: no two points closer than this, px. */
+  minDistance?: number;
+  seed?: number;
+  /** Allowed slope in degrees from level ground. Default [0, 89]. */
+  slopeRange?: [number, number];
+  /** Allowed altitude 0..1 across the surface's vertical extent (0 = lowest). Default [0, 1]. */
+  elevationRange?: [number, number];
+  /** 0 keeps instances upright, 1 stands them on the surface normal. Default 0.3. */
+  alignToNormal?: number;
+  /** Uniform scale drawn per point. Default [1, 1]. */
+  scaleRange?: [number, number];
+  /** Random turn around the instance's up axis. Default true. */
+  randomYaw?: boolean;
+  exclude?: ScatterExclusion[];
+}
+interface ScatterPoint {
+  /** On the surface, in its parent space. */
+  position: V3;
+  /** Unit face normal there. */
+  normal: V3;
+  rotation: Quat;
+  scale: number;
+  /** Normalized altitude 0..1. */
+  elevation: number;
+}
 /**
  * @deprecated A texture holder only; nothing renders into it. Shadows are
  * drawn by `Renderer3D.renderShadowMap` (a `castShadow` directional or spot
@@ -4006,6 +4818,43 @@ declare class SSAOPipeline {
   destroy(): void;
 }
 //#endregion
+//#region src/renderer3d/ssr-gi-pipeline.d.ts
+/** Reflection hits: pixel positions need full float precision at 4K. */
+
+//#endregion
+//#region src/renderer3d/volumetric-fog-pipeline.d.ts
+interface VolumetricFogRenderParams {
+  encoder: GPUCommandEncoder;
+  sourceColorTex: GPUTexture;
+  linearDepthTex: GPUTexture;
+  halfFogTex: GPUTexture;
+  destView: GPUTextureView;
+  cameraBindGroup: GPUBindGroup;
+  lightsBindGroup: GPUBindGroup;
+  fog: ResolvedVolumetricFog;
+  fullWidth: number;
+  fullHeight: number;
+  halfWidth: number;
+  halfHeight: number;
+  timeSeconds: number;
+  frameIndex: number;
+}
+declare class VolumetricFogPipeline {
+  private device;
+  private raymarchPipeline;
+  private upsamplePipeline;
+  private fogBindGroupLayout;
+  private emptyGroup2Layout;
+  private emptyGroup2BindGroup;
+  private linearSampler;
+  private bufferPool;
+  private uniformScratch;
+  constructor(device: GPUDevice, format?: GPUTextureFormat);
+  resetPools(): void;
+  destroy(): void;
+  render(params: VolumetricFogRenderParams): void;
+}
+//#endregion
 //#region src/shader-store.d.ts
 interface RegisteredShader {
   wgsl: string;
@@ -4436,7 +5285,7 @@ declare global {
   var __GATEWAI_DELAYS__: Set<number>;
 }
 //#endregion
-//#region ../node-sdk/dist/index-DCPaiCIF.d.mts
+//#region ../node-sdk/dist/index-CudN5Wne.d.mts
 //#endregion
 //#region renderer/index.d.ts
 type GPUCommandEncoder$1 = globalThis.GPUCommandEncoder;
@@ -4475,6 +5324,11 @@ interface NodeRenderProps<TOperation extends MediaOperation = MediaOperation> {
   isVideoMode?: boolean;
   isPlaying?: boolean;
   excludeTextures?: GPUTexture$1[];
+  /**
+   * Render only to record the 3D scene's motion (shutter motion blur reads
+   * every draw one frame earlier); nothing drawn is shown.
+   */
+  motionHistoryOnly?: boolean;
   /** Signal values that override the node's own (text animators read them). */
   signals?: Record<string, unknown>;
   renderChild?: (child: VirtualMediaData, overrides?: Partial<NodeRenderProps>) => unknown;
@@ -4545,5 +5399,5 @@ declare const SignalResultSchema: z.ZodObject<{
   }, z.core.$strip>], null>;
 }, z.core.$strip>;
 //#endregion
-export { inputStore as $, evaluateCubicBezierDerivative as $n, SelectorMode as $t, PolyhedronGeometryOptions as A, TextSignalSelectorSchema as An, LIGHT_UNIFORM_SIZE_BYTES as Ar, EnhancedTextNode as At, SignalRegistryResource as B, Vec2Schema as Bn, Path3DSample as Br, GlyphAnchorPointSchema as Bt, MasterAudioEntry as C, TextRangeSelector as Cn, Environment3DFloor as Cr, AudioSpectrumTypographySchema as Ct, MotionBlurPipeline as D, TextSelector as Dn, FrustumPlanes as Dr, CubicBezierSegmentSchema as Dt, Model3DData as E, TextScrambleConfigSchema as En, FrustumPlane as Er, CubicBezierSegment as Et, RoundedBoxGeometryOptions as F, TypingCadence as Fn, MAX_LIGHTS as Fr, ExtendedGlyphProperties as Ft, TorusGeometryOptions as G, buildPathLUT as Gn, linearRgb as Gr, LongShadowConfig as Gt, SlugFontCache as H, VolumetricFormationConfigSchema as Hn, ShadowUniformInfo as Hr, KineticMarqueeConfigSchema as Ht, SSAOPipeline as I, TypingCadenceSchema as In, Mat4 as Ir, ExtendedGlyphPropertiesSchema as It, WebGPUAudioProcessor as J, computeRangeSelectorWeight as Jn, ParticleDissolveConfigSchema as Jt, TubeGeometryOptions as K, computeAnchorPivotOffset as Kn, parseColorToRgb as Kr, LongShadowConfigSchema as Kt, ShadowPipeline as L, VariableFontAxes as Ln, Matrix4Math as Lr, GlyphAnchorGrouping as Lt, Renderer2D as M, TextWigglySelectorSchema as Mn, Light3DOptions as Mr, ExpressionEvaluationContext as Mt, Renderer3D as N, TypewriterAnimator as Nn, LightKind as Nr, ExpressionSelector as Nt, NodeAnimationTrack3D as O, TextSelectorSchema as On, GPULightData as Or, DynamicStrokeProperties as Ot, RingGeometryOptions as P, TypewriterAnimatorSchema as Pn, LightsUniformData as Pr, ExpressionSelectorSchema as Pt, initHeadlessWebGPU as Q, evaluateCubicBezier as Qn, SelectorBasedOnSchema as Qt, ShardGeometryOptions as R, VariableFontAxesSchema as Rn, Path3D as Rr, GlyphAnchorGroupingSchema as Rt, LoadModelOptions as S, TextPathSourceSchema as Sn, ENVIRONMENT_PRESETS as Sr, AudioSpectrumTypography as St, Mesh3DData as T, TextScrambleConfig as Tn, Environment3DOptions as Tr, ChromaticGlitchConfigSchema as Tt, SlugPipeline as U, VolumetricFormationMode as Un, Vec3 as Ur, LineSpacingDynamics as Ut, Skeleton3D as V, VolumetricFormationConfig as Vn, ResolvedEnvironment as Vr, KineticMarqueeConfig as Vt, SphereGeometryOptions as W, VolumetricFormationModeSchema as Wn, Vector3Math as Wr, LineSpacingDynamicsSchema as Wt, describeGpu as X, distanceToCurveParameter as Xn, PathChainLUTEntry as Xt, buildWGSLSignalFn as Y, deterministicWigglyNoise as Yn, PathChainLUT as Yt, ensureDevice as Z, ellipseToCubicBeziers as Zn, SelectorBasedOn as Zt, ExtrudeShapeGeometryOptions as _, TextCursorStyleSchema as _n, Camera3D as _r, AnchorPreset as _t, AudioLatentData as a, SkewProperties as an, evaluateTypewriterState as ar, parseMTL as at, LatheGeometryOptions as b, TextPathOptionsSchema as bn, CatmullRomOptions as br, AnimatableGlyphPropsSchema as bt, AudioMeshDeformPipeline as c, Spatial3DPropertiesSchema as cn, generatePathSegments as cr, signalRegistry as ct, AudioSignalComputePipeline as d, TextAnchorConfig as dn, parseSvgPathToCubicBeziers as dr, AETextAnimatorSchema as dt, SelectorModeSchema as en, evaluateExpressionSelector as er, loadFBX as et, BlendMode as f, TextAnchorConfigSchema as fn, sampleAudioSpectrumScale as fr, AdvancedTextAnimator as ft, EffectPipeline as g, TextCursorStyle as gn, BezierSegment3D as gr, AnchorGroupingSchema as gt, CylinderGeometryOptions as h, TextCursorConfigSchema as hn, waveToCubicBeziers as hr, AnchorGrouping as ht, AnimationClip3D as i, SelectorUnitsSchema as in, evaluateSpringProgress as ir, parseFBX as it, RenderContextValue as j, TextWigglySelector as jn, Light3D as jr, EnhancedTextNodeSchema as jt, Points3DGeometryOptions as k, TextSignalSelector as kn, HelixOptions as kr, DynamicStrokePropertiesSchema as kt, AudioPitchTrackConfig as l, SpringPhysics as ln, getScramblePool as lr, textureCache as lt, CapsuleGeometryOptions as m, TextCursorConfig as mn, samplePathChainGeometry as mr, AdvancedTextAnimatorSchema as mt, NodeRendererPlugin as n, SelectorShapeSchema as nn, evaluateSelectorCombination as nr, loadOBJ as nt, AudioLatentEngine as o, SkewPropertiesSchema as on, evaluateVolumetricFormation as or, parseOBJ as ot, Bone3D as p, TextAnimatorBuilder as pn, sampleCurveGeometry as pr, AdvancedTextAnimatorBuilder as pt, TubePathSpec as q, computeLineLeadingDisplacement as qn, resolveEnvironment as qr, ParticleDissolveConfig as qt, WebGPUNodeRenderer as r, SelectorUnits as rn, evaluateSkewMatrix as rr, lutStore as rt, AudioLatentTrackCache as s, Spatial3DProperties as sn, generateArcLengthLUT as sr, shaderStore as st, SignalResultSchema as t, SelectorShape as tn, evaluateMarqueeOffset as tr, loadModel3D as tt, AudioSignalComputeConfig as u, SpringPhysicsSchema as un, getShuffledOrder as ur, AETextAnimator as ut, GlassPipeline as v, TextPathBuilder as vn, Camera3DPose as vr, AnchorPresetSchema as vt, Material3D as w, TextRangeSelectorSchema as wn, Environment3DFog as wr, ChromaticGlitchConfig as wt, Line3DGeometryOptions as x, TextPathSource as xn, CirclePathOptions as xr, ArcLengthLUTEntry as xt, GpuAdapterDescription as y, TextPathOptions as yn, CameraShakeOptions as yr, AnimatableGlyphProps as yt, SignalRegistry as z, Vec2 as zn, Path3DPoint as zr, GlyphAnchorPoint as zt };
-//# sourceMappingURL=index-C2yaponf.d.mts.map
+export { TubeGeometryOptions as $, buildPathLUT as $n, Light3DOptions as $r, LongShadowConfig as $t, PolyhedronGeometryOptions as A, lorentzFactor as Ai, TextPathSourceSchema as An, CirclePathOptions as Ar, AudioSpectrumTypography as At, SdfPrimitive as B, TextWigglySelectorSchema as Bn, Environment3DSsrOptions as Br, ExpressionEvaluationContext as Bt, MasterAudioEntry as C, defaultCubeFaceSize as Ci, TextCursorConfigSchema as Cn, waveToCubicBeziers as Cr, AnchorGrouping as Ct, MotionBlurPipeline as D, fractal2 as Di, TextPathOptions as Dn, Camera3DPose as Dr, AnimatableGlyphProps as Dt, Model3DData as E, dopplerLut as Ei, TextPathBuilder as En, Camera3D as Er, AnchorPresetSchema as Et, RoundedBoxGeometryOptions as F, resolveVolumetricFog as Fi, TextSelector as Fn, ENVIRONMENT_PRESETS as Fr, CubicBezierSegmentSchema as Ft, Skeleton3D as G, VariableFontAxes as Gn, FrustumPlane as Gr, GlyphAnchorGrouping as Gt, ShardGeometryOptions as H, TypewriterAnimatorSchema as Hn, Environment3DVolumetricFogNoise as Hr, ExpressionSelectorSchema as Ht, SSAOPipeline as I, terrace as Ii, TextSelectorSchema as In, Environment3DFloor as Ir, DynamicStrokeProperties as It, SphereGeometryOptions as J, Vec2Schema as Jn, HdriUniforms as Jr, GlyphAnchorPointSchema as Jt, SlugFontCache as K, VariableFontAxesSchema as Kn, FrustumPlanes as Kr, GlyphAnchorGroupingSchema as Kt, ScatterOptions as L, TextSignalSelector as Ln, Environment3DFog as Lr, DynamicStrokePropertiesSchema as Lt, Renderer2D as M, resolveEnvironment as Mi, TextRangeSelectorSchema as Mn, DIRECT_LIGHT_FLOATS as Mr, ChromaticGlitchConfig as Mt, Renderer3D as N, resolveGi as Ni, TextScrambleConfig as Nn, DOPPLER_LUT_MAX as Nr, ChromaticGlitchConfigSchema as Nt, NodeAnimationTrack3D as O, lensCenterDensity as Oi, TextPathOptionsSchema as On, CameraShakeOptions as Or, AnimatableGlyphPropsSchema as Ot, RingGeometryOptions as P, resolveSsr as Pi, TextScrambleConfigSchema as Pn, DOPPLER_LUT_SIZE as Pr, CubicBezierSegment as Pt, TorusGeometryOptions as Q, VolumetricFormationModeSchema as Qn, Light3D as Qr, LineSpacingDynamicsSchema as Qt, ScatterPoint as R, TextSignalSelectorSchema as Rn, Environment3DGiOptions as Rr, EnhancedTextNode as Rt, LoadModelOptions as S, cubeTexel as Si, TextCursorConfig as Sn, samplePathChainGeometry as Sr, AdvancedTextAnimatorSchema as St, Mesh3DData as T, dopplerLuminanceGain as Ti, TextCursorStyleSchema as Tn, CUBE_FLIP as Tr, AnchorPreset as Tt, SignalRegistry as U, TypingCadence as Un, FractalMode as Ur, ExtendedGlyphProperties as Ut, ShadowPipeline as V, TypewriterAnimator as Vn, Environment3DVolumetricFog as Vr, ExpressionSelector as Vt, SignalRegistryResource as W, TypingCadenceSchema as Wn, FractalOptions as Wr, ExtendedGlyphPropertiesSchema as Wt, TerrainGeometryOptions as X, VolumetricFormationConfigSchema as Xn, LIGHT_UNIFORM_SIZE_BYTES as Xr, KineticMarqueeConfigSchema as Xt, TerrainColorByElevation as Y, VolumetricFormationConfig as Yn, HelixOptions as Yr, KineticMarqueeConfig as Yt, TerrainNoiseOptions as Z, VolumetricFormationMode as Zn, LensProjection as Zr, LineSpacingDynamics as Zt, ExtrudeShapeGeometryOptions as _, aberrate as _i, SpringPhysics as _n, getScramblePool as _r, textureCache as _t, AudioLatentData as a, Noise as ai, SelectorBasedOn as an, ellipseToCubicBeziers as ar, ensureDevice as at, LatheGeometryOptions as b, createRandom as bi, TextAnchorConfigSchema as bn, sampleAudioSpectrumScale as br, AdvancedTextAnimator as bt, AudioMeshDeformPipeline as c, Path3DSample as ci, SelectorModeSchema as cn, evaluateExpressionSelector as cr, loadFBX as ct, AudioSignalComputePipeline as d, ResolvedSsr as di, SelectorUnits as dn, evaluateSkewMatrix as dr, lutStore as dt, LightKind as ei, LongShadowConfigSchema as en, computeAnchorPivotOffset as er, TubePathSpec as et, BlendMode as f, ResolvedVolumetricFog as fi, SelectorUnitsSchema as fn, evaluateSpringProgress as fr, parseFBX as ft, EffectPipeline as g, Vector3Math as gi, Spatial3DPropertiesSchema as gn, generatePathSegments as gr, signalRegistry as gt, CylinderGeometryOptions as h, Vec3 as hi, Spatial3DProperties as hn, generateArcLengthLUT as hr, shaderStore as ht, AnimationClip3D as i, Matrix4Math as ii, PathChainLUTEntry as in, distanceToCurveParameter as ir, describeGpu as it, RenderContextValue as j, parseColorToRgb as ji, TextRangeSelector as jn, CubeLensOptions as jr, AudioSpectrumTypographySchema as jt, Points3DGeometryOptions as k, linearRgb as ki, TextPathSource as kn, CatmullRomOptions as kr, ArcLengthLUTEntry as kt, AudioPitchTrackConfig as l, ResolvedEnvironment as li, SelectorShape as ln, evaluateMarqueeOffset as lr, loadModel3D as lt, CapsuleGeometryOptions as m, ShadowUniformInfo as mi, SkewPropertiesSchema as mn, evaluateVolumetricFormation as mr, parseOBJ as mt, NodeRendererPlugin as n, MAX_LIGHTS as ni, ParticleDissolveConfigSchema as nn, computeRangeSelectorWeight as nr, WebGPUAudioProcessor as nt, AudioLatentEngine as o, Path3D as oi, SelectorBasedOnSchema as on, evaluateCubicBezier as or, initHeadlessWebGPU as ot, Bone3D as p, ScreenIndirectPass as pi, SkewProperties as pn, evaluateTypewriterState as pr, parseMTL as pt, SlugPipeline as q, Vec2 as qn, GPULightData as qr, GlyphAnchorPoint as qt, WebGPUNodeRenderer as r, Mat4 as ri, PathChainLUT as rn, deterministicWigglyNoise as rr, buildWGSLSignalFn as rt, AudioLatentTrackCache as s, Path3DPoint as si, SelectorMode as sn, evaluateCubicBezierDerivative as sr, inputStore as st, SignalResultSchema as t, LightsUniformData as ti, ParticleDissolveConfig as tn, computeLineLeadingDisplacement as tr, VolumetricFogPipeline as tt, AudioSignalComputeConfig as u, ResolvedGi as ui, SelectorShapeSchema as un, evaluateSelectorCombination as ur, loadOBJ as ut, GlassPipeline as v, cameraBasis as vi, SpringPhysicsSchema as vn, getShuffledOrder as vr, AETextAnimator as vt, Material3D as w, dopplerColorMatrix as wi, TextCursorStyle as wn, BezierSegment3D as wr, AnchorGroupingSchema as wt, Line3DGeometryOptions as x, cubeFaceCameras as xi, TextAnimatorBuilder as xn, sampleCurveGeometry as xr, AdvancedTextAnimatorBuilder as xt, GpuAdapterDescription as y, createNoise as yi, TextAnchorConfig as yn, parseSvgPathToCubicBeziers as yr, AETextAnimatorSchema as yt, SdfGeometryOptions as z, TextWigglySelector as zn, Environment3DOptions as zr, EnhancedTextNodeSchema as zt };
+//# sourceMappingURL=index-s2qQ8ifZ.d.mts.map