framefields 2.0.9 → 2.0.11

package/dist/{index-D1zaOwEU.d.mts → index-DDEPvMww.d.mts}

@@ -1848,7 +1848,157 @@ declare const TransitionSchema: z.ZodObject<{
   durationFrames: z.ZodNumber;
 }, z.core.$strip>;
 type TransitionType = z.infer<typeof TransitionTypeSchema>;
-type Transition = z.infer<typeof TransitionSchema>;
+//#endregion
+//#region src/utils/color.d.ts
+/**
+ * CSS color parsing, perceptual mixing and authoring helpers, shared by the
+ * schema evaluator (color tracks), the GPU renderers (fills) and the public
+ * `Color` helper. Pure and dependency-free.
+ *
+ * Every helper returns a CSS string any color prop accepts: `#rrggbb`, or
+ * `#rrggbbaa` when not fully opaque.
+ */
+/** Straight (non-premultiplied) sRGB, each channel 0..1. */
+type Rgba = [r: number, g: number, b: number, a: number];
+/** sRGB (0..1) → OKLab [L, a, b]. */
+declare function rgbToOklab(r: number, g: number, b: number): [number, number, number];
+/** OKLab → sRGB (0..1, clamped to gamut). */
+declare function oklabToRgb(L: number, a: number, b: number): [number, number, number];
+/**
+ * Parses any CSS color this engine accepts: hex (3/4/6/8), `rgb()`/`rgba()`,
+ * `hsl()`/`hsla()`, `oklch()`, `oklab()` (comma or space syntax, `/ alpha`)
+ * and common named colors. Returns `null` when the string is not a color.
+ */
+declare function parseCssColor(input: string): Rgba | null;
+/** Formats straight sRGB as `#rrggbb` (or `#rrggbbaa` when translucent). */
+declare function formatHex([r, g, b, a]: Rgba): string;
+/**
+ * Mixes two colors perceptually (in OKLab), `t` = 0 → `a`, 1 → `b`.
+ * Midpoints keep their lightness and saturation instead of going muddy
+ * the way a plain sRGB lerp does.
+ */
+declare function mixColors(a: string, b: string, t: number): string;
+interface ColorStopLike {
+  offset: number;
+  color: string;
+}
+/** Samples a multi-stop gradient (stops in any order) at `t` ∈ [0, 1]. */
+declare function sampleColorStops(stops: readonly (string | ColorStopLike)[], t: number): string;
+/** Bare color strings become evenly spaced stops; result is sorted by offset. */
+declare function normalizeColorStops(stops: readonly (string | ColorStopLike)[]): ColorStopLike[];
+/**
+ * Authoring helpers for colors. Every function returns a hex string, so the
+ * result drops straight into any color prop or keyframe.
+ *
+ * ```ts
+ * Color.oklch(0.7, 0.15, 250)          // perceptual: equal L reads equally bright
+ * Color.hsl(212, 0.95, 0.74)
+ * Color.mix("#ff5a1f", "#1f6bff", 0.5) // OKLab, no muddy midpoint
+ * const wave = Color.ramp(["#3b82f6", "#8b5cf6", "#ec4899"]);
+ * wave(0.5)                            // sample a gradient
+ * Color.lighten("#ff5a1f", 0.1), Color.alpha("#000", 0.4)
+ * ```
+ */
+declare const Color$1: {
+  /** Parses any supported CSS color to straight sRGB 0..1, or null. */
+  readonly parse: typeof parseCssColor;
+  /** Normalizes any supported CSS color to hex. */
+  readonly hex: (c: string) => string;
+  /** `r, g, b` in 0..255, `a` in 0..1. */
+  readonly rgb: (r: number, g: number, b: number, a?: number) => string;
+  /** Hue in degrees; saturation and lightness in 0..1. */
+  readonly hsl: (h: number, s: number, l: number, a?: number) => string;
+  /**
+   * Perceptual lightness 0..1, chroma ~0..0.37, hue in degrees. Colors with
+   * the same `l` look equally bright, which makes balanced palettes easy.
+   */
+  readonly oklch: (l: number, c: number, h: number, a?: number) => string;
+  /** Perceptual (OKLab) mix; `t` = 0 → `a`, 1 → `b`. */
+  readonly mix: typeof mixColors;
+  /** A gradient sampler: `Color.ramp(["#f00", "#00f"])(0.25)`. */
+  readonly ramp: (stops: readonly (string | ColorStopLike)[]) => (t: number) => string;
+  /** `n` evenly spaced swatches along a gradient. */
+  readonly steps: (stops: readonly (string | ColorStopLike)[], n: number) => string[];
+  /** Raises perceptual lightness by `amount` (0..1). */
+  readonly lighten: (c: string, amount: number) => string;
+  readonly darken: (c: string, amount: number) => string;
+  /** Scales chroma: 0 = grey, 1 = unchanged, >1 = more vivid. */
+  readonly saturate: (c: string, factor: number) => string;
+  /** Rotates hue by `degrees`, keeping perceptual lightness. */
+  readonly rotate: (c: string, degrees: number) => string;
+  /** Replaces alpha. */
+  readonly alpha: (c: string, a: number) => string;
+  /** WCAG relative-luminance contrast ratio (1..21). ≥ 4.5 for body text. */
+  readonly contrast: (a: string, b: string) => number;
+  /** Black or white, whichever reads better on `background`. */
+  readonly readableOn: (background: string) => string;
+};
+//#endregion
+//#region src/utils/gradient.d.ts
+type GradientType = "linear" | "radial" | "conic";
+interface ParsedGradientStop {
+  /** 0..1 along the gradient line / radius / turn. */
+  offset: number;
+  /** Straight sRGB 0..1. */
+  color: Rgba;
+}
+interface ParsedGradient {
+  type: GradientType;
+  /** Linear: CSS angle in degrees (0 = to top, 90 = to right, 180 = to bottom). */
+  angle: number;
+  /** Radial / conic center as a fraction of the box (0.5, 0.5 = middle). */
+  center: [number, number];
+  /** Radial: circle or ellipse sized to the farthest corner, or explicit px radii. */
+  shape: "circle" | "ellipse";
+  radius?: [number, number];
+  /** Conic: start angle in degrees (0 = top, clockwise). */
+  from: number;
+  stops: ParsedGradientStop[];
+}
+/** Gradients this renderer draws at most this many stops (extra ones are resampled). */
+declare const MAX_GRADIENT_STOPS = 8;
+declare function isCssGradient(value: unknown): value is string;
+/** Parses a CSS gradient string; `null` when it is not one this engine draws. */
+declare function parseCssGradient(input: string): ParsedGradient | null;
+/** Up to MAX_GRADIENT_STOPS stops: longer lists are resampled evenly. */
+declare function limitGradientStops(stops: ParsedGradientStop[]): ParsedGradientStop[];
+/**
+ * Stops as OKLab + alpha for the GPU. A transparent stop borrows its
+ * neighbor's color, so fading to `transparent` keeps the hue instead of
+ * passing through grey (CSS premultiplied interpolation does the same).
+ */
+declare function gradientStopsToOklab(stops: ParsedGradientStop[]): Array<[number, number, number, number]>;
+type StopInput = string | {
+  color: string;
+  offset: number;
+};
+/**
+ * Writes CSS gradient strings for `background` / `fill`:
+ *
+ * ```ts
+ * Layer.box({ background: Gradient.linear(["#ff5a1f", "#7c3aed"], 135) })
+ * Layer.shape("circle", { fill: Gradient.radial(["#fff", "transparent"]) })
+ * Gradient.conic(["red", "yellow", "lime", "aqua", "blue", "magenta", "red"])
+ * ```
+ * Plain strings work too: `"linear-gradient(to right, #000, #fff 80%)"`.
+ */
+declare const Gradient: {
+  /** `angle` in degrees: 0 = bottom→top, 90 = left→right, 180 = top→bottom (default). */
+  readonly linear: (stops: readonly StopInput[], angle?: number) => string;
+  /** Ellipse to the farthest corner, centered unless `at` ([0..1, 0..1]) says otherwise. */
+  readonly radial: (stops: readonly StopInput[], options?: {
+    at?: [number, number];
+    circle?: boolean;
+    radius?: number;
+  }) => string;
+  /** A sweep around `at`, starting at `from` degrees (0 = top, clockwise). */
+  readonly conic: (stops: readonly StopInput[], options?: {
+    from?: number;
+    at?: [number, number];
+  }) => string;
+  readonly parse: typeof parseCssGradient;
+  readonly is: typeof isCssGradient;
+};
 //#endregion
 //#region src/utils/is-equal.d.ts
 /**
@@ -2205,6 +2355,7 @@ declare class QuadPipeline {
 type ShapeFillType = "solid" | "linear" | "radial" | "none";
 interface ShapeFillConfig {
   type?: ShapeFillType;
+  /** A color, or a CSS gradient string (linear/radial/conic, any stops) laid over the shape's bounds. */
   color?: Color | string;
   color2?: Color | string;
   startX?: number;
@@ -2225,6 +2376,8 @@ declare class ShapeFillPipeline {
   constructor(device: GPUDevice, format: GPUTextureFormat);
   resetPools(): void;
   draw(pass: GPURenderPassEncoder, transformStack: TransformStack, vertices: Float32Array, fill: ShapeFillConfig, bounds: Rect, surfaceWidth: number, surfaceHeight: number, opts?: DrawOpts): void;
+  /** The `type: "linear" | "radial"` two-color fill (color → color2). */
+  private packTwoColorGradient;
   destroy(): void;
 }
 //#endregion
@@ -2262,7 +2415,9 @@ interface Color {
   b: number;
   a: number;
 }
-type BlendMode = "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity" | "mask-in" | "mask-out" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor";
+type BlendMode = "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity" | "mask-in" | "mask-out" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor"
+/** Keeps the base where the overlay is bright (luma matte). */ | "luma-in"
+/** Keeps the base where the overlay is dark (inverted luma matte). */ | "luma-out";
 interface DrawOpts {
   opacity?: number;
   blendMode?: GPUBlendFactor | BlendMode;
@@ -2343,7 +2498,7 @@ declare class Renderer2D {
  *
  * Supports:
  * - Hex: #RGB, #RGBA, #RRGGBB, #RRGGBBAA
- * - Functional: rgb(r,g,b), rgba(r,g,b,a)
+ * - Functional: rgb()/rgba(), hsl()/hsla(), oklch(), oklab() (comma or space syntax)
  * - Named: black, white, red, green, blue, yellow, transparent, etc.
  * - Color objects pass through unchanged.
  *
@@ -2953,6 +3108,123 @@ declare const Camera3D: {
   isBoxInFrustum(min: Vec3, max: Vec3, planes: FrustumPlanes): boolean;
 };
 //#endregion
+//#region src/math3d/environment3d.d.ts
+/**
+ * "neutral" (default, Khronos PBR Neutral): colors as authored, highlights
+ * rolled off: right for products, brands and UI. "agx": filmic, desaturates
+ * hot highlights gracefully. "aces": punchy film contrast, shifts hues.
+ */
+type ToneMapping = "neutral" | "agx" | "aces" | "none";
+type EnvironmentPreset = "studio" | "soft" | "sunset" | "night" | "neutral";
+interface Environment3DFog {
+  /** Display color surfaces fade into; match the background for a seamless horizon. */
+  color: string;
+  /** Distance from the camera (px) where fog starts. */
+  start: number;
+  /** Distance where fog reaches `opacity`. */
+  end: number;
+  /** Max fog coverage 0..1. Default 1. */
+  opacity?: number;
+}
+interface Environment3DOptions {
+  preset?: EnvironmentPreset;
+  /** Overrides the preset's sky (above), horizon and ground colors. */
+  top?: string;
+  horizon?: string;
+  bottom?: string;
+  /** Scales the whole environment's light. Default 1. */
+  intensity?: number;
+  /** Strength of the studio softboxes reflected in glossy surfaces. */
+  softboxes?: number;
+  /** Turns the environment around the vertical axis, degrees. */
+  rotation?: number;
+  /** Exposure in stops: +1 doubles brightness. Default 0. */
+  exposure?: number;
+  /** Default "neutral". */
+  toneMapping?: ToneMapping;
+  fog?: Environment3DFog;
+}
+/** Where a shadow-casting light's depth map lives, for the lit shaders. */
+interface ShadowUniformInfo {
+  /** Light view-projection (world → shadow clip). */
+  matrix: ArrayLike<number>;
+  /** Index of the casting light among the packed (non-ambient) lights. */
+  lightIndex: number;
+  /** Shadow map size in texels. */
+  mapSize: number;
+  /** Blur radius in texels. */
+  softness: number;
+  /** Depth bias in NDC. */
+  bias: number;
+  /** Pushes the lookup along the normal, world px. */
+  normalOffset: number;
+  /** 0 = invisible shadows, 1 = fully dark. */
+  darkness: number;
+}
+//#endregion
+//#region src/math3d/light3d.d.ts
+type LightKind = "ambient" | "directional" | "point" | "spot";
+interface Light3DOptions {
+  id?: string;
+  lightType?: LightKind;
+  type?: LightKind;
+  color?: string | [number, number, number] | [number, number, number, number] | {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+  } | unknown;
+  intensity?: number;
+  x?: number;
+  y?: number;
+  z?: number;
+  position?: [number, number, number];
+  targetX?: number;
+  targetY?: number;
+  targetZ?: number;
+  target?: [number, number, number];
+  direction?: [number, number, number];
+  radius?: number;
+  decay?: number;
+  angle?: number;
+  penumbra?: number;
+  /** Directional or spot: render a shadow map (the first such light wins). */
+  castShadow?: boolean;
+  /** Shadow edge blur in shadow-map texels (default 2). */
+  shadowSoftness?: number;
+  /** 0..1, how dark shadows get (default 1). */
+  shadowDarkness?: number;
+}
+interface GPULightData {
+  /** xyz = position, w = type (0=ambient, 1=directional, 2=point, 3=spot) */
+  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 */
+  spotParams: [number, number, number, number];
+}
+declare const Light3D: {
+  /**
+   * Computes the 3x3 normal matrix (stored in 4x4 layout) from a 4x4 Model matrix.
+   * Evaluates N = (M^-1)^T to preserve true orthogonal surface normals under non-uniform scaling.
+   */
+  computeNormalMatrix(modelMatrix: Mat4): Mat4;
+  /**
+   * Converts high-level light options into uniform data ready for GPU packing.
+   */
+  processLight(opt: Light3DOptions): GPULightData;
+  /**
+   * Packs active scene lights into a Float32Array matching WGSL LightsUniforms layout.
+   */
+  packLightsUniforms(lights: Light3DOptions[], environment?: Environment3DOptions | null, shadow?: ShadowUniformInfo | null): 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): void;
+};
+//#endregion
 //#region src/math3d/path3d.d.ts
 interface Path3DPoint {
   /** Position in 3D world space [x, y, z] */
@@ -3046,59 +3318,6 @@ declare class Path3D {
   static circle(options: CirclePathOptions): Path3D;
 }
 //#endregion
-//#region src/math3d/light3d.d.ts
-type LightKind = "ambient" | "directional" | "point" | "spot";
-interface Light3DOptions {
-  id?: string;
-  lightType?: LightKind;
-  type?: LightKind;
-  color?: string | [number, number, number] | [number, number, number, number] | {
-    r: number;
-    g: number;
-    b: number;
-    a?: number;
-  } | unknown;
-  intensity?: number;
-  x?: number;
-  y?: number;
-  z?: number;
-  position?: [number, number, number];
-  targetX?: number;
-  targetY?: number;
-  targetZ?: number;
-  target?: [number, number, number];
-  direction?: [number, number, number];
-  radius?: number;
-  decay?: number;
-  angle?: number;
-  penumbra?: number;
-}
-interface GPULightData {
-  /** xyz = position, w = type (0=ambient, 1=directional, 2=point, 3=spot) */
-  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 */
-  spotParams: [number, number, number, number];
-}
-declare const Light3D: {
-  /**
-   * Computes the 3x3 normal matrix (stored in 4x4 layout) from a 4x4 Model matrix.
-   * Evaluates N = (M^-1)^T to preserve true orthogonal surface normals under non-uniform scaling.
-   */
-  computeNormalMatrix(modelMatrix: Mat4): Mat4;
-  /**
-   * Converts high-level light options into uniform data ready for GPU packing.
-   */
-  processLight(opt: Light3DOptions): GPULightData;
-  /**
-   * Packs active scene lights into a Float32Array matching WGSL LightsUniforms layout.
-   */
-  packLightsUniforms(lights: Light3DOptions[]): Float32Array;
-};
-//#endregion
 //#region src/loaders/types.d.ts
 interface Mesh3DData {
   id?: string;
@@ -3146,6 +3365,20 @@ interface Material3D {
   shading?: "lit" | "unlit" | "toon";
   /** Toon shading: the color multiplier of the shadowed side. */
   shadeColor?: [number, number, number];
+  /** Linear-ish emissive color 0..1 (glTF emissiveFactor). */
+  emissive?: [number, number, number];
+  /** Emissive multiplier (glTF KHR_materials_emissive_strength). */
+  emissiveStrength?: number;
+  /** Encoded tangent-space normal map (glTF convention: +Y up / OpenGL). */
+  normalTextureBuffer?: Uint8Array;
+  normalScale?: number;
+  /** Encoded map: G = roughness, B = metallic (glTF). */
+  metallicRoughnessTextureBuffer?: Uint8Array;
+  /** Encoded map: R = ambient occlusion. */
+  occlusionTextureBuffer?: Uint8Array;
+  occlusionStrength?: number;
+  /** Encoded emissive color map (multiplies `emissive`). */
+  emissiveTextureBuffer?: Uint8Array;
 }
 /** A scene-graph node: its rest transform and parent (glTF node semantics). */
 interface ModelNode3D {
@@ -3262,6 +3495,34 @@ declare class AudioMeshDeformPipeline {
   destroy(): void;
 }
 //#endregion
+//#region src/renderer3d/bloom-pipeline.d.ts
+/**
+ * Bloom: light that spills past bright pixels, the way a lens and film do.
+ *
+ * A mip chain at half, quarter, … resolution: a soft-knee threshold picks the
+ * bright parts (emissive surfaces, hot speculars), 13-tap downsamples spread
+ * them, tent-filtered upsamples add every level back up (wide and tight glow
+ * together), and the result is added over the source. Works on premultiplied
+ * color: glow over a transparent pixel raises its alpha, so a bloomed 3D
+ * layer still glows when composited over the 2D layers below.
+ */
+interface BloomOptions {
+  /** Glow strength. Default 0.2. */
+  intensity?: number;
+  /**
+   * Brightness where glow starts. With an HDR source (3D scenes) it is scene
+   * radiance, default 2.5 = only light well past white (emissive ≳ 3,
+   * hot speculars). Without one it is display brightness, default 0.85.
+   */
+  threshold?: number;
+  /** Soft transition below the threshold, 0..1. Default 0.4. */
+  knee?: number;
+  /** Glow spread: mip levels used, 1..8. Default 6. */
+  radius?: number;
+  /** Tints the glow (CSS-free rgb 0..1). Default white. */
+  tint?: [number, number, number];
+}
+//#endregion
 //#region src/renderer3d/glass-pipeline.d.ts
 /**
  * @file renderer3d/glass-pipeline.ts
@@ -3303,9 +3564,39 @@ declare class GlassPipeline {
   draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, backdropTexture: GPUTexture, sampler: GPUSampler, data: GlassUniformData): void;
   destroy(): void;
 }
+//#endregion
+//#region src/renderer3d/surface-params.d.ts
+/** Physically based surface inputs every 3D draw (quad, text, mesh) accepts. */
+interface SurfaceParams {
+  /** Microsurface roughness 0 (mirror) .. 1 (chalk). Physical scenes default to 0.5. */
+  roughness?: number;
+  /** 0 = dielectric (plastic, paint, wood), 1 = metal. */
+  metallic?: number;
+  /** Light the surface gives off (a CSS color), added on top of lighting. */
+  emissive?: string | Color | [number, number, number];
+  /** Emissive multiplier; values above 1 glow past white and feed bloom. Default 1. */
+  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. */
+
 //#endregion
 //#region src/renderer3d/mesh3d-pipeline.d.ts
-interface MeshUniformData {
+/** A mesh material's extra maps (glTF conventions); absent maps are neutral. */
+interface MeshMaterialMaps {
+  /** Tangent-space normal map (+Y up). */
+  normal?: GPUTexture;
+  normalScale?: number;
+  /** G = roughness, B = metallic; multiplies the roughness / metallic factors. */
+  metallicRoughness?: GPUTexture;
+  /** R = ambient occlusion. */
+  occlusion?: GPUTexture;
+  occlusionStrength?: number;
+  /** Multiplies the emissive color. */
+  emissive?: GPUTexture;
+}
+interface MeshUniformData extends SurfaceParams {
   modelMatrix: Float32Array | number[];
   normalMatrix?: Float32Array | number[];
   colorTint?: [number, number, number, number];
@@ -3315,8 +3606,12 @@ interface MeshUniformData {
   isSkinned?: boolean;
   skinningMatrices?: Float32Array;
   material?: "lit" | "unlit" | "toon";
+  /** Screen-space track matte: the mesh shows where this texture's alpha does. */
+  matte?: GPUTexture;
   /** Toon shading: the shadowed side's color multiplier. */
   shadeColor?: [number, number, number];
+  /** Normal / metallic-roughness / occlusion / emissive maps. */
+  maps?: MeshMaterialMaps;
   /** Texels with alpha below this are discarded (glTF MASK). */
   alphaCutoff?: number;
   shininess?: number;
@@ -3335,6 +3630,9 @@ declare class Mesh3DPipeline {
   private device;
   pipelineSingle: GPURenderPipeline;
   pipelineMrt: GPURenderPipeline;
+  private bloomVariants;
+  /** Depth only (skinning included): draws a caster into a shadow map. */
+  pipelineShadow: GPURenderPipeline;
   cameraLayout: GPUBindGroupLayout;
   modelLayout: GPUBindGroupLayout;
   textureLayout: GPUBindGroupLayout;
@@ -3342,12 +3640,17 @@ declare class Mesh3DPipeline {
   private modelPool;
   private skinningPool;
   defaultWhiteTexture: GPUTexture;
+  /** (0.5, 0.5, 1): an unperturbed tangent-space normal. */
+  private flatNormalTexture;
   private defaultSkinningBuffer;
   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;
-  draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, meshBuffers: GPUMeshBuffers, texture: GPUTexture | undefined, sampler: GPUSampler, data: MeshUniformData, useMrt?: boolean): void;
+  private packModel;
+  draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, meshBuffers: GPUMeshBuffers, texture: GPUTexture | undefined, sampler: GPUSampler, data: MeshUniformData, useMrt?: boolean, useBloom?: boolean): void;
+  /** Draws the mesh into a shadow map (`lightCameraBindGroup` holds the light's view-projection). */
+  drawShadow(pass: GPURenderPassEncoder, lightCameraBindGroup: GPUBindGroup, meshBuffers: GPUMeshBuffers, data: MeshUniformData): void;
   destroy(): void;
 }
 //#endregion
@@ -3376,8 +3679,55 @@ declare class MotionBlurPipeline {
   destroy(): void;
 }
 //#endregion
-//#region src/renderer3d/quad3d-pipeline.d.ts
-interface ModelUniformData {
+//#region src/renderer3d/primitive-geometry.d.ts
+/**
+ * Procedural solids built as real meshes (one draw call each), centered on
+ * the origin in the 3D world's convention: x right, y down, z away from a
+ * default camera. "Top" is therefore -y.
+ */
+interface PrimitiveSurface {
+  /** Diffuse color (hex or rgb()). Default white, so a node `color` tints it. */
+  color?: string;
+  material?: "lit" | "unlit" | "toon";
+  shininess?: number;
+  roughness?: number;
+  metallic?: number;
+}
+interface RoundedBoxGeometryOptions extends PrimitiveSurface {
+  type: "roundedBox";
+  width: number;
+  height: number;
+  depth: number;
+  /** Corner and edge radius, clamped to half the smallest side. Default 0 (a sharp box). */
+  radius?: number;
+  /** Segments per rounded quarter (default 4). */
+  segments?: number;
+  /**
+   * Scale of the top (-y) face against the bottom along x and z: 0.9 draws
+   * a keycap-like frustum. Default 1.
+   */
+  taper?: number;
+}
+interface SphereGeometryOptions extends PrimitiveSurface {
+  type: "sphere";
+  radius: number;
+  /** Segments around the equator (default 32); rings are half of it. */
+  segments?: number;
+}
+interface CylinderGeometryOptions extends PrimitiveSurface {
+  type: "cylinder";
+  /** Radius of the top (-y) cap; defaults to `radius`. */
+  radiusTop?: number;
+  /** Radius of the bottom (+y) cap; defaults to `radius`. */
+  radiusBottom?: number;
+  radius?: number;
+  height: number;
+  /** Segments around (default 32). */
+  segments?: number;
+  /** Leave the caps off (a tube). */
+  openEnded?: boolean;
+}
+interface ModelUniformData extends SurfaceParams {
   modelMatrix: Float32Array | number[];
   normalMatrix?: Float32Array | number[];
   colorTint?: [number, number, number, number];
@@ -3391,19 +3741,24 @@ interface ModelUniformData {
   /** Fraction of the texture the layer covers, [u, v] (default the whole texture) */
   textureExtent?: [number, number];
   material?: "lit" | "unlit";
+  /** Screen-space track matte: the layer shows where this texture's alpha does. */
+  matte?: GPUTexture;
   shininess?: number;
   roughness?: number;
   specularIntensity?: number;
   ambientIntensity?: number;
   metallic?: number;
 }
-type MaterialUniformData = Pick<ModelUniformData, "material" | "shininess" | "roughness" | "specularIntensity" | "ambientIntensity" | "metallic">;
+type MaterialUniformData = Pick<ModelUniformData, "material" | "shininess" | "roughness" | "specularIntensity" | "ambientIntensity" | "metallic" | "emissive" | "emissiveIntensity">;
 /** [shininess, specularIntensity, ambientIntensity, materialMode] as the 3D shaders' lighting reads them. */
 
 declare class Quad3DPipeline {
   private device;
   pipelineSingle: GPURenderPipeline;
   pipelineMrt: GPURenderPipeline;
+  private bloomVariants;
+  /** Depth-only, alpha-tested: draws a caster into a shadow map. */
+  pipelineShadow: GPURenderPipeline;
   cameraLayout: GPUBindGroupLayout;
   modelLayout: GPUBindGroupLayout;
   textureLayout: GPUBindGroupLayout;
@@ -3415,10 +3770,20 @@ declare class Quad3DPipeline {
   constructor(device: GPUDevice, format: GPUTextureFormat, depthFormat?: GPUTextureFormat, /** Samples per pixel of the pass this draws into (MSAA). */
   sampleCount?: number);
   resetPools(): void;
-  draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, texture: GPUTexture, sampler: GPUSampler, data: ModelUniformData, useMrt?: boolean): void;
+  private packModel;
+  private textureBindGroup;
+  draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, texture: GPUTexture, sampler: GPUSampler, data: ModelUniformData, useMrt?: boolean, useBloom?: boolean): void;
+  /** Draws the quad into a shadow map (`lightCameraBindGroup` holds the light's view-projection). */
+  drawShadow(pass: GPURenderPassEncoder, lightCameraBindGroup: GPUBindGroup, texture: GPUTexture, sampler: GPUSampler, data: ModelUniformData): void;
   destroy(): void;
 }
 //#endregion
+//#region src/renderer3d/shadow-frustum.d.ts
+interface Aabb {
+  min: Vec3;
+  max: Vec3;
+}
+//#endregion
 //#region src/renderer3d/slug3d-pipeline.d.ts
 interface Slug3DUniformData extends MaterialUniformData {
   /** Paragraph px to world */
@@ -3430,12 +3795,15 @@ interface Slug3DUniformData extends MaterialUniformData {
   twoSided: boolean;
   /** Fraction of the distance to the eye the glyphs slide toward it, to stack on their plane */
   depthPull: number;
+  /** Screen-space track matte: the text shows where this texture's alpha does. */
+  matte?: GPUTexture;
 }
 /** Slug glyphs in the 3D pass: depth-tested, lit and resolution independent. */
 declare class Slug3DPipeline {
   private device;
   private pipelineSingle;
   private pipelineMrt;
+  private bloomVariants;
   private modelLayout;
   private fontLayout;
   private modelPool;
@@ -3445,14 +3813,14 @@ declare class Slug3DPipeline {
   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;
-  draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, font: SlugFont, instances: Float32Array, instanceCount: number, data: Slug3DUniformData, useMrt?: boolean): void;
+  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;
   destroy(): void;
 }
 //#endregion
 //#region src/renderer3d/renderer3d.d.ts
-interface DrawQuad3DOpts {
+interface DrawQuad3DOpts extends SurfaceParams {
   /** 3D world position [x, y, z] */
   position: [number, number, number];
   /** Layer surface width */
@@ -3495,8 +3863,18 @@ interface DrawQuad3DOpts {
   ambientIntensity?: number;
   /** Metallic factor [0, 1] */
   metallic?: number;
+  /**
+   * Screen-space track matte, the size of the pass: the layer shows where
+   * this texture's alpha does and keeps its place in the depth buffer.
+   */
+  matte?: GPUTexture;
 }
-interface DrawMesh3DOpts {
+interface DrawMesh3DOpts extends SurfaceParams {
+  /**
+   * Screen-space track matte, the size of the pass: the layer shows where
+   * this texture's alpha does and keeps its place in the depth buffer.
+   */
+  matte?: GPUTexture;
   /** 3D world position [x, y, z] */
   position?: Vec3;
   /** Euler rotations in degrees [rx, ry, rz] */
@@ -3523,6 +3901,8 @@ interface DrawMesh3DOpts {
   material?: "lit" | "unlit" | "toon";
   /** Toon shading: the shadowed side's color multiplier */
   shadeColor?: [number, number, number];
+  /** Normal / metallic-roughness / occlusion / emissive maps (see `materialMaps`). */
+  maps?: MeshMaterialMaps;
   /** Discard texels whose alpha is below this (glTF MASK) */
   alphaCutoff?: number;
   /** Texture addressing outside [0, 1] */
@@ -3545,6 +3925,32 @@ interface DrawMesh3DOpts {
     sampleRate?: number;
   };
 }
+/** Scene-wide world settings for a 3D pass. */
+interface Scene3DWorld {
+  /** Present = physically based shading (see `Environment3DOptions`). */
+  environment?: Environment3DOptions | null;
+  /** From `renderShadowMap`, when a light casts shadows. */
+  shadow?: ShadowUniformInfo | null;
+}
+/** Something that can fall into a shadow map. */
+type ShadowCaster3D = {
+  kind: "mesh";
+  mesh: Mesh3DData;
+  buffers?: GPUMeshBuffers;
+  opts: DrawMesh3DOpts;
+} | {
+  kind: "quad";
+  texture: GPUTexture;
+  opts: DrawQuad3DOpts;
+};
+interface ShadowMapOptions3D {
+  /** Texels per side. Default 2048. */
+  mapSize?: number;
+  /** Edge blur in texels. Default 2.5. */
+  softness?: number;
+  /** 0..1. Default 1. */
+  darkness?: number;
+}
 declare class Renderer3D {
   private device;
   format: GPUTextureFormat;
@@ -3557,18 +3963,27 @@ declare class Renderer3D {
   private cameraPool;
   private lightsPool;
   private cameraUniformBindGroupCache;
-  private lightsUniformBindGroupCache;
   private samplerCache;
   private depthTexture;
   private linearDepthTexture;
   private msaaColorTexture;
   private msaaLinearDepthTexture;
+  private msaaHdrTexture;
+  private hdrTexture;
+  /** Whether the current pass also writes HDR radiance (bloom). */
+  private passWritesHdr;
   private cameraUniformData;
   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;
+  private shadowTexture;
+  private placeholderShadowTexture;
+  private shadowSampler;
+  private meshBounds;
+  private bloomPipeline;
   private lastCameraBuffer;
   /**
    * Samples per pixel in the 3D pass. Mesh silhouettes (extruded text,
@@ -3580,11 +3995,27 @@ declare class Renderer3D {
   resetPools(): void;
   getOrCreateDepthTexture(width: number, height: number): GPUTexture;
   private getOrCreateMsaaTexture;
+  /** The HDR radiance target the last `beginPass(…, writeHdr)` drew into. */
+  hdrSource(): GPUTexture | null;
+  private getOrCreateHdrTexture;
   getOrCreateLinearDepthTexture(width: number, height: number): GPUTexture;
   packCameraUniforms(camera: Camera3DPose, surfaceWidth: number, surfaceHeight: number, time?: number): GPUBuffer;
   createCameraBindGroup(cameraBuffer: GPUBuffer): GPUBindGroup;
-  getOrCreateLightsBuffer(lights?: Light3DOptions[]): GPUBuffer;
-  beginPass(encoder: GPUCommandEncoder, colorTargetView: GPUTextureView, surfaceWidth: number, surfaceHeight: number, camera: Camera3DPose, loadOp?: GPULoadOp, clearColor?: GPUColor, linearDepthTargetView?: GPUTextureView, lights?: Light3DOptions[]): {
+  getOrCreateLightsBuffer(lights?: Light3DOptions[], world?: Scene3DWorld): GPUBuffer;
+  /** Lights uniform + shadow map + comparison sampler (group 3 of every lit shader). */
+  private createLightsBindGroup;
+  /** 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;
+  /**
+   * Renders the shadow map for `light` (a directional or spot 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): {
     pass: GPURenderPassEncoder;
     cameraBindGroup: GPUBindGroup;
     cameraBuffer: GPUBuffer;
@@ -3604,6 +4035,8 @@ declare class Renderer3D {
    */
   drawSlugText(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, batches: SlugGlyphBatch[], opts: DrawQuad3DOpts, stackBase?: number, useMrt?: boolean): void;
   drawTextureQuad(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, texture: GPUTexture, opts: DrawQuad3DOpts, useMrt?: boolean): void;
+  /** T(pos) * Rz * Ry * Rx * S, or the draw's precomputed model matrix. */
+  private meshModelMatrix;
   getOrCreateMeshBuffers(mesh: Mesh3DData): GPUMeshBuffers;
   deformMesh(encoder: GPUCommandEncoder, mesh: Mesh3DData, audioDeform: {
     config: MeshAudioDeformConfig;
@@ -3618,14 +4051,30 @@ declare class Renderer3D {
    * chain (a character's 2K maps are drawn a few hundred pixels tall).
    */
   materialTexture(material: Material3D): Promise<GPUTexture | undefined>;
+  /**
+   * The material's normal, metallic-roughness, occlusion and emissive maps
+   * on the GPU (each decoded once); absent maps are left out.
+   */
+  materialMaps(material: Material3D): Promise<MeshMaterialMaps>;
   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;
   applyDepthOfField(encoder: GPUCommandEncoder, sourceColorTex: GPUTexture, depthTex: GPUTexture, destView: GPUTextureView, cameraBuffer: GPUBuffer): void;
   destroy(): void;
 }
 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-pipeline.d.ts
+//#region src/renderer3d/shadow-depth.d.ts
+/** Shadow maps: a depth32float target rendered from a light's point of view. */
 
+/**
+ * @deprecated A texture holder only; nothing renders into it. Shadows are
+ * drawn by `Renderer3D.renderShadowMap` (a `castShadow` directional or spot
+ * light in the scene).
+ */
 declare class ShadowPipeline {
   shadowDepthTexture: GPUTexture;
   shadowDepthView: GPUTextureView;
@@ -3668,5 +4117,5 @@ declare class SSAOPipeline {
 //#endregion
 //#region src/renderer3d/text-extruder.d.ts
 //#endregion
-export { AudioExtractorSignalData as $, TEXT_LAYER_DEFAULTS as $n, isEqual as $r, MediaMetadata as $t, SignalRegistryResource as A, ProgrammaticSignal as An, WritableSignal as Ar, ExportResultSchema as At, loadModel3D as B, SignalDataSchema as Bn, deserializeSignalData as Br, GPUTextureBinding as Bt, Path3D as C, NormalizedLandmarkList as Cn, VideoTimingPropsSchema as Cr, DeflickerOptions as Ct, SSAOPipeline as D, OutputItem as Dn, VisionNodeSpec as Dr, EffectConfig as Dt, Renderer3D as E, Output$1 as En, VisionConfig as Er, Effect as Et, buildWGSLSignalFn as F, SignalBuilderConfig as Fn, computed as Fr, FileAssetSchema as Ft, parseOBJ as G, SignalStats as Gn, generateId as Gr, HandleType as Gt, lutStore as H, SignalGateDataSchema as Hn, findSourceAsset as Hr, GeneratorSignalData as Ht, ensureDevice as I, SignalChannelMeta as In, cosineSignal as Ir, FileData as It, textureCache as J, SineSignalOptions as Jn, getFingerprint as Jr, JsonObject as Jt, shaderStore as K, SignalStatsSchema as Kn, getActiveMediaMetadata as Kr, HandleTypeVal as Kt, initHeadlessWebGPU as L, SignalChannelMetaSchema as Ln, createOutputItemSchema as Lr, FileDataSchema as Lt, SlugFontCache as M, RenderDiagnostic as Mn, appendOperation as Mr, ExtendedLayerSchema as Mt, SlugPipeline as N, SegmentationOptions as Nn, checkNodeResultCache as Nr, FaceLandmarksOptions as Nt, ShadowPipeline as O, OutputItemSchema as On, VisionTask as Or, EffectConfigValue as Ot, WebGPUAudioProcessor as P, Signal as Pn, computeVideoCropRenderProps as Pr, FileAsset as Pt, AnyOutputUnionSchema as Q, StorageService as Qn, hasOnlySingleSource as Qr, MIME_TYPES as Qt, inputStore as R, SignalContext as Rn, createVirtualMedia as Rr, FrameContext as Rt, NodeAnimationTrack3D as S, NormalRelightingOptions as Sn, VideoTextPropsSchema as Sr, DataTypes as St, Renderer2D as T, OpticalFlowOptions as Tn, VirtualMediaDataSchema as Tr, DetectedObject as Tt, parseFBX as U, SignalMathData as Un, frameArraySignal as Ur, GeneratorSignalDataSchema as Ut, loadOBJ as V, SignalGateData as Vn, extractSvgDimensions as Vr, GateSignalOptions as Vt, parseMTL as W, SignalMathDataSchema as Wn, frameSignal as Wr, GlobalCompositeOperation as Wt, AnimationTypeSchema as X, SingleOutputGenericSchema as Xn, getMediaType as Xr, JsonValueSchema as Xt, AnimationType as Y, SingleOutputGeneric as Yn, getLeafMediaType as Yr, JsonValue as Yt, AnyOutputUnion as Z, SourceOperationSchema as Zn, getRenderFingerprint as Zr, Landmark3D as Zt, MasterAudioEntry as _, timeSignal as _i, NodeResultSchema as _n, VideoAnimationSchema as _r, DEFAULT_MEDIA_DIMENSION as _t, AudioMeshDeformPipeline as a, reportRenderDiagnostic as ai, MediaSourceInput as an, TextOperationSchema as ar, CAPTION_LAYER_DEFAULTS as at, Model3DData as b, NodeVisualConfig as bn, VideoSpatialPropsSchema as br, DataTypeEnum as bt, BlendMode as c, resolveNumber as ci, ModerationError as cn, TimelineSegmentSchema as cr, CannyOptions as ct, EffectPipeline as d, serializeSignalData as di, MultiOutputGenericSchema as dn, TrackedObject as dr, ConfigSchemaRegistry as dt, isSignal as ei, MediaMetadataSchema as en, TensorData as er, AudioExtractorSignalDataSchema as et, GPULightData as f, signal as fi, NodeMetadata as fn, Transition as fr, ConnectedInput as ft, LoadModelOptions as g, takeRenderDiagnostics as gi, NodeResult as gn, VideoAnimation as gr, DEFAULT_FPS as gt, Light3DOptions as h, stampResult as hi, NodeProcessorParams as hn, TransitionTypeSchema as hr, DEFAULT_DURATION_MS as ht, AudioLatentTrackCache as i, registerSignalDependency as ii, MediaSourceDescriptor as in, TensorPipelineConfig as ir, BaseVideoLayerPropsSchema as it, Skeleton3D as j, ProgrammaticSignalOptions as jn, XYPosition as jr, ExtendedLayer as jt, SignalRegistry as k, PoseSkeletonOptions as kn, VisionVariant as kr, ExportResult as kt, Bone3D as l, resolveParam as li, ModerationUnrefundableError as ln, TimelineTransform as lr, ConfigHandle as lt, Light3D as m, sineSignal as mi, NodeProcessorContext as mn, TransitionType as mr, DATA_TYPE_EXTENSIONS as mt, AudioLatentData as n, programmaticSignal as ni, MediaOperationSchema as nn, TensorFormat as nr, BaseMediaOperationPropsSchema as nt, AudioSignalComputeConfig as o, resolveBoolean as oi, MediaSourceSchema as on, TextSpan as or, COMPOSITE_OPERATIONS as ot, GlassPipeline as p, signalBuilder as pi, NodeMetadataSchema as pn, TransitionSchema as pr, ControlNetConditioningOutputs as pt, signalRegistry as q, SignalValue as qn, getFileDataMetadata as qr, JsonArray as qt, AudioLatentEngine as r, progressSignal as ri, MediaService as rn, TensorNode as rr, BaseVideoLayerProps as rt, AudioSignalComputePipeline as s, resolveMediaMimeType as si, MeshAudioDeformConfig as sn, TextSpanMark as sr, COMPOSITOR_DEFAULTS as st, AnimationClip3D as t, isVirtualMediaData as ti, MediaOperation as tn, TensorDimensions as tr, BaseMediaOperationProps as tt, Camera3D as u, resolveString as ui, MultiOutputGeneric as un, TimelineTransformSchema as ur, ConfigHandleSchema as ut, Material3D as v, updateClockSignals as vi, NodeRunFunction as vn, VideoLayerType as vr, DataForType as vt, RenderContextValue as w, ObjectBoundingBox as wn, VirtualMediaData as wr, DepthNormalsOptions as wt, MotionBlurPipeline as x, NodeVisualConfigSchema as xn, VideoStylePropsSchema as xr, DataTypeVal as xt, Mesh3DData as y, NodeValidationFn as yn, VideoLayerTypeSchema as yr, DataType as yt, loadFBX as z, SignalData as zn, dataTypeColors as zr, FrameSignal as zt };
-//# sourceMappingURL=index-D1zaOwEU.d.mts.map
+export { AnimationTypeSchema as $, SignalGateDataSchema as $n, formatHex as $r, HandleTypeVal as $t, ShadowPipeline as A, rgbToOklab as Ai, NormalRelightingOptions as An, VideoSpatialPropsSchema as Ar, DetectedObject as At, initHeadlessWebGPU as B, ProgrammaticSignal as Bn, WritableSignal as Br, FileAssetSchema as Bt, NodeAnimationTrack3D as C, registerSignalDependency as Ci, NodeProcessorParams as Cn, TransitionSchema as Cr, DataForType as Ct, Renderer3D as D, resolveNumber as Di, NodeValidationFn as Dn, VideoAnimationSchema as Dr, DataTypes as Dt, Renderer2D as E, resolveMediaMimeType as Ei, NodeRunFunction as En, VideoAnimation as Er, DataTypeVal as Et, SlugPipeline as F, sineSignal as Fi, OutputItem as Fn, VirtualMediaDataSchema as Fr, ExportResultSchema as Ft, lutStore as G, Signal as Gn, computed as Gr, GPUTextureBinding as Gt, loadFBX as H, RenderDiagnostic as Hn, appendOperation as Hr, FileDataSchema as Ht, SphereGeometryOptions as I, stampResult as Ii, OutputItemSchema as In, VisionConfig as Ir, ExtendedLayer as It, parseOBJ as J, SignalChannelMetaSchema as Jn, createVirtualMedia as Jr, GeneratorSignalDataSchema as Jt, parseFBX as K, SignalBuilderConfig as Kn, cosineSignal as Kr, GateSignalOptions as Kt, WebGPUAudioProcessor as L, takeRenderDiagnostics as Li, ParsedGradient as Ln, VisionNodeSpec as Lr, ExtendedLayerSchema as Lt, SignalRegistryResource as M, serializeSignalData as Mi, ObjectBoundingBox as Mn, VideoTextPropsSchema as Mr, EffectConfig as Mt, Skeleton3D as N, signal as Ni, OpticalFlowOptions as Nn, VideoTimingPropsSchema as Nr, EffectConfigValue as Nt, RoundedBoxGeometryOptions as O, resolveParam as Oi, NodeVisualConfig as On, VideoLayerType as Or, DeflickerOptions as Ot, SlugFontCache as P, signalBuilder as Pi, Output$1 as Pn, VirtualMediaData as Pr, ExportResult as Pt, AnimationType as Q, SignalGateData as Qn, findSourceAsset as Qr, HandleType as Qt, buildWGSLSignalFn as R, timeSignal as Ri, ParsedGradientStop as Rn, VisionTask as Rr, FaceLandmarksOptions as Rt, MotionBlurPipeline as S, progressSignal as Si, NodeProcessorContext as Sn, TrackedObject as Sr, DEFAULT_MEDIA_DIMENSION as St, RenderContextValue as T, resolveBoolean as Ti, NodeResultSchema as Tn, TransitionTypeSchema as Tr, DataTypeEnum as Tt, loadModel3D as U, Rgba as Un, checkNodeResultCache as Ur, FrameContext as Ut, inputStore as V, ProgrammaticSignalOptions as Vn, XYPosition as Vr, FileData as Vt, loadOBJ as W, SegmentationOptions as Wn, computeVideoCropRenderProps as Wr, FrameSignal as Wt, signalRegistry as X, SignalData as Xn, deserializeSignalData as Xr, Gradient as Xt, shaderStore as Y, SignalContext as Yn, dataTypeColors as Yr, GlobalCompositeOperation as Yt, textureCache as Z, SignalDataSchema as Zn, extractSvgDimensions as Zr, GradientType as Zt, LoadModelOptions as _, normalizeColorStops as _i, ModerationUnrefundableError as _n, TextSpan as _r, ConnectedInput as _t, AudioMeshDeformPipeline as a, getFingerprint as ai, MAX_GRADIENT_STOPS as an, SineSignalOptions as ar, BaseMediaOperationPropsSchema as at, Mesh3DData as b, parseCssGradient as bi, NodeMetadata as bn, TimelineTransform as br, DEFAULT_DURATION_MS as bt, BlendMode as c, getRenderFingerprint as ci, MediaMetadataSchema as cn, SourceOperationSchema as cr, CAPTION_LAYER_DEFAULTS as ct, CylinderGeometryOptions as d, isCssGradient as di, MediaService as dn, TensorData as dr, CannyOptions as dt, frameArraySignal as ei, JsonArray as en, SignalMathData as er, AnyOutputUnion as et, EffectPipeline as f, isEqual as fi, MediaSourceDescriptor as fn, TensorDimensions as fr, Color$1 as ft, Light3DOptions as g, mixColors as gi, ModerationError as gn, TextOperationSchema as gr, ConfigSchemaRegistry as gt, Light3D as h, limitGradientStops as hi, MeshAudioDeformConfig as hn, TensorPipelineConfig as hr, ConfigHandleSchema as ht, AudioLatentTrackCache as i, getFileDataMetadata as ii, Landmark3D as in, SignalValue as ir, BaseMediaOperationProps as it, SignalRegistry as j, sampleColorStops as ji, NormalizedLandmarkList as jn, VideoStylePropsSchema as jr, Effect as jt, SSAOPipeline as k, resolveString as ki, NodeVisualConfigSchema as kn, VideoLayerTypeSchema as kr, DepthNormalsOptions as kt, Bone3D as l, gradientStopsToOklab as li, MediaOperation as ln, StorageService as lr, COMPOSITE_OPERATIONS as lt, GlassPipeline as m, isVirtualMediaData as mi, MediaSourceSchema as mn, TensorNode as mr, ConfigHandle as mt, AudioLatentData as n, generateId as ni, JsonValue as nn, SignalStats as nr, AudioExtractorSignalData as nt, AudioSignalComputeConfig as o, getLeafMediaType as oi, MIME_TYPES as on, SingleOutputGeneric as or, BaseVideoLayerProps as ot, GPULightData as p, isSignal as pi, MediaSourceInput as pn, TensorFormat as pr, ColorStopLike as pt, parseMTL as q, SignalChannelMeta as qn, createOutputItemSchema as qr, GeneratorSignalData as qt, AudioLatentEngine as r, getActiveMediaMetadata as ri, JsonValueSchema as rn, SignalStatsSchema as rr, AudioExtractorSignalDataSchema as rt, AudioSignalComputePipeline as s, getMediaType as si, MediaMetadata as sn, SingleOutputGenericSchema as sr, BaseVideoLayerPropsSchema as st, AnimationClip3D as t, frameSignal as ti, JsonObject as tn, SignalMathDataSchema as tr, AnyOutputUnionSchema as tt, Camera3D as u, hasOnlySingleSource as ui, MediaOperationSchema as un, TEXT_LAYER_DEFAULTS as ur, COMPOSITOR_DEFAULTS as ut, MasterAudioEntry as v, oklabToRgb as vi, MultiOutputGeneric as vn, TextSpanMark as vr, ControlNetConditioningOutputs as vt, Path3D as w, reportRenderDiagnostic as wi, NodeResult as wn, TransitionType as wr, DataType as wt, Model3DData as x, programmaticSignal as xi, NodeMetadataSchema as xn, TimelineTransformSchema as xr, DEFAULT_FPS as xt, Material3D as y, parseCssColor as yi, MultiOutputGenericSchema as yn, TimelineSegmentSchema as yr, DATA_TYPE_EXTENSIONS as yt, ensureDevice as z, updateClockSignals as zi, PoseSkeletonOptions as zn, VisionVariant as zr, FileAsset as zt };
+//# sourceMappingURL=index-DDEPvMww.d.mts.map