framefields 2.0.2

package/dist/index-D2jDC7O5.d.mts

@@ -0,0 +1,3643 @@
+import z$1, { z } from "zod";
+import { Input, VideoSample } from "mediabunny";
+import "fontkit";
+
+//#region ../core/dist/index.d.mts
+//#region src/signals/programmatic.d.ts
+interface ProgrammaticSignalOptions {
+  readonly fps?: number;
+  readonly durationFrames?: number;
+  readonly gpuBinding?: GPUTextureBinding;
+  readonly nodeId?: string;
+  readonly label?: string;
+}
+interface GateSignalOptions {
+  readonly mode?: "gate" | "trigger" | "toggle";
+  readonly debounceFrames?: number;
+  readonly holdFrames?: number;
+  readonly invert?: boolean;
+}
+type EvaluatorFn = (ctx: FrameContext) => number;
+declare class ProgrammaticSignal implements FrameSignal<number> {
+  readonly gpuBinding?: GPUTextureBinding;
+  readonly label?: string;
+  private _evaluator;
+  private _samples?;
+  private _fps;
+  private _durationFrames?;
+  private _cachedFrame;
+  private _cachedValue;
+  private _seekedFrame;
+  private _subscribers;
+  private _children;
+  get fps(): number;
+  constructor(source: number | ArrayLike<number> | EvaluatorFn | Signal<number>, options?: ProgrammaticSignalOptions);
+  get value(): number;
+  get(ctx?: FrameContext): number;
+  peek(): number;
+  registerChild(child: ProgrammaticSignal): void;
+  private _derive;
+  seekFrame(frame: number): void;
+  invalidate(): void;
+  valueOf(): number;
+  [Symbol.toPrimitive](hint: string): unknown;
+  smooth(windowFrames: number): ProgrammaticSignal;
+  remap(inMin: number, inMax: number, outMin: number, outMax: number, clamp?: boolean): ProgrammaticSignal;
+  clamp(min: number, max: number): ProgrammaticSignal;
+  gate(threshold: number, options?: GateSignalOptions): ProgrammaticSignal;
+  velocity(dt?: number): ProgrammaticSignal;
+  delay(frames: number): ProgrammaticSignal;
+  spring(stiffness?: number, damping?: number): ProgrammaticSignal;
+  add(other: number | Signal<number>): ProgrammaticSignal;
+  subtract(other: number | Signal<number>): ProgrammaticSignal;
+  multiply(factor: number | Signal<number>): ProgrammaticSignal;
+  invert(): ProgrammaticSignal;
+  pow(exponent: number): ProgrammaticSignal;
+  map(fn: (val: number, ctx: FrameContext) => number): ProgrammaticSignal;
+  toFrameArray(totalFrames: number, fps?: number): Float32Array;
+}
+declare function programmaticSignal(source: number | ArrayLike<number> | EvaluatorFn | Signal<number>, options?: ProgrammaticSignalOptions): ProgrammaticSignal;
+//#endregion
+//#region src/signals/index.d.ts
+interface FrameContext {
+  frame: number;
+  fps: number;
+  time: number;
+  duration: number;
+  durationMs: number;
+  progress: number;
+  deltaTime: number;
+}
+interface GPUTextureBinding {
+  nodeId: string;
+  channel?: "primary" | "beat" | "bass" | "energy";
+  textureView?: unknown;
+  texture?: unknown;
+  buffer?: unknown;
+  stats?: {
+    min: number;
+    max: number;
+  };
+}
+interface Signal<T> {
+  readonly value: T;
+  get(ctx?: FrameContext): T;
+  peek(): T;
+}
+interface WritableSignal<T> extends Signal<T> {
+  value: T;
+  set(value: T): void;
+  update(fn: (prev: T) => T): void;
+}
+interface FrameSignal<T = number> extends Signal<T> {
+  readonly gpuBinding?: GPUTextureBinding;
+  readonly fps?: number;
+  seekFrame?(frame: number): void;
+}
+type SignalContext = FrameContext;
+type SignalValue<T = unknown> = T | Signal<T> | WritableSignal<T> | FrameSignal<T extends number ? number : T>;
+declare function registerSignalDependency(subscribers: Set<ComputedImpl<unknown>>): void;
+declare function isSignal(val: unknown): val is Signal<unknown>;
+declare class ComputedImpl<T> implements Signal<T> {
+  private _fn;
+  private _value;
+  private _dirty;
+  private _evaluating;
+  deps: Set<Set<ComputedImpl<unknown>>>;
+  private _subscribers;
+  constructor(fn: () => T);
+  get value(): T;
+  get(): T;
+  peek(): T;
+  markDirty(): void;
+  private compute;
+  valueOf(): T;
+  [Symbol.toPrimitive](hint: string): unknown;
+}
+declare function signal<T>(initialValue: T): WritableSignal<T>;
+declare function computed<T>(fn: () => T): Signal<T>;
+declare function frameArraySignal(samples: ArrayLike<number>, fps?: number, gpuBinding?: GPUTextureBinding): FrameSignal<number>;
+declare const frameSignal: WritableSignal<number>;
+declare const timeSignal: WritableSignal<number>;
+declare const progressSignal: WritableSignal<number>;
+declare function updateClockSignals(frame: number, fps?: number, durationMs?: number): void;
+interface SignalBuilderConfig {
+  type?: "sine" | "triangle" | "sawtooth" | "square" | "bounce" | "custom";
+  frequency?: number;
+  amplitude?: number;
+  offset?: number;
+  phase?: number;
+  wgsl?: string;
+  gpuBinding?: GPUTextureBinding;
+  fn?: (ctx: FrameContext) => number;
+}
+declare function signalBuilder(config: SignalBuilderConfig): FrameSignal<number>;
+interface SineSignalOptions {
+  min?: number;
+  max?: number;
+  period?: number;
+  frequency?: number;
+  amplitude?: number;
+  offset?: number;
+  phase?: number;
+}
+declare function sineSignal(options?: SineSignalOptions): FrameSignal<number>;
+declare function cosineSignal(options?: SineSignalOptions): FrameSignal<number>;
+declare const Signal: {
+  state: typeof signal;
+  computed: typeof computed;
+  builder: typeof signalBuilder;
+  fromArray: typeof frameArraySignal;
+  programmatic: typeof programmaticSignal;
+  frame: WritableSignal<number>;
+  time: WritableSignal<number>;
+  progress: WritableSignal<number>;
+  sine: typeof sineSignal;
+  cosine: typeof cosineSignal;
+};
+//#endregion
+//#region src/effects/index.d.ts
+type EffectConfigValue<T> = T | Signal<T> | WritableSignal<T> | FrameSignal<T>;
+type EffectConfig<T extends object> = { [K in keyof T]: EffectConfigValue<T[K]> };
+declare abstract class Effect<TConfig extends object = Record<string, unknown>> {
+  abstract readonly op: string;
+  readonly signals: { [K in keyof TConfig]: WritableSignal<TConfig[K]> | Signal<TConfig[K]> };
+  readonly config: TConfig;
+  private _frameHooks;
+  constructor(initialConfig: TConfig);
+  /**
+   * Game-engine per-frame lifecycle hook.
+   * Invoked before rendering each frame so scripts or agents can mutate properties.
+   */
+  onRequestFrame(callback: (ctx: FrameContext) => void): this;
+  notifyFrame(ctx: FrameContext): void;
+  /**
+   * Samples concrete scalar / config values for the current frame.
+   */
+  resolveUniforms(ctx?: FrameContext): Record<string, unknown>;
+  /**
+   * Returns WebGPU texture bindings attached to any property signal.
+   */
+  resolveTextures(): Record<string, unknown>;
+  /**
+   * Converts the effect into an operation node for the VirtualMediaData AST.
+   */
+  toOperation(): Record<string, unknown>;
+}
+//#endregion
+//#region src/errors.d.ts
+declare class ModerationError extends Error {
+  constructor(message: string);
+}
+declare class ModerationUnrefundableError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/id-gen.d.ts
+/**
+ * Generates a unique ID using nanoid.
+ * This function is cross-platform compatible (Node.js and Browser).
+ *
+ * @param size - Optional size of the ID (default is 21)
+ * @returns A unique string ID
+ */
+declare const generateId: (size?: number) => string;
+//#endregion
+//#region src/types/base.d.ts
+declare const DataTypeVal: {
+  readonly Text: "Text";
+  readonly Number: "Number";
+  readonly Boolean: "Boolean";
+  readonly Image: "Image";
+  readonly Video: "Video";
+  readonly Audio: "Audio";
+  readonly SVG: "SVG";
+  readonly Caption: "Caption";
+  readonly Lottie: "Lottie";
+  readonly ThreeD: "ThreeD";
+  readonly GIF: "GIF";
+  readonly Signal: "Signal";
+  readonly LUT: "LUT";
+};
+declare const DataType: {
+  readonly Text: "Text";
+  readonly Number: "Number";
+  readonly Boolean: "Boolean";
+  readonly Image: "Image";
+  readonly Video: "Video";
+  readonly Audio: "Audio";
+  readonly SVG: "SVG";
+  readonly Caption: "Caption";
+  readonly Lottie: "Lottie";
+  readonly ThreeD: "ThreeD";
+  readonly GIF: "GIF";
+  readonly Signal: "Signal";
+  readonly LUT: "LUT";
+};
+type DataType = (typeof DataTypeVal)[keyof typeof DataTypeVal];
+declare const DataTypes: [DataType, ...DataType[]];
+type DataTypeEnum = DataType;
+declare const HandleTypeVal: {
+  readonly Input: "Input";
+  readonly Output: "Output";
+};
+type HandleType = (typeof HandleTypeVal)[keyof typeof HandleTypeVal];
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+interface JsonObject {
+  [key: string]: JsonValue | undefined;
+}
+interface JsonArray extends Array<JsonValue> {}
+declare const JsonValueSchema: z$1.ZodType<JsonValue>;
+/**
+ * Zod schema for the FileAsset model
+ * Matches the Prisma schema definitions for types and nullability.
+ */
+declare const FileAssetSchema: z$1.ZodObject<{
+  id: z$1.ZodCUID2;
+  name: z$1.ZodString;
+  createdAt: z$1.z.ZodCoercedDate<unknown>;
+  updatedAt: z$1.z.ZodCoercedDate<unknown>;
+  userId: z$1.ZodNullable<z$1.ZodCUID2>;
+  width: z$1.ZodNullable<z$1.ZodNumber>;
+  height: z$1.ZodNullable<z$1.ZodNumber>;
+  bucket: z$1.ZodString;
+  size: z$1.ZodNumber;
+  mimeType: z$1.ZodString;
+  key: z$1.ZodString;
+  isUploaded: z$1.ZodDefault<z$1.ZodBoolean>;
+  duration: z$1.ZodNullable<z$1.ZodNumber>;
+  sampleRate: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  channels: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  bitDepth: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  audioCodec: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  audioBitrate: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  fps: z$1.ZodNullable<z$1.ZodNumber>;
+  fingerprint: z$1.ZodNullable<z$1.ZodString>;
+}, z$1.z.core.$strip>;
+type FileAsset = z$1.infer<typeof FileAssetSchema>;
+interface XYPosition {
+  x: number;
+  y: number;
+}
+declare const NodeVisualConfigSchema: z$1.ZodObject<{
+  position: z$1.ZodOptional<z$1.ZodObject<{
+    x: z$1.ZodNumber;
+    y: z$1.ZodNumber;
+  }, z$1.z.core.$strip>>;
+  width: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  height: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  locked: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+  collapsed: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+}, z$1.z.core.$loose>;
+type NodeVisualConfig = z$1.infer<typeof NodeVisualConfigSchema>;
+//#endregion
+//#region src/node-metadata.d.ts
+declare const ConfigHandleSchema: z$1.ZodObject<{
+  configKey: z$1.ZodString;
+  dataTypes: z$1.ZodCustom<DataType[], DataType[]>;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.z.core.$strip>;
+type ConfigHandle = z$1.infer<typeof ConfigHandleSchema>;
+/**
+ * Function type for node config/input validation.
+ */
+type NodeValidationFn = (config: any, inputs?: Record<string, any>, handles?: any[]) => Record<string, string> | null;
+/**
+ * Metadata defining the interface and identity of a node.
+ * This is safe to import in any environment.
+ */
+declare const NodeMetadataSchema: z$1.ZodObject<{
+  type: z$1.ZodString;
+  version: z$1.ZodOptional<z$1.ZodNumber>;
+  baseType: z$1.ZodOptional<z$1.ZodString>;
+  displayName: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  showInQuickAccess: z$1.ZodOptional<z$1.ZodBoolean>;
+  showInSidebar: z$1.ZodOptional<z$1.ZodBoolean>;
+  advanced: z$1.ZodOptional<z$1.ZodBoolean>;
+  category: z$1.ZodString;
+  subcategory: z$1.ZodOptional<z$1.ZodString>;
+  defaultDimensions: z$1.ZodOptional<z$1.ZodObject<{
+    width: z$1.ZodOptional<z$1.ZodNumber>;
+    height: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+  handles: z$1.ZodObject<{
+    inputs: z$1.ZodArray<z$1.ZodObject<{
+      dataTypes: z$1.ZodCustom<DataType[], DataType[]>;
+      label: z$1.ZodString;
+      required: z$1.ZodOptional<z$1.ZodBoolean>;
+      order: z$1.ZodNumber;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.z.core.$strip>>;
+    outputs: z$1.ZodArray<z$1.ZodObject<{
+      dataTypes: z$1.ZodCustom<DataType[], DataType[]>;
+      label: z$1.ZodString;
+      required: z$1.ZodOptional<z$1.ZodBoolean>;
+      order: z$1.ZodNumber;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.z.core.$strip>>;
+  }, z$1.z.core.$strip>;
+  variableInputs: z$1.ZodOptional<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+    enabled: z$1.ZodLiteral<true>;
+    dataTypes: z$1.ZodCustom<DataType[], DataType[]>;
+  }, z$1.z.core.$strip>, z$1.ZodObject<{
+    enabled: z$1.ZodLiteral<false>;
+    dataTypes: z$1.ZodOptional<z$1.ZodCustom<DataType[], DataType[]>>;
+  }, z$1.z.core.$strip>], "enabled">>;
+  variableOutputs: z$1.ZodOptional<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+    enabled: z$1.ZodLiteral<true>;
+    dataTypes: z$1.ZodCustom<DataType[], DataType[]>;
+  }, z$1.z.core.$strip>, z$1.ZodObject<{
+    enabled: z$1.ZodLiteral<false>;
+    dataTypes: z$1.ZodOptional<z$1.ZodCustom<DataType[], DataType[]>>;
+  }, z$1.z.core.$strip>], "enabled">>;
+  isTerminal: z$1.ZodOptional<z$1.ZodBoolean>;
+  isTransient: z$1.ZodOptional<z$1.ZodBoolean>;
+  configSchema: z$1.ZodOptional<z$1.ZodCustom<z$1.ZodType<unknown, unknown, z$1.z.core.$ZodTypeInternals<unknown, unknown>>, z$1.ZodType<unknown, unknown, z$1.z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  defaultConfig: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+  validation: z$1.ZodOptional<z$1.ZodAny>;
+  resultSchema: z$1.ZodOptional<z$1.ZodCustom<z$1.ZodType<unknown, unknown, z$1.z.core.$ZodTypeInternals<unknown, unknown>>, z$1.ZodType<unknown, unknown, z$1.z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  configHandles: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+    configKey: z$1.ZodString;
+    dataTypes: z$1.ZodCustom<DataType[], DataType[]>;
+    label: z$1.ZodString;
+    description: z$1.ZodOptional<z$1.ZodString>;
+  }, z$1.z.core.$strip>>>;
+}, z$1.z.core.$strip>;
+type NodeMetadata = Omit<z$1.infer<typeof NodeMetadataSchema>, "validation"> & {
+  validation?: NodeValidationFn;
+};
+//#endregion
+//#region src/render-diagnostics.d.ts
+/**
+ * Problems a render noticed about its document (as opposed to its output),
+ * collected per render id so the renderer can put them in its QA report.
+ * Producers report; the renderer takes them when the render ends.
+ */
+interface RenderDiagnostic {
+  readonly severity: "error" | "warning" | "info";
+  /** Stable machine-readable kind, e.g. "animation_truncated" */
+  readonly code: string;
+  readonly message: string;
+  readonly layerId?: string;
+}
+/** Record a diagnostic for a render; repeats (same code, layer and message) are kept once. */
+declare function reportRenderDiagnostic(renderId: string, diagnostic: RenderDiagnostic): void;
+/**
+ * Everything reported for a render, including its nested compositions (they
+ * render under derived ids, `${renderId}-…`), removing it from the store.
+ */
+declare function takeRenderDiagnostics(renderId: string): RenderDiagnostic[];
+//#endregion
+//#region src/types/config/colors.d.ts
+declare const dataTypeColors: Record<string, {
+  bg: string;
+  stroke: string;
+  hex: string;
+  text: string;
+  border: string;
+}>;
+//#endregion
+//#region src/types/config/schemas.d.ts
+declare const DATA_TYPE_EXTENSIONS: Record<DataType, string>;
+declare const MIME_TYPES: Record<string, string>;
+declare const COMPOSITE_OPERATIONS: readonly ["source-over", "source-in", "source-out", "source-atop", "destination-over", "destination-in", "destination-out", "destination-atop", "lighter", "copy", "xor", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"];
+declare const GlobalCompositeOperation: z.ZodEnum<{
+  "source-over": "source-over";
+  "source-in": "source-in";
+  "source-out": "source-out";
+  "source-atop": "source-atop";
+  "destination-over": "destination-over";
+  "destination-in": "destination-in";
+  "destination-out": "destination-out";
+  "destination-atop": "destination-atop";
+  lighter: "lighter";
+  copy: "copy";
+  xor: "xor";
+  multiply: "multiply";
+  screen: "screen";
+  overlay: "overlay";
+  darken: "darken";
+  lighten: "lighten";
+  "color-dodge": "color-dodge";
+  "color-burn": "color-burn";
+  "hard-light": "hard-light";
+  "soft-light": "soft-light";
+  difference: "difference";
+  exclusion: "exclusion";
+  hue: "hue";
+  saturation: "saturation";
+  color: "color";
+  luminosity: "luminosity";
+}>;
+type ZodSchemaType = z.ZodType<any, any, any>;
+declare class ConfigSchemaRegistry {
+  private static schemas;
+  static register(type: string, schema: ZodSchemaType): void;
+  static get(type: string): ZodSchemaType | undefined;
+  static clear(): void;
+}
+//#endregion
+//#region src/types/constants.d.ts
+declare const COMPOSITOR_DEFAULTS: {
+  FONT_FAMILY: string;
+  FONT_SIZE: number;
+  FILL: string;
+  LINE_HEIGHT: number;
+  ALIGN: string;
+  VERTICAL_ALIGN: string;
+  LETTER_SPACING: number;
+  STROKE_WIDTH: number;
+  STROKE: string;
+  CORNER_RADIUS: number;
+  PADDING: number;
+};
+//#endregion
+//#region src/types/video/virtual-video.d.ts
+declare const MediaSourceSchema: z.ZodObject<{
+  entity: z.ZodOptional<z.ZodObject<{
+    id: z.ZodCUID2;
+    name: z.ZodString;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+    userId: z.ZodNullable<z.ZodCUID2>;
+    width: z.ZodNullable<z.ZodNumber>;
+    height: z.ZodNullable<z.ZodNumber>;
+    bucket: z.ZodString;
+    size: z.ZodNumber;
+    mimeType: z.ZodString;
+    key: z.ZodString;
+    isUploaded: z.ZodDefault<z.ZodBoolean>;
+    duration: z.ZodNullable<z.ZodNumber>;
+    sampleRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    channels: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bitDepth: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    audioCodec: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    audioBitrate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    fps: z.ZodNullable<z.ZodNumber>;
+    fingerprint: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const MediaMetadataSchema: z.ZodObject<{
+  width: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  height: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  fps: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  durationMs: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  sampleRate: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  channels: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  bitDepth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  audioCodec: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  audioBitrate: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type MediaMetadata = z.infer<typeof MediaMetadataSchema>;
+declare const TimelineSegmentSchema: z.ZodObject<{
+  startSec: z.ZodNumber;
+  endSec: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const TimelineTransformSchema: z.ZodObject<{
+  startFrame: z.ZodOptional<z.ZodNumber>;
+  segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    startSec: z.ZodNumber;
+    endSec: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type TimelineTransform = z.infer<typeof TimelineTransformSchema>;
+declare const BaseMediaOperationPropsSchema: z.ZodObject<{
+  volume: z.ZodOptional<z.ZodNumber>;
+  opacity: z.ZodOptional<z.ZodNumber>;
+  startFrame: z.ZodOptional<z.ZodNumber>;
+  timeline: z.ZodOptional<z.ZodObject<{
+    startFrame: z.ZodOptional<z.ZodNumber>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      startSec: z.ZodNumber;
+      endSec: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type BaseMediaOperationProps = z.infer<typeof BaseMediaOperationPropsSchema>;
+/** Original source file (leaf node) */
+declare const SourceOperationSchema: z.ZodObject<{
+  volume: z.ZodOptional<z.ZodNumber>;
+  opacity: z.ZodOptional<z.ZodNumber>;
+  startFrame: z.ZodOptional<z.ZodNumber>;
+  timeline: z.ZodOptional<z.ZodObject<{
+    startFrame: z.ZodOptional<z.ZodNumber>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      startSec: z.ZodNumber;
+      endSec: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+  op: z.ZodLiteral<"source">;
+  source: z.ZodObject<{
+    entity: z.ZodOptional<z.ZodObject<{
+      id: z.ZodCUID2;
+      name: z.ZodString;
+      createdAt: z.ZodCoercedDate<unknown>;
+      updatedAt: z.ZodCoercedDate<unknown>;
+      userId: z.ZodNullable<z.ZodCUID2>;
+      width: z.ZodNullable<z.ZodNumber>;
+      height: z.ZodNullable<z.ZodNumber>;
+      bucket: z.ZodString;
+      size: z.ZodNumber;
+      mimeType: z.ZodString;
+      key: z.ZodString;
+      isUploaded: z.ZodDefault<z.ZodBoolean>;
+      duration: z.ZodNullable<z.ZodNumber>;
+      sampleRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+      channels: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+      bitDepth: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+      audioCodec: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      audioBitrate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+      fps: z.ZodNullable<z.ZodNumber>;
+      fingerprint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  sourceMeta: z.ZodObject<{
+    width: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    height: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    fps: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    durationMs: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    sampleRate: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    channels: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    bitDepth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    audioCodec: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    audioBitrate: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  }, z.core.$strip>;
+  dataType: z.ZodEnum<{
+    Text: "Text";
+    Number: "Number";
+    Boolean: "Boolean";
+    Image: "Image";
+    Video: "Video";
+    Audio: "Audio";
+    SVG: "SVG";
+    Caption: "Caption";
+    Lottie: "Lottie";
+    ThreeD: "ThreeD";
+    GIF: "GIF";
+    Signal: "Signal";
+    LUT: "LUT";
+  }>;
+}, z.core.$strip>;
+/** Text content (leaf node) */
+declare const TextOperationSchema: z.ZodObject<{
+  volume: z.ZodOptional<z.ZodNumber>;
+  opacity: z.ZodOptional<z.ZodNumber>;
+  startFrame: z.ZodOptional<z.ZodNumber>;
+  timeline: z.ZodOptional<z.ZodObject<{
+    startFrame: z.ZodOptional<z.ZodNumber>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      startSec: z.ZodNumber;
+      endSec: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+  op: z.ZodLiteral<"text">;
+  text: z.ZodString;
+  metadata: z.ZodOptional<z.ZodObject<{
+    width: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    height: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    fps: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    durationMs: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    sampleRate: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    channels: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    bitDepth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    audioCodec: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    audioBitrate: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+  }, z.core.$strip>>;
+  dataType: z.ZodEnum<{
+    Text: "Text";
+    Number: "Number";
+    Boolean: "Boolean";
+    Image: "Image";
+    Video: "Video";
+    Audio: "Audio";
+    SVG: "SVG";
+    Caption: "Caption";
+    Lottie: "Lottie";
+    ThreeD: "ThreeD";
+    GIF: "GIF";
+    Signal: "Signal";
+    LUT: "LUT";
+  }>;
+}, z.core.$loose>;
+declare const MediaOperationSchema: z.ZodType<MediaOperation>;
+type MediaOperation = BaseMediaOperationProps & (({
+  op: "source";
+} & z.infer<typeof SourceOperationSchema>) | ({
+  op: "text";
+} & z.infer<typeof TextOperationSchema>) | ({
+  op: string;
+  metadata?: MediaMetadata;
+  dataType: DataType;
+} & Record<string, any>));
+type VirtualMediaData = {
+  metadata: MediaMetadata;
+  operation: MediaOperation;
+  children: VirtualMediaData[];
+};
+declare const VirtualMediaDataSchema: z.ZodType<VirtualMediaData>;
+//#endregion
+//#region src/types/node-result.d.ts
+declare const FileDataSchema: z$1.ZodObject<{
+  entity: z$1.ZodOptional<z$1.ZodCustom<{
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string | null;
+    width: number | null;
+    height: number | null;
+    bucket: string;
+    size: number;
+    mimeType: string;
+    key: string;
+    isUploaded: boolean;
+    duration: number | null;
+    fps: number | null;
+    fingerprint: string | null;
+    sampleRate?: number | null | undefined;
+    channels?: number | null | undefined;
+    bitDepth?: number | null | undefined;
+    audioCodec?: string | null | undefined;
+    audioBitrate?: number | null | undefined;
+  }, {
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string | null;
+    width: number | null;
+    height: number | null;
+    bucket: string;
+    size: number;
+    mimeType: string;
+    key: string;
+    isUploaded: boolean;
+    duration: number | null;
+    fps: number | null;
+    fingerprint: string | null;
+    sampleRate?: number | null | undefined;
+    channels?: number | null | undefined;
+    bitDepth?: number | null | undefined;
+    audioCodec?: string | null | undefined;
+    audioBitrate?: number | null | undefined;
+  }>>;
+}, z$1.z.core.$strip>;
+type FileData = z$1.infer<typeof FileDataSchema>;
+declare const SignalStatsSchema: z$1.ZodObject<{
+  min: z$1.ZodOptional<z$1.ZodNumber>;
+  max: z$1.ZodOptional<z$1.ZodNumber>;
+  mean: z$1.ZodOptional<z$1.ZodNumber>;
+  rms: z$1.ZodOptional<z$1.ZodNumber>;
+  peak: z$1.ZodOptional<z$1.ZodNumber>;
+  beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+  tempo: z$1.ZodOptional<z$1.ZodNumber>;
+}, z$1.z.core.$strip>;
+type SignalStats = z$1.infer<typeof SignalStatsSchema>;
+declare const SignalChannelMetaSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  name: z$1.ZodString;
+  index: z$1.ZodNumber;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$strip>;
+type SignalChannelMeta = z$1.infer<typeof SignalChannelMetaSchema>;
+declare const GeneratorSignalDataSchema: z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"generator">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  baseType: z$1.ZodOptional<z$1.ZodString>;
+  func: z$1.ZodDefault<z$1.ZodUnion<[z$1.ZodEnum<{
+    custom: "custom";
+    sine: "sine";
+    triangle: "triangle";
+    sawtooth: "sawtooth";
+    square: "square";
+  }>, z$1.ZodString]>>;
+  frequency: z$1.ZodDefault<z$1.ZodNumber>;
+  amplitude: z$1.ZodDefault<z$1.ZodNumber>;
+  phase: z$1.ZodDefault<z$1.ZodNumber>;
+  offset: z$1.ZodDefault<z$1.ZodNumber>;
+  waveform: z$1.ZodOptional<z$1.ZodString>;
+  bpm: z$1.ZodOptional<z$1.ZodNumber>;
+  syncToBpm: z$1.ZodOptional<z$1.ZodBoolean>;
+  fmFrequency: z$1.ZodOptional<z$1.ZodNumber>;
+  fmDepth: z$1.ZodOptional<z$1.ZodNumber>;
+  envelope: z$1.ZodOptional<z$1.ZodString>;
+  fnBody: z$1.ZodOptional<z$1.ZodString>;
+  fnParams: z$1.ZodOptional<z$1.ZodArray<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>>;
+  customWGSL: z$1.ZodOptional<z$1.ZodString>;
+  signalFnName: z$1.ZodOptional<z$1.ZodString>;
+  outputType: z$1.ZodOptional<z$1.ZodString>;
+  fps: z$1.ZodOptional<z$1.ZodNumber>;
+  durationMs: z$1.ZodOptional<z$1.ZodNumber>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$loose>;
+type GeneratorSignalData = z$1.infer<typeof GeneratorSignalDataSchema>;
+declare const AudioExtractorSignalDataSchema: z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"audio_extractor">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  sourceUrl: z$1.ZodOptional<z$1.ZodString>;
+  channel: z$1.ZodOptional<z$1.ZodUnion<[z$1.ZodEnum<{
+    primary: "primary";
+    beat: "beat";
+    bass: "bass";
+    energy: "energy";
+    spectral_flux: "spectral_flux";
+  }>, z$1.ZodString]>>;
+  channelIndex: z$1.ZodOptional<z$1.ZodNumber>;
+  channels: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+    id: z$1.ZodString;
+    name: z$1.ZodString;
+    index: z$1.ZodNumber;
+    stats: z$1.ZodOptional<z$1.ZodObject<{
+      min: z$1.ZodOptional<z$1.ZodNumber>;
+      max: z$1.ZodOptional<z$1.ZodNumber>;
+      mean: z$1.ZodOptional<z$1.ZodNumber>;
+      rms: z$1.ZodOptional<z$1.ZodNumber>;
+      peak: z$1.ZodOptional<z$1.ZodNumber>;
+      beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+      tempo: z$1.ZodOptional<z$1.ZodNumber>;
+    }, z$1.z.core.$strip>>;
+  }, z$1.z.core.$strip>>>;
+  extractionMode: z$1.ZodOptional<z$1.ZodString>;
+  attackMs: z$1.ZodOptional<z$1.ZodNumber>;
+  releaseMs: z$1.ZodOptional<z$1.ZodNumber>;
+  sensitivity: z$1.ZodOptional<z$1.ZodNumber>;
+  noiseFloorDb: z$1.ZodOptional<z$1.ZodNumber>;
+  dynamicRangeDb: z$1.ZodOptional<z$1.ZodNumber>;
+  autoRange: z$1.ZodOptional<z$1.ZodBoolean>;
+  smoothing: z$1.ZodOptional<z$1.ZodNumber>;
+  curve: z$1.ZodOptional<z$1.ZodString>;
+  beatThreshold: z$1.ZodOptional<z$1.ZodNumber>;
+  beatDecayMs: z$1.ZodOptional<z$1.ZodNumber>;
+  previewMode: z$1.ZodOptional<z$1.ZodString>;
+  samples: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodArray<z$1.ZodNumber>, z$1.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>]>>;
+  fps: z$1.ZodOptional<z$1.ZodNumber>;
+  durationMs: z$1.ZodOptional<z$1.ZodNumber>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+  state: z$1.ZodOptional<z$1.ZodEnum<{
+    pending: "pending";
+    ready: "ready";
+    failed: "failed";
+  }>>;
+  error: z$1.ZodOptional<z$1.ZodString>;
+  virtualMedia: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+  signalFnName: z$1.ZodOptional<z$1.ZodString>;
+  customWGSL: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.z.core.$loose>;
+type AudioExtractorSignalData = z$1.infer<typeof AudioExtractorSignalDataSchema>;
+declare const SignalMathDataSchema: z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"signal_math">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  op: z$1.ZodOptional<z$1.ZodString>;
+  operation: z$1.ZodOptional<z$1.ZodString>;
+  signalA: z$1.ZodOptional<z$1.ZodUnknown>;
+  signalB: z$1.ZodOptional<z$1.ZodUnknown>;
+  bValue: z$1.ZodOptional<z$1.ZodNumber>;
+  inMin: z$1.ZodOptional<z$1.ZodNumber>;
+  inMax: z$1.ZodOptional<z$1.ZodNumber>;
+  outMin: z$1.ZodOptional<z$1.ZodNumber>;
+  outMax: z$1.ZodOptional<z$1.ZodNumber>;
+  clampMin: z$1.ZodOptional<z$1.ZodNumber>;
+  clampMax: z$1.ZodOptional<z$1.ZodNumber>;
+  exponent: z$1.ZodOptional<z$1.ZodNumber>;
+  edge0: z$1.ZodOptional<z$1.ZodNumber>;
+  edge1: z$1.ZodOptional<z$1.ZodNumber>;
+  customWGSL: z$1.ZodOptional<z$1.ZodString>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$loose>;
+type SignalMathData = z$1.infer<typeof SignalMathDataSchema>;
+declare const SignalGateDataSchema: z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"gate">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  sourceSignal: z$1.ZodOptional<z$1.ZodUnknown>;
+  threshold: z$1.ZodOptional<z$1.ZodNumber>;
+  debounceMs: z$1.ZodOptional<z$1.ZodNumber>;
+  mode: z$1.ZodOptional<z$1.ZodEnum<{
+    gate: "gate";
+    trigger: "trigger";
+    toggle: "toggle";
+  }>>;
+  holdFrames: z$1.ZodOptional<z$1.ZodNumber>;
+  invert: z$1.ZodOptional<z$1.ZodBoolean>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$loose>;
+type SignalGateData = z$1.infer<typeof SignalGateDataSchema>;
+declare const SignalDataSchema: z$1.ZodUnion<readonly [z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"generator">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  baseType: z$1.ZodOptional<z$1.ZodString>;
+  func: z$1.ZodDefault<z$1.ZodUnion<[z$1.ZodEnum<{
+    custom: "custom";
+    sine: "sine";
+    triangle: "triangle";
+    sawtooth: "sawtooth";
+    square: "square";
+  }>, z$1.ZodString]>>;
+  frequency: z$1.ZodDefault<z$1.ZodNumber>;
+  amplitude: z$1.ZodDefault<z$1.ZodNumber>;
+  phase: z$1.ZodDefault<z$1.ZodNumber>;
+  offset: z$1.ZodDefault<z$1.ZodNumber>;
+  waveform: z$1.ZodOptional<z$1.ZodString>;
+  bpm: z$1.ZodOptional<z$1.ZodNumber>;
+  syncToBpm: z$1.ZodOptional<z$1.ZodBoolean>;
+  fmFrequency: z$1.ZodOptional<z$1.ZodNumber>;
+  fmDepth: z$1.ZodOptional<z$1.ZodNumber>;
+  envelope: z$1.ZodOptional<z$1.ZodString>;
+  fnBody: z$1.ZodOptional<z$1.ZodString>;
+  fnParams: z$1.ZodOptional<z$1.ZodArray<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>>;
+  customWGSL: z$1.ZodOptional<z$1.ZodString>;
+  signalFnName: z$1.ZodOptional<z$1.ZodString>;
+  outputType: z$1.ZodOptional<z$1.ZodString>;
+  fps: z$1.ZodOptional<z$1.ZodNumber>;
+  durationMs: z$1.ZodOptional<z$1.ZodNumber>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$loose>, z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"audio_extractor">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  sourceUrl: z$1.ZodOptional<z$1.ZodString>;
+  channel: z$1.ZodOptional<z$1.ZodUnion<[z$1.ZodEnum<{
+    primary: "primary";
+    beat: "beat";
+    bass: "bass";
+    energy: "energy";
+    spectral_flux: "spectral_flux";
+  }>, z$1.ZodString]>>;
+  channelIndex: z$1.ZodOptional<z$1.ZodNumber>;
+  channels: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+    id: z$1.ZodString;
+    name: z$1.ZodString;
+    index: z$1.ZodNumber;
+    stats: z$1.ZodOptional<z$1.ZodObject<{
+      min: z$1.ZodOptional<z$1.ZodNumber>;
+      max: z$1.ZodOptional<z$1.ZodNumber>;
+      mean: z$1.ZodOptional<z$1.ZodNumber>;
+      rms: z$1.ZodOptional<z$1.ZodNumber>;
+      peak: z$1.ZodOptional<z$1.ZodNumber>;
+      beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+      tempo: z$1.ZodOptional<z$1.ZodNumber>;
+    }, z$1.z.core.$strip>>;
+  }, z$1.z.core.$strip>>>;
+  extractionMode: z$1.ZodOptional<z$1.ZodString>;
+  attackMs: z$1.ZodOptional<z$1.ZodNumber>;
+  releaseMs: z$1.ZodOptional<z$1.ZodNumber>;
+  sensitivity: z$1.ZodOptional<z$1.ZodNumber>;
+  noiseFloorDb: z$1.ZodOptional<z$1.ZodNumber>;
+  dynamicRangeDb: z$1.ZodOptional<z$1.ZodNumber>;
+  autoRange: z$1.ZodOptional<z$1.ZodBoolean>;
+  smoothing: z$1.ZodOptional<z$1.ZodNumber>;
+  curve: z$1.ZodOptional<z$1.ZodString>;
+  beatThreshold: z$1.ZodOptional<z$1.ZodNumber>;
+  beatDecayMs: z$1.ZodOptional<z$1.ZodNumber>;
+  previewMode: z$1.ZodOptional<z$1.ZodString>;
+  samples: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodArray<z$1.ZodNumber>, z$1.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>]>>;
+  fps: z$1.ZodOptional<z$1.ZodNumber>;
+  durationMs: z$1.ZodOptional<z$1.ZodNumber>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+  state: z$1.ZodOptional<z$1.ZodEnum<{
+    pending: "pending";
+    ready: "ready";
+    failed: "failed";
+  }>>;
+  error: z$1.ZodOptional<z$1.ZodString>;
+  virtualMedia: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+  signalFnName: z$1.ZodOptional<z$1.ZodString>;
+  customWGSL: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.z.core.$loose>, z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"signal_math">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  op: z$1.ZodOptional<z$1.ZodString>;
+  operation: z$1.ZodOptional<z$1.ZodString>;
+  signalA: z$1.ZodOptional<z$1.ZodUnknown>;
+  signalB: z$1.ZodOptional<z$1.ZodUnknown>;
+  bValue: z$1.ZodOptional<z$1.ZodNumber>;
+  inMin: z$1.ZodOptional<z$1.ZodNumber>;
+  inMax: z$1.ZodOptional<z$1.ZodNumber>;
+  outMin: z$1.ZodOptional<z$1.ZodNumber>;
+  outMax: z$1.ZodOptional<z$1.ZodNumber>;
+  clampMin: z$1.ZodOptional<z$1.ZodNumber>;
+  clampMax: z$1.ZodOptional<z$1.ZodNumber>;
+  exponent: z$1.ZodOptional<z$1.ZodNumber>;
+  edge0: z$1.ZodOptional<z$1.ZodNumber>;
+  edge1: z$1.ZodOptional<z$1.ZodNumber>;
+  customWGSL: z$1.ZodOptional<z$1.ZodString>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$loose>, z$1.ZodObject<{
+  v: z$1.ZodOptional<z$1.ZodLiteral<2>>;
+  type: z$1.ZodLiteral<"gate">;
+  nodeId: z$1.ZodOptional<z$1.ZodString>;
+  sourceSignal: z$1.ZodOptional<z$1.ZodUnknown>;
+  threshold: z$1.ZodOptional<z$1.ZodNumber>;
+  debounceMs: z$1.ZodOptional<z$1.ZodNumber>;
+  mode: z$1.ZodOptional<z$1.ZodEnum<{
+    gate: "gate";
+    trigger: "trigger";
+    toggle: "toggle";
+  }>>;
+  holdFrames: z$1.ZodOptional<z$1.ZodNumber>;
+  invert: z$1.ZodOptional<z$1.ZodBoolean>;
+  stats: z$1.ZodOptional<z$1.ZodObject<{
+    min: z$1.ZodOptional<z$1.ZodNumber>;
+    max: z$1.ZodOptional<z$1.ZodNumber>;
+    mean: z$1.ZodOptional<z$1.ZodNumber>;
+    rms: z$1.ZodOptional<z$1.ZodNumber>;
+    peak: z$1.ZodOptional<z$1.ZodNumber>;
+    beats: z$1.ZodOptional<z$1.ZodArray<z$1.ZodNumber>>;
+    tempo: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$loose>, z$1.ZodObject<{
+  type: z$1.ZodString;
+}, z$1.z.core.$loose>]>;
+type SignalData = z$1.infer<typeof SignalDataSchema>;
+declare function serializeSignalData(data: SignalData): string;
+declare function deserializeSignalData(raw: unknown): SignalData;
+type DataForType<R extends DataType> = R extends "Text" ? string : R extends "Number" ? number : R extends "Boolean" ? boolean : R extends "Signal" ? SignalData : R extends "Image" | "SVG" | "Caption" | "Video" | "Audio" | "Lottie" | "ThreeD" | "GIF" | "LUT" ? VirtualMediaData : R extends "Any" ? string | number | boolean | FileData | VirtualMediaData | SignalData : never;
+declare const OutputItemSchema: z$1.ZodObject<{
+  type: z$1.ZodCustom<DataType, DataType>;
+  data: z$1.ZodAny;
+  outputHandleId: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.z.core.$strip>;
+declare const createOutputItemSchema: <T extends DataType>(type: z$1.ZodLiteral<T>, dataSchema: z$1.ZodTypeAny) => z$1.ZodType<OutputItem<T>>;
+type OutputItem<R extends DataType> = {
+  type: R;
+  data: DataForType<R>;
+  outputHandleId: string | undefined;
+};
+type Output$1 = {
+  items: OutputItem<DataType>[];
+};
+declare const SingleOutputGenericSchema: <T extends DataType>(outputItemSchema: z$1.ZodType<OutputItem<T>>) => z$1.ZodObject<{
+  selectedOutputIndex: z$1.ZodLiteral<0>;
+  outputs: z$1.ZodTuple<[z$1.ZodObject<{
+    items: z$1.ZodTuple<[z$1.ZodType<OutputItem<T>, unknown, z$1.z.core.$ZodTypeInternals<OutputItem<T>, unknown>>], null>;
+  }, z$1.z.core.$strip>], null>;
+}, z$1.z.core.$strip>;
+type SingleOutputGeneric<T extends DataType> = {
+  selectedOutputIndex: 0;
+  outputs: [{
+    items: [OutputItem<T>];
+  }];
+};
+declare const MultiOutputGenericSchema: <T extends DataType>(outputItemSchema: z$1.ZodType<OutputItem<T>>) => z$1.ZodObject<{
+  selectedOutputIndex: z$1.ZodNumber;
+  outputs: z$1.ZodArray<z$1.ZodObject<{
+    items: z$1.ZodArray<z$1.ZodType<OutputItem<T>, unknown, z$1.z.core.$ZodTypeInternals<OutputItem<T>, unknown>>>;
+  }, z$1.z.core.$strip>>;
+  sourceFingerprint: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.z.core.$strip>;
+type MultiOutputGeneric<T extends DataType> = {
+  selectedOutputIndex: number;
+  outputs: {
+    items: OutputItem<T>[];
+  }[];
+  sourceFingerprint?: string;
+};
+type AnyOutputUnion = OutputItem<"Video"> | OutputItem<"Image"> | OutputItem<"Audio"> | OutputItem<"Text"> | OutputItem<"Number"> | OutputItem<"Boolean"> | OutputItem<"SVG"> | OutputItem<"GIF"> | OutputItem<"Caption"> | OutputItem<"Lottie"> | OutputItem<"ThreeD"> | OutputItem<"Signal"> | OutputItem<"LUT">;
+declare const AnyOutputUnionSchema: z$1.ZodType<AnyOutputUnion>;
+declare const NodeResultSchema: z$1.ZodObject<{
+  selectedOutputIndex: z$1.ZodNumber;
+  outputs: z$1.ZodArray<z$1.ZodObject<{
+    items: z$1.ZodArray<z$1.ZodType<AnyOutputUnion, unknown, z$1.z.core.$ZodTypeInternals<AnyOutputUnion, unknown>>>;
+  }, z$1.z.core.$strip>>;
+}, z$1.z.core.$strip>;
+type NodeResult = z$1.infer<typeof NodeResultSchema>;
+declare const ExportResultSchema: z$1.ZodObject<{
+  selectedOutputIndex: z$1.ZodNumber;
+  outputs: z$1.ZodArray<z$1.ZodObject<{
+    items: z$1.ZodArray<z$1.ZodType<OutputItem<"Text" | "Number" | "Boolean" | "Image" | "Video" | "Audio" | "SVG" | "Caption" | "Lottie" | "ThreeD" | "GIF" | "Signal" | "LUT">, unknown, z$1.z.core.$ZodTypeInternals<OutputItem<"Text" | "Number" | "Boolean" | "Image" | "Video" | "Audio" | "SVG" | "Caption" | "Lottie" | "ThreeD" | "GIF" | "Signal" | "LUT">, unknown>>>;
+  }, z$1.z.core.$strip>>;
+  sourceFingerprint: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.z.core.$strip>;
+type ExportResult = {
+  selectedOutputIndex: number;
+  outputs: {
+    items: AnyOutputUnion[];
+  }[];
+  sourceFingerprint?: string;
+};
+//#endregion
+//#region src/types/node-processor.d.ts
+type ConnectedInput = {
+  connectionValid: boolean;
+  outputItem: AnyOutputUnion | null;
+};
+interface NodeProcessorContext {
+  getFirstOutputHandle: (nodeId: string, type?: DataTypeEnum) => string | undefined;
+  getFirstOutputHandleWithLabel: (nodeId: string, label: string) => string | undefined;
+  findInputData: (inputs: Record<string, ConnectedInput>, requiredType?: string, handleLabel?: string) => string | undefined;
+  registerObjectUrl: (url: string) => void;
+  getOutputHandle: (type: string, label?: string) => string | undefined;
+}
+type NodeProcessorParams<TNode = any> = {
+  node: TNode;
+  inputs: Record<string, ConnectedInput>;
+  signal: AbortSignal;
+  data: any;
+  context: NodeProcessorContext;
+};
+type NodeRunFunction<TNode = any> = (params: NodeProcessorParams<TNode>) => Promise<NodeResult | null>;
+//#endregion
+//#region src/types/rich-text.d.ts
+interface TextSpanMark {
+  background: string | Signal<string>;
+  borderRadius?: number;
+  paddingX?: number;
+  paddingY?: number;
+}
+interface TextSpan {
+  text: string | Signal<string>;
+  fontFamily?: string;
+  fontSize?: number | Signal<number>;
+  fontWeight?: number | string;
+  fontStyle?: "normal" | "italic";
+  fill?: string | Signal<string>;
+  letterSpacing?: number;
+  baselineShift?: number;
+  opacity?: number | Signal<number>;
+  mark?: TextSpanMark;
+}
+//#endregion
+//#region src/types/services.d.ts
+/**
+ * Interface for media processing and handling.
+ */
+interface MediaService {
+  getImageDimensions: (buffer: Buffer) => Promise<{
+    width: number;
+    height: number;
+  }> | {
+    width: number;
+    height: number;
+  };
+  getImageBuffer: (imageInput: FileData) => Promise<Buffer>;
+  resolveFileDataUrl: (data: FileData | null) => string | Promise<string | null> | null;
+}
+/**
+ * Interface for storage operations.
+ */
+interface StorageService {
+  uploadToStorage: (buffer: Buffer, key: string, contentType?: string, bucketName?: string) => Promise<void>;
+  uploadFileToStorage: (filePath: string, key: string, contentType?: string, bucketName?: string) => Promise<void>;
+  getFromStorage?: (key: string, bucketName?: string) => Promise<Buffer>;
+  deleteFromStorage?: (key: string, bucketName?: string) => Promise<void>;
+  getPublicUrl?: (key: string, bucketName?: string) => string;
+}
+//#endregion
+//#region src/types/vision.d.ts
+/**
+ * Shared vision types (engine-agnostic — no ONNX imports here).
+ *
+ * Consumed by @framefields/vision (the inference engine) and @framefields/framefields (the SDK).
+ */
+/**
+ * Vision tasks and the model that serves each:
+ *  - `detect` / `segment` — RTMDet-Ins (COCO 80 boxes + instance masks, one forward pass)
+ *  - `pose` — RTMO (COCO-17 keypoints, multi-person)
+ *  - `matte` — MediaPipe Selfie Segmenter (fast person-vs-background alpha)
+ */
+type VisionTask = "detect" | "segment" | "pose" | "matte";
+/** Model size: `t` (tiny, fastest) · `s` (default) · `m` (most accurate). */
+type VisionVariant = "t" | "s" | "m";
+interface VisionConfig {
+  readonly enableDetection?: boolean;
+  readonly enableSegmentation?: boolean;
+  readonly enablePose?: boolean;
+  /** Fast person matte (Selfie Segmenter) alongside or instead of instance masks. */
+  readonly enableMatte?: boolean;
+  /** COCO class-name filter (all classes when omitted). */
+  readonly classes?: readonly string[];
+  /** Minimum detection score, 0..1. Default 0.3. */
+  readonly confidence?: number;
+  /** Model size. Default "s". */
+  readonly variant?: VisionVariant;
+  /** Model cache directory. Default `$FRAMEFIELDS_MODELS_DIR` or `~/.cache/framefields/models`. */
+  readonly modelsDir?: string;
+  /** Mirror origin for model downloads (`<baseUrl>/<filename>`). Default: pinned Hugging Face revisions. */
+  readonly baseUrl?: string;
+  /** Mask probability threshold (lower → fuller masks). Default 0.5. */
+  readonly maskThreshold?: number;
+  /** Soft-edge band around `maskThreshold`, 0..1. Default 0.05. */
+  readonly featherRadius?: number;
+  /** Vertical FOV (degrees) used to project landmarks into camera space. */
+  readonly cameraFov?: number;
+}
+interface VisionNodeSpec {
+  readonly id: string;
+  readonly kind: "vision";
+  readonly source?: unknown;
+  readonly config: VisionConfig;
+}
+interface Landmark3D {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly visibility?: number;
+}
+type NormalizedLandmarkList = readonly Landmark3D[];
+interface ObjectBoundingBox {
+  readonly originX: number;
+  readonly originY: number;
+  readonly width: number;
+  readonly height: number;
+  readonly normalizedX: number;
+  readonly normalizedY: number;
+  readonly normalizedWidth: number;
+  readonly normalizedHeight: number;
+  readonly angle?: number;
+}
+interface DetectedObject {
+  readonly category: string;
+  readonly score: number;
+  readonly boundingBox: ObjectBoundingBox;
+  readonly keypoints?: NormalizedLandmarkList;
+}
+interface TrackedObject {
+  readonly trackId: number;
+  readonly category: string;
+  readonly score: number;
+  readonly boundingBox: ObjectBoundingBox;
+  readonly centerX: number;
+  readonly centerY: number;
+  readonly normalizedCenterX: number;
+  readonly normalizedCenterY: number;
+  readonly velocity: {
+    readonly vx: number;
+    readonly vy: number;
+  };
+  readonly speed: number;
+  readonly age: number;
+  readonly hits: number;
+  readonly active: boolean;
+  readonly isCoasting: boolean;
+}
+//#endregion
+//#region src/types/tensor.d.ts
+type TensorFormat = "r8unorm" | "r32float" | "rg16float" | "rgba16float" | "rgba8unorm";
+interface TensorDimensions {
+  readonly width: number;
+  readonly height: number;
+  readonly channels: number;
+}
+interface OpticalFlowOptions {
+  readonly scale?: number;
+  readonly windowSize?: number;
+  readonly regularization?: number;
+  readonly outputFormat?: "rgba16float" | "rg32float";
+}
+interface DeflickerOptions {
+  readonly blendWeight?: number | Signal<number>;
+  readonly disocclusionThreshold?: number;
+  readonly maxMotionPixels?: number;
+  readonly opticalFlow?: OpticalFlowOptions;
+}
+interface NormalRelightingOptions {
+  readonly normalMap?: GPUTexture | unknown;
+  readonly depthScale?: number | Signal<number>;
+  readonly roughness?: number | Signal<number>;
+  readonly specularStrength?: number | Signal<number>;
+  readonly metallic?: number | Signal<number>;
+  readonly ambientIntensity?: number | Signal<number>;
+  readonly volumetricDensity?: number | Signal<number>;
+}
+interface ControlNetConditioningOutputs {
+  readonly canny?: GPUTexture;
+  readonly depth?: GPUTexture;
+  readonly normals?: GPUTexture;
+  readonly poseSkeleton?: GPUTexture;
+  readonly segmentationMask?: GPUTexture;
+  readonly faceLandmarks?: GPUTexture;
+  readonly motionVectors?: GPUTexture;
+  readonly deflickered?: GPUTexture;
+}
+interface TensorData {
+  readonly data: Float32Array;
+  readonly shape: readonly number[];
+  readonly dtype: "float32";
+}
+interface CannyOptions {
+  readonly low?: number;
+  readonly high?: number;
+  readonly outputFormat?: "rgba8unorm" | "r32float";
+}
+interface DepthNormalsOptions {
+  readonly depthQuality?: "high" | "standard";
+  readonly depthScale?: number;
+  readonly outputFormat?: "rgba16float" | "rgba8unorm";
+}
+interface PoseSkeletonOptions {
+  readonly width?: number;
+  readonly height?: number;
+  readonly lineWidth?: number;
+  readonly landmarks?: NormalizedLandmarkList;
+}
+interface FaceLandmarksOptions {
+  readonly width?: number;
+  readonly height?: number;
+  readonly lineWidth?: number;
+  readonly landmarks?: NormalizedLandmarkList;
+}
+interface SegmentationOptions {
+  readonly threshold?: number;
+  readonly feather?: number;
+  readonly outputFormat?: "rgba8unorm" | "r8unorm";
+}
+interface TensorPipelineConfig {
+  readonly canny?: CannyOptions;
+  readonly depthNormals?: DepthNormalsOptions;
+  readonly poseSkeleton?: PoseSkeletonOptions;
+  readonly faceLandmarks?: FaceLandmarksOptions;
+  readonly segmentation?: SegmentationOptions;
+  readonly opticalFlow?: OpticalFlowOptions;
+  readonly deflicker?: DeflickerOptions;
+}
+interface TensorNode {
+  readonly id: string;
+  readonly kind: "tensor";
+  readonly source?: unknown;
+  readonly config: TensorPipelineConfig;
+}
+interface MeshAudioDeformConfig {
+  readonly audioTrackId?: string;
+  /**
+   * normal_extrusion pushes vertices out along their normals by the band's
+   * energy; radial_pulse inflates the mesh from its origin on bass and
+   * drums; harmonic_wave runs a sine along Y; twist turns each slice about
+   * the Y axis in proportion to its height and the bass; ripple sends
+   * concentric waves across the XY plane, struck by the drums.
+   */
+  readonly mode: "radial_pulse" | "harmonic_wave" | "normal_extrusion" | "twist" | "ripple";
+  readonly frequencyRange?: [minHz: number, maxHz: number];
+  readonly amplitudeMultiplier?: number | Signal<number>;
+  readonly damping?: number;
+}
+//#endregion
+//#region src/types/video/base-layer-schema.d.ts
+declare const AnimationTypeSchema: z.ZodEnum<{
+  "fade-in": "fade-in";
+  "fade-out": "fade-out";
+  "slide-in-left": "slide-in-left";
+  "slide-in-right": "slide-in-right";
+  "slide-in-top": "slide-in-top";
+  "slide-in-bottom": "slide-in-bottom";
+  "zoom-in": "zoom-in";
+  "zoom-out": "zoom-out";
+  "rotate-cw": "rotate-cw";
+  "rotate-ccw": "rotate-ccw";
+  bounce: "bounce";
+  shake: "shake";
+}>;
+type AnimationType = z.infer<typeof AnimationTypeSchema>;
+declare const VideoAnimationSchema: z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodEnum<{
+    "fade-in": "fade-in";
+    "fade-out": "fade-out";
+    "slide-in-left": "slide-in-left";
+    "slide-in-right": "slide-in-right";
+    "slide-in-top": "slide-in-top";
+    "slide-in-bottom": "slide-in-bottom";
+    "zoom-in": "zoom-in";
+    "zoom-out": "zoom-out";
+    "rotate-cw": "rotate-cw";
+    "rotate-ccw": "rotate-ccw";
+    bounce: "bounce";
+    shake: "shake";
+  }>;
+  value: z.ZodNumber;
+}, z.core.$strip>;
+type VideoAnimation = z.infer<typeof VideoAnimationSchema>;
+declare const VideoSpatialPropsSchema: z.ZodObject<{
+  x: z.ZodDefault<z.ZodNumber>;
+  y: z.ZodDefault<z.ZodNumber>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  rotation: z.ZodDefault<z.ZodNumber>;
+  scale: z.ZodDefault<z.ZodNumber>;
+  opacity: z.ZodDefault<z.ZodNumber>;
+  zIndex: z.ZodOptional<z.ZodNumber>;
+  blendMode: z.ZodOptional<z.ZodEnum<{
+    "source-over": "source-over";
+    "source-in": "source-in";
+    "source-out": "source-out";
+    "source-atop": "source-atop";
+    "destination-over": "destination-over";
+    "destination-in": "destination-in";
+    "destination-out": "destination-out";
+    "destination-atop": "destination-atop";
+    lighter: "lighter";
+    copy: "copy";
+    xor: "xor";
+    multiply: "multiply";
+    screen: "screen";
+    overlay: "overlay";
+    darken: "darken";
+    lighten: "lighten";
+    "color-dodge": "color-dodge";
+    "color-burn": "color-burn";
+    "hard-light": "hard-light";
+    "soft-light": "soft-light";
+    difference: "difference";
+    exclusion: "exclusion";
+    hue: "hue";
+    saturation: "saturation";
+    color: "color";
+    luminosity: "luminosity";
+  }>>;
+}, z.core.$strip>;
+declare const VideoTimingPropsSchema: z.ZodObject<{
+  startFrame: z.ZodDefault<z.ZodNumber>;
+  durationInMS: z.ZodOptional<z.ZodNumber>;
+  trimStart: z.ZodOptional<z.ZodNumber>;
+  trimEnd: z.ZodOptional<z.ZodNumber>;
+  speed: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const VideoTextPropsSchema: z.ZodObject<{
+  text: z.ZodOptional<z.ZodString>;
+  fontSize: z.ZodOptional<z.ZodNumber>;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  fontStyle: z.ZodOptional<z.ZodString>;
+  fontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  fill: z.ZodOptional<z.ZodString>;
+  align: z.ZodOptional<z.ZodString>;
+  verticalAlign: z.ZodOptional<z.ZodString>;
+  letterSpacing: z.ZodOptional<z.ZodNumber>;
+  lineHeight: z.ZodOptional<z.ZodNumber>;
+  padding: z.ZodOptional<z.ZodNumber>;
+  stroke: z.ZodOptional<z.ZodString>;
+  strokeWidth: z.ZodOptional<z.ZodNumber>;
+  strokeAlign: z.ZodOptional<z.ZodEnum<{
+    inside: "inside";
+    center: "center";
+    outside: "outside";
+  }>>;
+  textShadow: z.ZodOptional<z.ZodString>;
+  textBackgroundColor: z.ZodOptional<z.ZodString>;
+  shadows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    color: z.ZodString;
+    offset: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    blurRadius: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>>;
+  textAnimation: z.ZodOptional<z.ZodAny>;
+  bottomPadding: z.ZodOptional<z.ZodNumber>;
+  maxWidth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const VideoStylePropsSchema: z.ZodObject<{
+  backgroundColor: z.ZodOptional<z.ZodString>;
+  borderColor: z.ZodOptional<z.ZodString>;
+  borderWidth: z.ZodOptional<z.ZodNumber>;
+  strokeRadius: z.ZodOptional<z.ZodNumber>;
+  autoDimensions: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const VideoLayerTypeSchema: z.ZodEnum<{
+  Text: "Text";
+  Image: "Image";
+  Video: "Video";
+  Audio: "Audio";
+  SVG: "SVG";
+  Caption: "Caption";
+  Lottie: "Lottie";
+  GIF: "GIF";
+}>;
+type VideoLayerType = z.infer<typeof VideoLayerTypeSchema>;
+declare const BaseVideoLayerPropsSchema: z.ZodObject<{
+  x: z.ZodDefault<z.ZodNumber>;
+  y: z.ZodDefault<z.ZodNumber>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  rotation: z.ZodDefault<z.ZodNumber>;
+  scale: z.ZodDefault<z.ZodNumber>;
+  opacity: z.ZodDefault<z.ZodNumber>;
+  zIndex: z.ZodOptional<z.ZodNumber>;
+  blendMode: z.ZodOptional<z.ZodEnum<{
+    "source-over": "source-over";
+    "source-in": "source-in";
+    "source-out": "source-out";
+    "source-atop": "source-atop";
+    "destination-over": "destination-over";
+    "destination-in": "destination-in";
+    "destination-out": "destination-out";
+    "destination-atop": "destination-atop";
+    lighter: "lighter";
+    copy: "copy";
+    xor: "xor";
+    multiply: "multiply";
+    screen: "screen";
+    overlay: "overlay";
+    darken: "darken";
+    lighten: "lighten";
+    "color-dodge": "color-dodge";
+    "color-burn": "color-burn";
+    "hard-light": "hard-light";
+    "soft-light": "soft-light";
+    difference: "difference";
+    exclusion: "exclusion";
+    hue: "hue";
+    saturation: "saturation";
+    color: "color";
+    luminosity: "luminosity";
+  }>>;
+  startFrame: z.ZodDefault<z.ZodNumber>;
+  durationInMS: z.ZodOptional<z.ZodNumber>;
+  trimStart: z.ZodOptional<z.ZodNumber>;
+  trimEnd: z.ZodOptional<z.ZodNumber>;
+  speed: z.ZodOptional<z.ZodNumber>;
+  text: z.ZodOptional<z.ZodString>;
+  fontSize: z.ZodOptional<z.ZodNumber>;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  fontStyle: z.ZodOptional<z.ZodString>;
+  fontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  fill: z.ZodOptional<z.ZodString>;
+  align: z.ZodOptional<z.ZodString>;
+  verticalAlign: z.ZodOptional<z.ZodString>;
+  letterSpacing: z.ZodOptional<z.ZodNumber>;
+  lineHeight: z.ZodOptional<z.ZodNumber>;
+  padding: z.ZodOptional<z.ZodNumber>;
+  stroke: z.ZodOptional<z.ZodString>;
+  strokeWidth: z.ZodOptional<z.ZodNumber>;
+  strokeAlign: z.ZodOptional<z.ZodEnum<{
+    inside: "inside";
+    center: "center";
+    outside: "outside";
+  }>>;
+  textShadow: z.ZodOptional<z.ZodString>;
+  textBackgroundColor: z.ZodOptional<z.ZodString>;
+  shadows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    color: z.ZodString;
+    offset: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    blurRadius: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>>;
+  textAnimation: z.ZodOptional<z.ZodAny>;
+  bottomPadding: z.ZodOptional<z.ZodNumber>;
+  maxWidth: z.ZodOptional<z.ZodNumber>;
+  backgroundColor: z.ZodOptional<z.ZodString>;
+  borderColor: z.ZodOptional<z.ZodString>;
+  borderWidth: z.ZodOptional<z.ZodNumber>;
+  strokeRadius: z.ZodOptional<z.ZodNumber>;
+  autoDimensions: z.ZodOptional<z.ZodBoolean>;
+  type: z.ZodOptional<z.ZodEnum<{
+    Text: "Text";
+    Image: "Image";
+    Video: "Video";
+    Audio: "Audio";
+    SVG: "SVG";
+    Caption: "Caption";
+    Lottie: "Lottie";
+    GIF: "GIF";
+  }>>;
+  animations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+      "fade-in": "fade-in";
+      "fade-out": "fade-out";
+      "slide-in-left": "slide-in-left";
+      "slide-in-right": "slide-in-right";
+      "slide-in-top": "slide-in-top";
+      "slide-in-bottom": "slide-in-bottom";
+      "zoom-in": "zoom-in";
+      "zoom-out": "zoom-out";
+      "rotate-cw": "rotate-cw";
+      "rotate-ccw": "rotate-ccw";
+      bounce: "bounce";
+      shake: "shake";
+    }>;
+    value: z.ZodNumber;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type BaseVideoLayerProps = z.infer<typeof BaseVideoLayerPropsSchema>;
+//#endregion
+//#region src/types/video/layer-schema.d.ts
+declare const ExtendedLayerSchema: z.ZodObject<{
+  x: z.ZodDefault<z.ZodNumber>;
+  y: z.ZodDefault<z.ZodNumber>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  rotation: z.ZodDefault<z.ZodNumber>;
+  scale: z.ZodDefault<z.ZodNumber>;
+  opacity: z.ZodDefault<z.ZodNumber>;
+  blendMode: z.ZodOptional<z.ZodEnum<{
+    "source-over": "source-over";
+    "source-in": "source-in";
+    "source-out": "source-out";
+    "source-atop": "source-atop";
+    "destination-over": "destination-over";
+    "destination-in": "destination-in";
+    "destination-out": "destination-out";
+    "destination-atop": "destination-atop";
+    lighter: "lighter";
+    copy: "copy";
+    xor: "xor";
+    multiply: "multiply";
+    screen: "screen";
+    overlay: "overlay";
+    darken: "darken";
+    lighten: "lighten";
+    "color-dodge": "color-dodge";
+    "color-burn": "color-burn";
+    "hard-light": "hard-light";
+    "soft-light": "soft-light";
+    difference: "difference";
+    exclusion: "exclusion";
+    hue: "hue";
+    saturation: "saturation";
+    color: "color";
+    luminosity: "luminosity";
+  }>>;
+  startFrame: z.ZodDefault<z.ZodNumber>;
+  trimStart: z.ZodOptional<z.ZodNumber>;
+  trimEnd: z.ZodOptional<z.ZodNumber>;
+  speed: z.ZodOptional<z.ZodNumber>;
+  text: z.ZodOptional<z.ZodString>;
+  fontSize: z.ZodOptional<z.ZodNumber>;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  fontStyle: z.ZodOptional<z.ZodString>;
+  fontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  fill: z.ZodOptional<z.ZodString>;
+  align: z.ZodOptional<z.ZodString>;
+  verticalAlign: z.ZodOptional<z.ZodString>;
+  letterSpacing: z.ZodOptional<z.ZodNumber>;
+  lineHeight: z.ZodOptional<z.ZodNumber>;
+  padding: z.ZodOptional<z.ZodNumber>;
+  stroke: z.ZodOptional<z.ZodString>;
+  strokeWidth: z.ZodOptional<z.ZodNumber>;
+  strokeAlign: z.ZodOptional<z.ZodEnum<{
+    inside: "inside";
+    center: "center";
+    outside: "outside";
+  }>>;
+  textShadow: z.ZodOptional<z.ZodString>;
+  textBackgroundColor: z.ZodOptional<z.ZodString>;
+  shadows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    color: z.ZodString;
+    offset: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    blurRadius: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>>;
+  textAnimation: z.ZodOptional<z.ZodAny>;
+  bottomPadding: z.ZodOptional<z.ZodNumber>;
+  maxWidth: z.ZodOptional<z.ZodNumber>;
+  backgroundColor: z.ZodOptional<z.ZodString>;
+  borderColor: z.ZodOptional<z.ZodString>;
+  borderWidth: z.ZodOptional<z.ZodNumber>;
+  strokeRadius: z.ZodOptional<z.ZodNumber>;
+  autoDimensions: z.ZodOptional<z.ZodBoolean>;
+  animations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+      "fade-in": "fade-in";
+      "fade-out": "fade-out";
+      "slide-in-left": "slide-in-left";
+      "slide-in-right": "slide-in-right";
+      "slide-in-top": "slide-in-top";
+      "slide-in-bottom": "slide-in-bottom";
+      "zoom-in": "zoom-in";
+      "zoom-out": "zoom-out";
+      "rotate-cw": "rotate-cw";
+      "rotate-ccw": "rotate-ccw";
+      bounce: "bounce";
+      shake: "shake";
+    }>;
+    value: z.ZodNumber;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  type: z.ZodEnum<{
+    Text: "Text";
+    Image: "Image";
+    Video: "Video";
+    Audio: "Audio";
+    SVG: "SVG";
+    Caption: "Caption";
+    Lottie: "Lottie";
+    GIF: "GIF";
+  }>;
+  virtualMedia: z.ZodOptional<z.ZodType<VirtualMediaData, unknown, z.core.$ZodTypeInternals<VirtualMediaData, unknown>>>;
+  transitionIn: z.ZodOptional<z.ZodObject<{
+    type: z.ZodEnum<{
+      none: "none";
+      crossfade: "crossfade";
+      "wipe-left": "wipe-left";
+      "wipe-right": "wipe-right";
+      "slide-up": "slide-up";
+      "slide-down": "slide-down";
+    }>;
+    durationFrames: z.ZodNumber;
+  }, z.core.$strip>>;
+  transitionOut: z.ZodOptional<z.ZodObject<{
+    type: z.ZodEnum<{
+      none: "none";
+      crossfade: "crossfade";
+      "wipe-left": "wipe-left";
+      "wipe-right": "wipe-right";
+      "slide-up": "slide-up";
+      "slide-down": "slide-down";
+    }>;
+    durationFrames: z.ZodNumber;
+  }, z.core.$strip>>;
+  durationInMS: z.ZodNumber;
+  maxDurationInMS: z.ZodOptional<z.ZodNumber>;
+  src: z.ZodOptional<z.ZodString>;
+  volume: z.ZodDefault<z.ZodNumber>;
+  inputHandleId: z.ZodOptional<z.ZodString>;
+  isPlaceholder: z.ZodOptional<z.ZodBoolean>;
+  lockAspect: z.ZodOptional<z.ZodBoolean>;
+  lockRatio: z.ZodOptional<z.ZodBoolean>;
+  zIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type ExtendedLayer = z.infer<typeof ExtendedLayerSchema>;
+//#endregion
+//#region src/types/video/rendering-defaults.d.ts
+declare const DEFAULT_FPS = 60;
+declare const DEFAULT_DURATION_MS = 3000;
+declare const DEFAULT_MEDIA_DIMENSION = 1080;
+/** Default styling applied to new Text layers. */
+declare const TEXT_LAYER_DEFAULTS: Partial<ExtendedLayer>;
+/** Default styling applied to new Caption layers. */
+declare const CAPTION_LAYER_DEFAULTS: Partial<ExtendedLayer>;
+//#endregion
+//#region src/types/video/resolve-media.d.ts
+type MediaSourceDescriptor = {
+  url?: string;
+  path?: string;
+  width?: number;
+  height?: number;
+  durationMs?: number;
+  fps?: number;
+  mimeType?: string;
+  sampleRate?: number;
+  channels?: number;
+  bitDepth?: number;
+  audioCodec?: string;
+  audioBitrate?: number;
+  entity?: any;
+};
+type MediaSourceInput = VirtualMediaData | string | MediaSourceDescriptor | FileData;
+/**
+ * Identify the actual leaf media type (Video, Image, etc) by walking down the tree.
+ * This can differ from getMediaType() if an operation (like Ken Burns) upgrades
+ * an Image to a Video.
+ */
+declare function getLeafMediaType(vv: VirtualMediaData | undefined | null): DataType | undefined;
+/**
+ * Resolve the MIME type of the leaf source media.
+ */
+declare function resolveMediaMimeType(vv: VirtualMediaData | undefined | null): string | undefined;
+/**
+ * Create a VirtualMediaData from a FileData source or Text.
+ * Used by Import, VideoGen, and Text nodes to wrap concrete content.
+ */
+declare function createVirtualMedia(source: MediaSourceInput, type?: DataType): VirtualMediaData;
+/**
+ * Identify if a VirtualMediaData node is intended to be Video, Audio, Image, or Text.
+ */
+declare function getMediaType(vv: VirtualMediaData): DataType;
+/**
+ * Append an operation to an existing VirtualMediaData (recursive).
+ * This creates a new parent node wrapping the current one as a child.
+ */
+declare function appendOperation(vv: VirtualMediaData, operation: MediaOperation): VirtualMediaData;
+declare function getFileDataMetadata(filedata: {
+  entity?: {
+    width?: number | null;
+    height?: number | null;
+    duration?: number | null;
+    fps?: number | null;
+    mimeType?: string | null;
+    sampleRate?: number | null;
+    channels?: number | null;
+    bitDepth?: number | null;
+    audioCodec?: string | null;
+    audioBitrate?: number | null;
+    name?: string | null;
+  };
+} | null | undefined): MediaMetadata | null;
+/**
+ * Get the active metadata from the VirtualMediaData node.
+ * Simply returns the metadata property of the node.
+ * Supports legacy formats (sourceMeta) and extracts from source if needed.
+ */
+declare function getActiveMediaMetadata(vv: VirtualMediaData | undefined | null): MediaMetadata | null;
+/**
+ * Compute the dimensions and offsets for rendering a cropped video.
+ * Traverses the VirtualMediaData tree to find nested crops and source dimensions.
+ */
+declare function computeVideoCropRenderProps(virtualMedia: VirtualMediaData): {
+  videoNaturalWidth: number;
+  videoNaturalHeight: number;
+  cropTranslatePercentageX: number;
+  cropTranslatePercentageY: number;
+} | null;
+//#endregion
+//#region src/types/video/transition-schema.d.ts
+declare const TransitionTypeSchema: z.ZodEnum<{
+  none: "none";
+  crossfade: "crossfade";
+  "wipe-left": "wipe-left";
+  "wipe-right": "wipe-right";
+  "slide-up": "slide-up";
+  "slide-down": "slide-down";
+}>;
+declare const TransitionSchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    none: "none";
+    crossfade: "crossfade";
+    "wipe-left": "wipe-left";
+    "wipe-right": "wipe-right";
+    "slide-up": "slide-up";
+    "slide-down": "slide-down";
+  }>;
+  durationFrames: z.ZodNumber;
+}, z.core.$strip>;
+type TransitionType = z.infer<typeof TransitionTypeSchema>;
+type Transition = z.infer<typeof TransitionSchema>;
+//#endregion
+//#region src/utils/is-equal.d.ts
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ * Handles primitives, objects, arrays, Dates, and NaNs.
+ */
+declare function isEqual(a: any, b: any): boolean;
+//#endregion
+//#region src/utils/result-cache.d.ts
+/**
+ * Checks if a cached node result can be reused based on source fingerprint.
+ * Returns the valid cached result, or null if the cache is stale.
+ */
+declare function checkNodeResultCache<T extends {
+  sourceFingerprint?: string;
+}>(currentResult: T | undefined | null, input: unknown): T | null;
+/**
+ * Creates a fresh result with a source fingerprint stamp.
+ */
+declare function stampResult<T>(result: T, input: unknown): T & {
+  sourceFingerprint: string;
+};
+//#endregion
+//#region src/utils/svg.d.ts
+/**
+ * Attempts to parse the width and height of an SVG from its buffer.
+ * Falls back to viewBox ratios if explicitly defined sizes are missing.
+ */
+declare function extractSvgDimensions(buffer: Buffer): {
+  w: number;
+  h: number;
+} | null;
+//#endregion
+//#region src/utils/virtual-media.d.ts
+/**
+ * Generates a fingerprint for the given data.
+ */
+declare function getFingerprint(data: unknown): string;
+/**
+ * Generates a version-aware fingerprint for render caching.
+ * Includes app version so cached renders are invalidated on version bumps.
+ */
+declare function getRenderFingerprint(data: unknown, appVersion: string, extra?: Record<string, unknown>): string;
+/**
+ * Checks if data is VirtualMediaData.
+ */
+declare function isVirtualMediaData(data: any): data is VirtualMediaData;
+/**
+ * Checks if the virtual media is just a raw source without any significant operations
+ * that would require a rendering step (like transformations, trimming, or effects).
+ */
+declare function hasOnlySingleSource(data: any): boolean;
+/**
+ * Finds the source asset in a virtual media tree.
+ */
+declare function findSourceAsset(vm: VirtualMediaData): FileData | null;
+//#endregion
+//#endregion
+//#region ../webgpu-renderers/dist/index.d.mts
+interface CachedPipelineAndState {
+  pipeline: GPUComputePipeline;
+  stateBuffer: GPUBuffer;
+  activeSignalsKey: string;
+  inputBuffer?: GPUBuffer;
+  outputBuffer?: GPUBuffer;
+  uniformBuffer?: GPUBuffer;
+  allocatedSamples?: number;
+  allocatedChannels?: number;
+  allocatedUniformsFloatCount?: number;
+  _reverbStateInitialized?: boolean;
+}
+declare class WebGPUAudioProcessor {
+  private static devicePipelineCache;
+  private static getDeviceCache;
+  static getCache(device: GPUDevice, renderId: string | undefined, nodeId: string, activeSignalsKey?: string, stateFloatCount?: number): CachedPipelineAndState | undefined;
+  static clearCache(renderId: string, device?: GPUDevice): void;
+  static process(device: GPUDevice, nodeId: string, channels: Float32Array[], _sampleRate: number, virtualMedia: VirtualMediaData, frame: number, fps: number, shaderTemplate: (params: {
+    customSignalWGSL: string;
+    makeupGainModulation: string;
+  }) => string, getUniforms: (t: number) => number[], uniformsFloatCount: number, stateFloatCount?: number, renderId?: string, isStatic?: boolean, elapsedMs?: number, durationMs?: number, initialState?: Float32Array, stateUpdate?: Float32Array, paramOrder?: string[]): Promise<void>;
+}
+//#endregion
+//#region src/audio/audio-latent-engine.d.ts
+/**
+ * @file audio-latent-engine.ts
+ * Real-time Audio Latent & Spectral Vector Engine for 3D Mesh Deformation.
+ * Implements 2048-point Hann-windowed Radix-2 STFT, 1024-band frequency spectrum calculation,
+ * multi-band latent energy extraction (bass, drum transient flux, vocal formant),
+ * and WebGPU AudioLatentBuffer storage packing.
+ */
+interface AudioLatentData {
+  /** 1024 positive frequency bin magnitudes [0, 1023] normalized */
+  fftBins: Float32Array;
+  /** Normalized low-frequency energy (20 - 150 Hz sub-bass / kick envelope) */
+  bassEnergy: number;
+  /** Percussive transient attack / spectral flux delta */
+  drumTransient: number;
+  /** Mid-frequency speech / melody formant presence (300 - 3400 Hz) */
+  vocalEnergy: number;
+  /** Frame timestamp in milliseconds */
+  timeMs: number;
+}
+/**
+ * Fast Audio Latent and Spectral Vector Processor.
+ */
+declare class AudioLatentEngine {
+  private tempReal;
+  private tempImag;
+  private previousBins;
+  /**
+   * Extracts 1024-band FFT and audio latent energies at a specific playback time.
+   */
+  extractAtTime(channels: Float32Array[], sampleRate: number, timeSec: number): AudioLatentData;
+  /**
+   * Packs AudioLatentData into a Float32Array suitable for WebGPU storage buffer upload.
+   * Struct layout:
+   *  0..1023: fftBins (array<f32, 1024>)
+   *  1024:    bassEnergy
+   *  1025:    drumTransient
+   *  1026:    vocalEnergy
+   *  1027:    timeMs
+   */
+  static packBufferData(data: AudioLatentData): Float32Array;
+  /**
+   * Creates a WebGPU GPUBuffer initialized with AudioLatentData.
+   */
+  static createGpuBuffer(device: GPUDevice, data?: AudioLatentData): GPUBuffer;
+  /**
+   * Updates an existing WebGPU AudioLatentBuffer with new frame data.
+   */
+  static updateGpuBuffer(device: GPUDevice, buffer: GPUBuffer, data: AudioLatentData): void;
+}
+/**
+ * Cache for a full audio track timeline providing O(1) frame lookup during video rendering.
+ */
+declare class AudioLatentTrackCache {
+  readonly channels: Float32Array[];
+  readonly sampleRate: number;
+  readonly fps: number;
+  readonly totalFrames: number;
+  private frames;
+  private gpuBuffers;
+  constructor(channels: Float32Array[], sampleRate: number, fps: number, totalFrames: number);
+  getFrameData(frame: number): AudioLatentData;
+  getGpuBuffer(device: GPUDevice, frame: number): GPUBuffer;
+}
+//#endregion
+//#region src/renderer2d/transform-stack.d.ts
+declare class TransformStack {
+  private stack;
+  push(matrix: DOMMatrix): void;
+  pop(): void;
+  getCurrent(): DOMMatrix;
+  packIntoBuffer(bufferData: Float32Array, opacity: number, surfaceWidth: number, surfaceHeight: number, localOverride?: DOMMatrix, customParam?: number): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/slug/slug-loader.d.ts
+interface SlugCodePoint {
+  codePoint: number;
+  width: number;
+  height: number;
+  advanceWidth: number;
+  bearingX: number;
+  bearingY: number;
+  bandCount: number;
+  bandDimX: number;
+  bandDimY: number;
+  bandsTexCoordX: number;
+  bandsTexCoordY: number;
+}
+interface SlugFont {
+  codePoints: Map<number, SlugCodePoint>;
+  curvesTex: GPUTexture;
+  bandsTex: GPUTexture;
+  ascender: number;
+  descender: number;
+  lineGap: number;
+  unitsPerEm: number;
+  fontFamily?: string;
+  hasTrueWeight?: boolean;
+  weight?: number;
+}
+//#endregion
+//#region src/slug/slug-pipeline.d.ts
+/** The glyphs one Slug draw would have issued, kept to be drawn elsewhere. */
+interface SlugGlyphBatch {
+  font: SlugFont;
+  /** 24 floats per glyph, as the Slug vertex shaders read them */
+  instances: Float32Array;
+  instanceCount: number;
+  opacity: number;
+  /** Synthetic italic shear */
+  slant: number;
+  /** Paragraph space to target pixels, as the 2D affine [a, b, c, d, e, f] */
+  transform: [number, number, number, number, number, number];
+}
+declare class SlugPipeline {
+  private device;
+  private pipeline;
+  private uniformLayout;
+  private textureLayout;
+  private uniformPool;
+  private instancePool;
+  private uniformBindGroupCache;
+  private uniformData;
+  private captured;
+  constructor(device: GPUDevice, format: GPUTextureFormat);
+  resetPools(): void;
+  /**
+   * Record glyph draws instead of issuing them, until endCapture: a 3D text
+   * layer hands its glyphs to the 3D pass rather than rasterizing them.
+   */
+  beginCapture(): void;
+  endCapture(): SlugGlyphBatch[];
+  draw(pass: GPURenderPassEncoder, transformStack: TransformStack, font: SlugFont, instanceData: Float32Array, instanceCount: number, _color: Color | string, surfaceWidth: number, surfaceHeight: number, opts?: DrawOpts): void;
+  /** Draw captured batches into a 2D pass, with the transforms they were captured under. */
+  drawBatches(pass: GPURenderPassEncoder, batches: SlugGlyphBatch[], surfaceWidth: number, surfaceHeight: number): void;
+  private encode;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/bind-group-cache.d.ts
+declare class BindGroupCache {
+  private cache;
+  private dualCache;
+  getBindGroup(device: GPUDevice, layout: GPUBindGroupLayout, texture: GPUTexture, sampler: GPUSampler): GPUBindGroup;
+  getCompositeBindGroup(device: GPUDevice, layout: GPUBindGroupLayout, baseTexture: GPUTexture, overlayTexture: GPUTexture, sampler: GPUSampler): GPUBindGroup;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/clip-stack.d.ts
+interface ScissorEntry {
+  rect: Rect;
+  surfaceWidth?: number;
+  surfaceHeight?: number;
+}
+//#endregion
+//#region src/renderer2d/sampler-cache.d.ts
+interface SamplerDescriptor {
+  magFilter?: GPUFilterMode;
+  minFilter?: GPUFilterMode;
+  mipmapFilter?: GPUMipmapFilterMode;
+  addressModeU?: GPUAddressMode;
+  addressModeV?: GPUAddressMode;
+  maxAnisotropy?: number;
+}
+declare class SamplerCache {
+  private samplers;
+  private lru;
+  private maxCapacity;
+  constructor(maxCapacity?: number);
+  getSampler(device: GPUDevice, desc?: SamplerDescriptor): GPUSampler;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/effect-pipeline.d.ts
+declare class EffectPipeline {
+  private device;
+  private compositeUniformLayout;
+  private dualTextureLayout;
+  private motionBlurUniformLayout;
+  private singleTextureLayout;
+  private compositePipeline;
+  private motionBlurPipeline;
+  private compositePool;
+  private motionBlurPool;
+  private texturePool;
+  private compositeUniformBindGroupCache;
+  private motionBlurUniformBindGroupCache;
+  private compositeData;
+  private motionBlurData;
+  constructor(device: GPUDevice, format: GPUTextureFormat);
+  resetPools(): void;
+  getTexture(device: GPUDevice, width: number, height: number, format: GPUTextureFormat, exclude?: GPUTexture | GPUTexture[]): GPUTexture;
+  getBuffer(device: GPUDevice, data: ArrayBufferView): GPUBuffer;
+  composite(encoder: GPUCommandEncoder, bindGroupCache: BindGroupCache, samplerCache: SamplerCache, baseTex: GPUTexture, overlayTex: GPUTexture, mode: BlendMode, format: GPUTextureFormat, exclude?: GPUTexture | GPUTexture[]): GPUTexture;
+  applyMotionBlur(encoder: GPUCommandEncoder, bindGroupCache: BindGroupCache, samplerCache: SamplerCache, sourceTex: GPUTexture, vx: number, vy: number, shutterAngle: number | undefined, samples: number | undefined, format: GPUTextureFormat, exclude?: GPUTexture | GPUTexture[]): GPUTexture;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/path-geometry.d.ts
+interface Point {
+  x: number;
+  y: number;
+}
+interface PathSegment {
+  p0: Point;
+  p1: Point;
+}
+/**
+ * Sample a cubic bezier curve into linear segments.
+ */
+
+type ShapeType = "rect" | "circle" | "ellipse" | "polygon" | "star" | "arrow" | "path";
+interface ShapeGeometryConfig {
+  shapeType: ShapeType;
+  width: number;
+  height: number;
+  path?: string;
+  cornerRadius?: number;
+  starPoints?: number;
+  starInnerRadiusRatio?: number;
+  polygonSides?: number;
+  arrowHeadWidth?: number;
+  arrowHeadLength?: number;
+  arrowShaftWidth?: number;
+}
+//#endregion
+//#region src/renderer2d/path-pipeline.d.ts
+interface PathDrawOpts extends DrawOpts {
+  trimStart?: number;
+  trimEnd?: number;
+  trimOffset?: number;
+  strokeLineCap?: "round" | "butt" | "square";
+  strokeDashArray?: number[];
+  strokeDashOffset?: number;
+}
+declare class PathPipeline {
+  private device;
+  private pipeline;
+  private maxPipeline;
+  private uniformLayout;
+  private uniformPool;
+  private vertexPool;
+  private uniformBindGroupCache;
+  private scratchData;
+  constructor(device: GPUDevice, format: GPUTextureFormat);
+  resetPools(): void;
+  drawPath(pass: GPURenderPassEncoder, transformStack: TransformStack, pathStr: string, color: Color | string, strokeWidth: number, surfaceWidth: number, surfaceHeight: number, opts?: PathDrawOpts): void;
+  drawSegments(pass: GPURenderPassEncoder, transformStack: TransformStack, segments: PathSegment[], color: Color | string, strokeWidth: number, surfaceWidth: number, surfaceHeight: number, opts?: PathDrawOpts): void;
+  private drawSegment;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/quad-pipeline.d.ts
+declare class QuadPipeline {
+  private device;
+  private pipeline;
+  private uniformLayout;
+  private textureLayout;
+  private uniformPool;
+  private vertexPool;
+  private uniformBindGroupCache;
+  private uniformData;
+  private vertexData;
+  constructor(device: GPUDevice, format: GPUTextureFormat);
+  resetPools(): void;
+  draw(pass: GPURenderPassEncoder, bindGroupCache: BindGroupCache, transformStack: TransformStack, texture: GPUTexture, sampler: GPUSampler, src: Rect, dst: Rect, surfaceWidth: number, surfaceHeight: number, opts?: DrawOpts): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/shape-fill-pipeline.d.ts
+type ShapeFillType = "solid" | "linear" | "radial" | "none";
+interface ShapeFillConfig {
+  type?: ShapeFillType;
+  color?: Color | string;
+  color2?: Color | string;
+  startX?: number;
+  startY?: number;
+  endX?: number;
+  endY?: number;
+  cx?: number;
+  cy?: number;
+  radius?: number;
+}
+declare class ShapeFillPipeline {
+  private device;
+  private pipeline;
+  private uniformLayout;
+  private uniformPool;
+  private vertexPool;
+  private uniformData;
+  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;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/solid-pipeline.d.ts
+declare class SolidPipeline {
+  private device;
+  private pipeline;
+  private uniformLayout;
+  private uniformPool;
+  private vertexPool;
+  private uniformBindGroupCache;
+  private uniformData;
+  private vertexData;
+  constructor(device: GPUDevice, format: GPUTextureFormat);
+  resetPools(): void;
+  draw(pass: GPURenderPassEncoder, transformStack: TransformStack, rect: Rect, color: Color | string, surfaceWidth: number, surfaceHeight: number, cornerRadius?: number, opts?: DrawOpts): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer2d/index.d.ts
+interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface RRect {
+  rect: Rect;
+  rx: number;
+  ry: number;
+}
+interface Color {
+  r: number;
+  g: number;
+  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";
+interface DrawOpts {
+  opacity?: number;
+  blendMode?: GPUBlendFactor | BlendMode;
+  transform?: DOMMatrix;
+  customParam?: number;
+}
+interface ClipPath {
+  path: string;
+}
+declare class Renderer2D {
+  private device;
+  private transformStack;
+  private clipStack;
+  quadPipeline: QuadPipeline;
+  solidPipeline: SolidPipeline;
+  shapeFillPipeline: ShapeFillPipeline;
+  pathPipeline: PathPipeline;
+  effectPipeline: EffectPipeline;
+  slugPipeline: SlugPipeline;
+  bindGroupCache: BindGroupCache;
+  samplerCache: SamplerCache;
+  format: GPUTextureFormat;
+  isDestroyed: boolean;
+  /**
+   * Non-glyph draws issued so far. A 3D text layer compares it across its
+   * content to learn whether anything besides captured glyphs (a backdrop,
+   * an emoji) landed in its texture.
+   */
+  rasterDrawCount: number;
+  private surfaceWidth;
+  private surfaceHeight;
+  private lastEncoder;
+  constructor(device: GPUDevice, format: GPUTextureFormat);
+  beginFrame(encoder: GPUCommandEncoder, targetView: GPUTextureView, clearColor: GPUColor | undefined, surfaceWidth: number, surfaceHeight: number, loadOp?: GPULoadOp): GPURenderPassEncoder;
+  endFrame(_encoder: GPUCommandEncoder): void;
+  resetPools(): void;
+  drawTexture(pass: GPURenderPassEncoder, tex: GPUTexture, dst: Rect, opts?: DrawOpts): void;
+  drawTextureRegion(pass: GPURenderPassEncoder, tex: GPUTexture, src: Rect, dst: Rect, opts?: DrawOpts): void;
+  drawRect(pass: GPURenderPassEncoder, rect: Rect, color: Color | string, cornerRadius?: number | DrawOpts, opts?: DrawOpts): void;
+  drawPath(pass: GPURenderPassEncoder, pathStr: string, color: Color | string, strokeWidth: number, opts?: PathDrawOpts): void;
+  drawShapeFill(pass: GPURenderPassEncoder, vertices: Float32Array, fill: ShapeFillConfig, bounds: Rect, opts?: DrawOpts): void;
+  drawShape(pass: GPURenderPassEncoder, config: ShapeGeometryConfig, fill?: ShapeFillConfig, stroke?: {
+    color?: Color | string;
+    width?: number;
+    cap?: "round" | "butt" | "square";
+    trimStart?: number;
+    trimEnd?: number;
+    trimOffset?: number;
+    dashArray?: number[];
+    dashOffset?: number;
+  }, opts?: DrawOpts): void;
+  drawRRect(pass: GPURenderPassEncoder, rrect: RRect, color: Color | string, opts?: DrawOpts): void;
+  getTemporaryTexture(width: number, height: number, exclude?: GPUTexture | GPUTexture[]): GPUTexture;
+  getTemporaryBuffer(data: ArrayBufferView): GPUBuffer;
+  composite(encoder: GPUCommandEncoder, base: GPUTexture, overlay: GPUTexture, mode: BlendMode, exclude?: GPUTexture | GPUTexture[]): GPUTexture;
+  applyMotionBlur(encoder: GPUCommandEncoder, sourceTex: GPUTexture, vx: number, vy: number, shutterAngle?: number, samples?: number, exclude?: GPUTexture | GPUTexture[]): GPUTexture;
+  getCurrentTransform(): DOMMatrix;
+  getTransformStack(): TransformStack;
+  getSurfaceWidth(): number;
+  getSurfaceHeight(): number;
+  pushIdentity(): void;
+  pushTransform(matrix: DOMMatrix): void;
+  popTransform(): void;
+  pushScissor(rect: Rect): void;
+  pushScissorLocal(rect: Rect): void;
+  popScissor(): void;
+  suspendScissors(): ScissorEntry[];
+  resumeScissors(saved: ScissorEntry[]): void;
+  pushStencilClip(path: ClipPath): void;
+  popStencilClip(): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/color.d.ts
+/**
+ * Parse any CSS color string into a normalized {r,g,b,a} Color
+ * with channel values in [0,1].
+ *
+ * Supports:
+ * - Hex: #RGB, #RGBA, #RRGGBB, #RRGGBBAA
+ * - Functional: rgb(r,g,b), rgba(r,g,b,a)
+ * - Named: black, white, red, green, blue, yellow, transparent, etc.
+ * - Color objects pass through unchanged.
+ *
+ * Returns `{ r: 0, g: 0, b: 0, a: 0 }` (transparent black) for
+ * null/undefined/unrecognised input.
+ */
+
+declare const ensureDevice: (opts?: GPURequestAdapterOptions) => Promise<GPUDevice>;
+//#endregion
+//#region src/headless/init.d.ts
+declare function initHeadlessWebGPU(): Promise<void>;
+//#endregion
+//#region src/headless-font-loader.d.ts
+
+//#endregion
+//#region src/input-store.d.ts
+declare class InputStore {
+  private store;
+  acquire(url: string): Promise<Input>;
+  release(url: string): void;
+}
+declare const inputStore: InputStore;
+//#endregion
+//#region src/lut-store.d.ts
+interface GPUModelLut {
+  texture: GPUTexture;
+  type: "1D" | "3D";
+  size: number;
+  vertexBuffer: GPUBuffer;
+  vertexCount: number;
+}
+interface RawLutData {
+  points: Array<[number, number, number]>;
+  size: number;
+  type: "1D" | "3D";
+}
+declare class LutStore {
+  private deviceCaches;
+  private devicePromises;
+  private rawDataCache;
+  private rawDataPromises;
+  private listeners;
+  onChange(listener: (key: string) => void): () => void;
+  private emit;
+  getAnyMatching(prefix: string, device: GPUDevice): GPUModelLut | undefined;
+  private getOrCreateRawDataPromise;
+  rejectRawDataPromise(key: string, error: any): void;
+  private getCache;
+  private getPromises;
+  get(key: string, device: GPUDevice): GPUModelLut | undefined;
+  set(key: string, device: GPUDevice, lut: GPUModelLut): void;
+  /** Get cached raw (device-independent) data for a key. */
+  getRawData(key: string): RawLutData | undefined;
+  /** Get any available raw LUT data from cache. */
+  getAnyRawData(): RawLutData | undefined;
+  createOrUpdate(key: string, device: GPUDevice, points: Array<[number, number, number]>, size: number, type: "1D" | "3D"): GPUModelLut;
+  getOrLoad(src: string, device: GPUDevice, signal?: AbortSignal): Promise<GPUModelLut>;
+  evict(key: string, device: GPUDevice): void;
+  hasPending(device: GPUDevice): boolean;
+  awaitAllPending(device: GPUDevice): Promise<void>;
+  destroy(): void;
+}
+declare const lutStore: LutStore;
+//#endregion
+//#region src/surface-provider.d.ts
+interface SurfaceProvider {
+  readonly width: number;
+  readonly height: number;
+  readonly colorFormat: GPUTextureFormat;
+  /** Current frame's render target view */
+  getCurrentTextureView(): GPUTextureView;
+  /** Current frame's render target texture */
+  getCurrentTexture(): GPUTexture;
+  /** Present / flush the frame (browser: swap chain; node: no-op) */
+  present(): void;
+  /** Read RGBA pixels back to CPU (node: staging buffer; browser: copyToBuffer) */
+  readPixels(): Promise<Uint8ClampedArray>;
+  destroy(): void;
+}
+//#endregion
+//#region src/render-context.d.ts
+interface RenderContextValue {
+  device: GPUDevice;
+  renderer: Renderer2D;
+  surface: SurfaceProvider;
+}
+//#endregion
+//#region src/text-animations/advanced-types.d.ts
+
+//#endregion
+//#region src/shader-store.d.ts
+interface RegisteredShader {
+  wgsl: string;
+  name: string;
+  outputType: string;
+  fnParams: Array<{
+    name: string;
+    type: string;
+    defaultValue: number;
+  }>;
+}
+declare class ShaderStore {
+  private store;
+  private getCacheKey;
+  register(nodeId: string, shader: RegisteredShader, renderId?: string): void;
+  get(nodeId: string, renderId?: string): RegisteredShader | undefined;
+  delete(nodeId: string, renderId?: string): void;
+  clear(renderId: string): void;
+  registerSignalsFromComposition(renderId: string | undefined, virtualMedia: VirtualMediaData): void;
+}
+declare const shaderStore: ShaderStore;
+//#endregion
+//#region src/shaders/audio-mesh-displace.d.ts
+/**
+ * @file audio-mesh-displace.ts
+ * WGSL compute shader for audio FFT & latent vector 3D mesh vertex displacement.
+ * Processes 16-float (64-byte) vertex streams in parallel at 256 threads per workgroup.
+ */
+
+//#endregion
+//#region src/signals/audio-signal-compute.d.ts
+interface AudioSignalComputeConfig {
+  extractionMode?: "rms_envelope" | "transient_beat" | "sub_bass" | "bass" | "mid" | "high" | "spectral_flux";
+  attackMs?: number;
+  releaseMs?: number;
+  sensitivity?: number;
+  noiseFloorDb?: number;
+  dynamicRangeDb?: number;
+  autoRange?: boolean;
+  smoothing?: number;
+  curve?: "linear" | "exponential" | "logarithmic" | "square" | "smoothstep";
+  beatThreshold?: number;
+  beatDecayMs?: number;
+}
+interface ExtractedSignalStats {
+  primary: {
+    min: number;
+    max: number;
+  };
+  beat: {
+    min: number;
+    max: number;
+  };
+  bass: {
+    min: number;
+    max: number;
+  };
+  energy: {
+    min: number;
+    max: number;
+  };
+}
+interface ExtractedAudioSignals {
+  primaryBuffer: GPUBuffer;
+  beatBuffer: GPUBuffer;
+  bassBuffer: GPUBuffer;
+  energyBuffer: GPUBuffer;
+  texture: GPUTexture;
+  textureView: GPUTextureView;
+  numFrames: number;
+  durationSec: number;
+  stats: ExtractedSignalStats;
+  channelSamples?: {
+    primary: Float32Array;
+    beat: Float32Array;
+    bass: Float32Array;
+    energy: Float32Array;
+  };
+}
+/**
+ * 1. Biquad IIR Filter Bank Compute Shader
+ * Applies resonant bandpass/lowpass/highpass filtering on PCM audio buffer.
+ */
+
+declare class AudioSignalComputePipeline {
+  private static pipelineCache;
+  private static getPipeline;
+  /**
+   * Processes raw PCM audio channels on the GPU and outputs extracted feature buffers and textures.
+   */
+  static extractFeatures(device: GPUDevice, audioChannels: Float32Array[], sampleRate: number, fps: number, config?: AudioSignalComputeConfig, targetWidth?: number): Promise<ExtractedAudioSignals>;
+  /**
+   * Computes cumulative speed-ramped presentation timestamps for video pace control.
+   */
+  static computePaceTimestamps(device: GPUDevice, signalBuffer: GPUBuffer, numFrames: number, fps: number, baseSpeed?: number, gain?: number): GPUBuffer;
+}
+//#endregion
+//#region src/signals/signal-registry.d.ts
+interface SignalRegistryResource {
+  type: "1d-buffer" | "2d-texture" | "combined";
+  buffer?: GPUBuffer;
+  texture?: GPUTexture;
+  textureView?: GPUTextureView;
+  lastProcessedFrame: number;
+  lastFingerprint?: string;
+  uniformBuffer?: GPUBuffer;
+  bindGroup?: GPUBindGroup;
+  isExternal?: boolean;
+  duration?: number;
+  stats?: {
+    min: number;
+    max: number;
+  };
+}
+interface MasterAudioEntry {
+  texture: GPUTexture;
+  textureView: GPUTextureView;
+  durationSec: number;
+  stats: {
+    min: number;
+    max: number;
+  };
+  lastFingerprint?: string;
+}
+declare class SignalRegistry {
+  private deviceCache;
+  private statsMap;
+  private statsListeners;
+  setStats(nodeId: string, stats: {
+    min: number;
+    max: number;
+  }): void;
+  getStats(nodeId: string): {
+    min: number;
+    max: number;
+  } | undefined;
+  onStats(nodeId: string, listener: (stats: {
+    min: number;
+    max: number;
+  }) => void): () => void;
+  /**
+   * Recursively computes a deterministic cache fingerprint for a signal descriptor
+   * and its upstream dependencies (signalA, signalB, and upstream calculated stats).
+   */
+  computeSignalFingerprint(sd: unknown, depth?: number, visited?: Set<unknown>): string;
+  private getDeviceResources;
+  getSampler(device: GPUDevice): GPUSampler;
+  /**
+   * Clears frame resources. Typically called on renderId reset or context destruction.
+   */
+  clear(renderId: string, device?: GPUDevice): void;
+  getDummy1x1TextureView(device: GPUDevice): GPUTextureView;
+  getDummyBuffer(device: GPUDevice): GPUBuffer;
+  registerBuffer(device: GPUDevice, nodeId: string, buffer: GPUBuffer, renderId?: string): void;
+  registerTexture(device: GPUDevice, nodeId: string, texture: GPUTexture, textureView: GPUTextureView, renderId?: string, duration?: number): void;
+  getMasterTextureView(device: GPUDevice, nodeId: string, renderId?: string): GPUTextureView | undefined;
+  getMasterTexture(device: GPUDevice, nodeId: string, renderId?: string): GPUTexture | undefined;
+  private channelSamplesMap;
+  setChannelSamples(nodeId: string, samples: {
+    primary?: Float32Array;
+    beat?: Float32Array;
+    bass?: Float32Array;
+    energy?: Float32Array;
+  }, renderId?: string): void;
+  getChannelSamples(nodeId: string, channel?: string, renderId?: string): Float32Array | undefined;
+  getDuration(device: GPUDevice, nodeId: string, renderId?: string): number | undefined;
+  private extractionPromises;
+  has(device: GPUDevice, nodeId: string, renderId?: string): boolean;
+  /**
+   * Recursively scans a signal descriptor (and upstream signalA/signalB trees)
+   * for any audio sources and ensures they have been decoded and extracted.
+   */
+  ensureAudioSourcesExtracted(device: GPUDevice, sd: unknown, fps?: number, renderId?: string, visited?: Set<unknown>): Promise<void>;
+  extractFromAudioSource(device: GPUDevice, sourceUrl: string, config: AudioSignalComputeConfig | undefined, nodeId: string, fps?: number, renderId?: string): Promise<void>;
+  /**
+   * Resolves or creates a 1D GPUBuffer for a time-varying signal.
+   * If not evaluated yet for the current frame, it dispatches the generator compute pass.
+   */
+  getOrCreate1DBuffer(device: GPUDevice, _encoder: GPUCommandEncoder | null, nodeId: string, elapsedTime: number, duration: number, sd: any, numSamples: number, sampleRate: number, renderId?: string, frame?: number, fps?: number): GPUBuffer;
+  /**
+   * Resolves or creates a 2D GPUTextureView for spatial modulation.
+   * If not evaluated yet for the current frame, it dispatches the generator render pass.
+   */
+  getOrCreate2DTextureView(device: GPUDevice, _encoder: GPUCommandEncoder | null, nodeId: string, elapsedTime: number, duration: number, sd: any, width: number, _height: number, renderId?: string, frame?: number, fps?: number): GPUTextureView;
+  private dispatch1DGenerator;
+  private dispatch1DAudioSignal;
+  private dispatch1DMathSignal;
+  private dispatch2DGenerator;
+  private dispatch2DAudioSignal;
+  private dispatch2DSignalMath;
+  private dispatch2DSignalGate;
+  private dispatch1DGateSignal;
+}
+declare const signalRegistry: SignalRegistry;
+//#endregion
+//#region src/signals/types.d.ts
+type WGSLOutputType = "f32" | "vec2f" | "vec3f" | "vec4f";
+type WGSLParamType = "f32" | "i32" | "u32" | "vec2f" | "vec3f" | "vec4f";
+interface FnParam {
+  name: string;
+  type: WGSLParamType;
+  defaultValue: number;
+}
+type EasingFamily = "linear" | "sine" | "quad" | "cubic" | "quart" | "quint" | "expo" | "circ" | "back" | "elastic" | "bounce" | "smoothstep" | "smootherstep";
+type EasingMode = "in" | "out" | "in_out";
+type EnvelopePattern = "ramp_up" | "ramp_down" | "bell" | "loop";
+interface SignalNodeConfig {
+  amplitude?: number;
+  frequency?: number;
+  phase?: number;
+  offset?: number;
+  amplitudeMin?: number;
+  amplitudeMax?: number;
+  spatialScale?: number;
+  spatialSpeed?: number;
+  fmAmplitude?: number;
+  fmFrequency?: number;
+  gateEnabled?: boolean;
+  gateStartFrame?: number;
+  gateEndFrame?: number;
+  gateIdleValue?: number;
+  envelopeUseFrame?: boolean;
+  fnBody?: string;
+  fnOutputType?: WGSLOutputType;
+  fnParams?: FnParam[];
+  previewMode?: "pattern" | "cartesian" | "3d";
+  baseEnabled?: boolean;
+  baseType?: "sine" | "triangle" | "sawtooth" | "square" | "constant" | "noise_smooth" | "noise_white" | "pulse" | "bounce" | "staircase" | "custom";
+  fmEnabled?: boolean;
+  envelopeEnabled?: boolean;
+  envelopeFamily?: EasingFamily;
+  envelopeMode?: EasingMode;
+  envelopePattern?: EnvelopePattern;
+  envelopeCycles?: number;
+}
+//#endregion
+//#region src/signals/wgsl.d.ts
+interface WGSLSignalFn {
+  /** WGSL identifier, safe to paste into any shader. */
+  name: string;
+  /** Full ready-to-embed WGSL text (constants + fn declaration). */
+  wgsl: string;
+  /** The fn signature line only — useful for downstream shader templates. */
+  signature: string;
+  /** Return type of the function. */
+  outputType: WGSLOutputType;
+  /** User-defined param descriptors (mirrors config.fnParams). */
+  params: FnParam[];
+  /**
+   * True when the source compiled without any syntactic red-flags.
+   * (Basic heuristic — real validation must happen in the WebGPU device.)
+   */
+  valid: boolean;
+  /** Human-readable warning if `valid` is false. */
+  validationWarning?: string;
+}
+declare function buildWGSLSignalFn(config: SignalNodeConfig, /** Node id — used to produce a unique fn name. */
+nodeId: string): WGSLSignalFn;
+//#endregion
+//#region src/slug/slug-generator.d.ts
+interface FontkitGlyph {
+  codePoints: number[];
+  advanceWidth: number;
+  bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+  path: {
+    commands: Array<{
+      command: "moveTo" | "lineTo" | "quadraticCurveTo" | "bezierCurveTo" | "closePath";
+      args: number[];
+    }>;
+  };
+}
+interface FontkitFont {
+  numGlyphs: number;
+  getGlyph?(id: number): FontkitGlyph;
+  glyphForCodePoint?(codePoint: number): FontkitGlyph;
+  characterSet: number[] | Iterable<number>;
+  ascent: number;
+  descent: number;
+  lineGap: number;
+  unitsPerEm: number;
+  variationAxes?: Record<string, unknown>;
+  getVariation?(settings: Record<string, number>): FontkitFont;
+  /** Shapes a string (kerning, ligatures); fontkit fonts always have it. */
+  layout?(text: string): {
+    glyphs: unknown[];
+    positions: Array<{
+      xAdvance: number;
+    }>;
+  };
+}
+//#endregion
+//#region src/slug/slug-font-cache.d.ts
+type FontLoadListener = (fontFamily: string) => void;
+declare class SlugFontCache {
+  private static get cache();
+  private static get parsedFontCache();
+  /** Register an already parsed font (e.g. by FontManager) under a family name. */
+  static setParsed(fontFamily: string, font: FontkitFont): void;
+  static getParsed(fontFamily: string): FontkitFont | null;
+  static getAllParsed(): FontkitFont[];
+  static getFirstParsed(): FontkitFont | null;
+  static hasPending(): boolean;
+  private static listeners;
+  private static get loadingPromises();
+  private static get failedFonts();
+  static emojiFontPath: string | null;
+  static emojiFontUrl: string | null;
+  static emojiTextureCache: Map<string, GPUTexture>;
+  private static emojiFontBuffer;
+  private static emojiFontLoadPromise;
+  private static emojiFontFaceLoadPromise;
+  private static cmapOffset;
+  private static cblcOffset;
+  private static cbdtOffset;
+  /**
+   * Parse the SFNT table directory from a raw font buffer and cache
+   * the offsets for cmap, CBLC, and CBDT tables.
+   */
+  private static parseTableDirectory;
+  /**
+   * Load the emoji font binary from a local filesystem path (Node.js only)
+   * or from an HTTP URL via fetch.
+   */
+  private static loadEmojiFontBinary;
+  static getEmojiPngBuffer(codePoint: number): Promise<{
+    buffer: Uint8Array;
+    width: number;
+    height: number;
+  } | null>;
+  static preloadEmoji(device: GPUDevice, char: string, fontSize: number): Promise<GPUTexture>;
+  static getFont(fontFamily: string, fontWeight?: string | number, device?: GPUDevice | null, strokeWidth?: number, fontSize?: number, variableAxes?: Record<string, number>): SlugFont | undefined;
+  static registerFont(fontFamily: string, font: SlugFont): void;
+  static ensureTextures(device: GPUDevice, font: SlugFont): void;
+  static addListener(listener: FontLoadListener): () => void;
+  static isFailed(fontFamily: string): boolean;
+  static clearFailed(fontFamily?: string): void;
+  static preloadSlugFont(device: GPUDevice | null, fontFamily: string, fontUrl: string, whitelist?: number[], renderId?: string): Promise<SlugFont>;
+  /**
+   * Preloads the emoji font in the browser using the Cache API and registers
+   * a FontFace so canvas 2D can render emojis natively.
+   * No-op in Node.js environments.
+   */
+  static preloadEmojiFontFace(url: string): Promise<void>;
+  static destroy(): void;
+}
+//#endregion
+//#region src/slug/slug-geometry.d.ts
+
+//#endregion
+//#region src/texture-cache.d.ts
+declare class TextureCache {
+  private textures;
+  private refs;
+  private lruMap;
+  activeKeys: Set<string>;
+  /**
+   * Evicted textures wait here until the frame being recorded has been
+   * submitted: a command encoder may already reference them, and a frame's
+   * recording can span awaits (decodes, inference) during which they are
+   * evicted. `flushRetired` hands them to the GPU queue for destruction.
+   */
+  private retired;
+  acquire(key: string): GPUTexture | undefined;
+  has(key: string): boolean;
+  hasPrefix(prefix: string): boolean;
+  contains(str: string): boolean;
+  set(key: string, tex: GPUTexture, device?: GPUDevice): void;
+  create(key: string, device: GPUDevice, width: number, height: number, format?: GPUTextureFormat): GPUTexture;
+  release(key: string): void;
+  evict(key: string, device?: GPUDevice): void;
+  prune(device?: GPUDevice, maxInactive?: number): void;
+  private retire;
+  /**
+   * Destroys textures retired before the last submit, once the GPU is done
+   * with that work. Call at the start of a frame, after the previous one was
+   * submitted (`Renderer2D.resetPools` does).
+   */
+  flushRetired(device: GPUDevice): void;
+  private updateLru;
+  destroy(): void;
+}
+declare const textureCache: TextureCache;
+//#endregion
+//#region src/utils.d.ts
+declare global {
+  var __GATEWAI_DELAYS__: Set<number>;
+}
+//#endregion
+//#region src/math3d/vector3.d.ts
+/**
+ * 3D Vector mathematics for camera kinematics, scene projections, and spatial transforms.
+ * Fully typed, pure functional routines with zero runtime allocations where possible.
+ */
+type Vec3 = [number, number, number];
+//#endregion
+//#region src/math3d/matrix4.d.ts
+type Mat4 = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+//#endregion
+//#region src/math3d/camera3d.d.ts
+interface Camera3DPose {
+  /** Camera Eye position in world space [x, y, z] */
+  eye: Vec3;
+  /** LookAt Target / Point of Interest [x, y, z] */
+  target: Vec3;
+  /** Camera Up vector (default [0, -1, 0] for Y-down screen coordinates) */
+  up: Vec3;
+  /** Vertical field of view in degrees (default 50) */
+  fov: number;
+  /** Viewport aspect ratio (width / height) */
+  aspect: number;
+  /** Near clipping plane distance (default 1.0) */
+  near: number;
+  /** Far clipping plane distance (default 50000.0) */
+  far: number;
+  /** Optical zoom multiplier (default 1.0) */
+  zoom: number;
+  /** Focal plane distance from camera for Depth of Field in pixels */
+  focusDistance?: number;
+  /** Lens f-number / aperture (e.g. 1.4, 2.8, 5.6) */
+  fStop?: number;
+  /** Maximum bokeh blur radius in pixels (default 32) */
+  maxBlurRadius?: number;
+}
+interface CameraShakeOptions {
+  translationAmplitude: number;
+  rotationAmplitude: number;
+  frequency?: number;
+  octaves?: number;
+  seed?: number;
+}
+type FrustumPlane = [number, number, number, number];
+interface FrustumPlanes {
+  left: FrustumPlane;
+  right: FrustumPlane;
+  bottom: FrustumPlane;
+  top: FrustumPlane;
+  near: FrustumPlane;
+  far: FrustumPlane;
+}
+declare const Camera3D: {
+  /**
+   * Creates a default canvas-aligned 3D camera.
+   * Calibrated so that layers at Z=0 project 1:1 with 2D canvas pixel coordinates.
+   */
+  createDefaultCamera(width: number, height: number, fovDegrees?: number): Camera3DPose;
+  /**
+   * Computes LookAt view matrix from camera pose.
+   */
+  computeViewMatrix(camera: Camera3DPose): Mat4;
+  /**
+   * Computes WebGPU [0, 1] perspective projection matrix with zoom factor.
+   */
+  computeProjectionMatrix(camera: Camera3DPose): Mat4;
+  /**
+   * Computes combined View-Projection matrix: VP = P x V.
+   */
+  computeViewProjectionMatrix(camera: Camera3DPose): Mat4;
+  /**
+   * Dolly camera along optical viewing axis.
+   * Positive delta moves eye closer to target.
+   */
+  dolly(eye: Vec3, target: Vec3, deltaDistance: number): {
+    eye: Vec3;
+    target: Vec3;
+  };
+  /**
+   * Truck (lateral X) and Pedestal (vertical Y) camera translation in local camera space.
+   */
+  truckPedestal(eye: Vec3, target: Vec3, up: Vec3, deltaX: number, deltaY: number): {
+    eye: Vec3;
+    target: Vec3;
+  };
+  /**
+   * Computes camera Eye position orbiting around target in spherical coordinates.
+   * @param target Center point of orbit.
+   * @param radius Distance from target.
+   * @param azimuthDeg Horizontal orbit angle in degrees.
+   * @param elevationDeg Vertical elevation angle in degrees (from horizon).
+   */
+  orbit(target: Vec3, radius: number, azimuthDeg: number, elevationDeg: number): Vec3;
+  /**
+   * Applies Euler orientation angles (pitch, yaw, roll) in degrees to a camera pose.
+   * Pitch rotates around camera local Right axis (tilt up/down).
+   * Yaw rotates around camera local Up axis (pan left/right).
+   * Roll rotates around camera optical Forward axis (bank counter/clockwise).
+   */
+  applyOrientation(pose: Camera3DPose, pitchDeg: number, yawDeg: number, rollDeg: number): Camera3DPose;
+  /**
+   * Applies continuous procedural 3D camera shake (Simplex/harmonic noise).
+   */
+  applyCameraShake(pose: Camera3DPose, timeSeconds: number, options: CameraShakeOptions): Camera3DPose;
+  /**
+   * Computes Circle of Confusion (CoC) blur radius for Depth of Field.
+   * Points at depth == focusDistance produce 0.0 (sharp).
+   */
+  computeCircleOfConfusion(depth: number, focusDistance: number, focalLengthMm: number, fStop: number, maxBlurRadius?: number): number;
+  /**
+   * Extracts the 6 frustum clipping planes from a View-Projection matrix.
+   */
+  computeCameraFrustumPlanes(vp: Mat4): FrustumPlanes;
+  /**
+   * Checks whether an axis-aligned 3D bounding box intersects the camera frustum.
+   */
+  isBoxInFrustum(min: Vec3, max: Vec3, planes: FrustumPlanes): boolean;
+};
+//#endregion
+//#region src/math3d/path3d.d.ts
+interface Path3DPoint {
+  /** Position in 3D world space [x, y, z] */
+  position: Vec3;
+  /** Normalized unit tangent forward vector */
+  tangent: Vec3;
+  /** Normalized unit normal vector (orthogonal to tangent) */
+  normal: Vec3;
+  /** Normalized unit binormal vector: cross(tangent, normal) */
+  binormal: Vec3;
+  /** Cumulative arc length distance in pixels from path origin */
+  distance: number;
+  /** Normalized progress along path in [0, 1] */
+  t: number;
+  /** Euler orientation angles in degrees [pitch, yaw, roll] */
+  rotation: Vec3;
+}
+interface Path3DSample {
+  position: Vec3;
+  tangent: Vec3;
+  distance: number;
+}
+interface CatmullRomOptions {
+  /** Tension factor between 0 (loose) and 1 (tight); defaults to 0.5 (centripetal-like) */
+  tension?: number;
+  /** Whether path closes in a continuous loop */
+  closed?: boolean;
+  /** Samples per segment for arc-length integration (default 40) */
+  samplesPerSegment?: number;
+}
+interface BezierSegment3D {
+  p0: Vec3;
+  p1: Vec3;
+  p2: Vec3;
+  p3: Vec3;
+}
+interface HelixOptions {
+  center: Vec3;
+  radius: number;
+  pitch: number;
+  turns: number;
+  axis?: "x" | "y" | "z";
+  samplesPerTurn?: number;
+}
+interface CirclePathOptions {
+  center: Vec3;
+  radius: number;
+  normal?: Vec3;
+  startAngleDeg?: number;
+  endAngleDeg?: number;
+  samples?: number;
+}
+declare class Path3D {
+  private samples;
+  private frames;
+  totalLength: number;
+  constructor(samples: Path3DSample[]);
+  /**
+   * Computes continuous Rotation-Minimizing Frames (RMF) along the path
+   * using the Double Reflection Method (Wang et al. 2008), preventing gimbal flips.
+   */
+  private computeRotationMinimizingFrames;
+  /**
+   * Extracts pitch, yaw, roll Euler angles in degrees from the orthonormal frame.
+   */
+  private eulerFromFrame;
+  /**
+   * Evaluates point, tangent, normal, binormal, and rotation at normalized progress u in [0, 1].
+   * Progression moves with constant velocity along the arc length of the path.
+   */
+  getPointAt(u: number): Path3DPoint;
+  /**
+   * Evaluates point along path by absolute arc-length distance in pixels.
+   */
+  getPointAtDistance(distance: number): Path3DPoint;
+  /**
+   * Creates a smooth Catmull-Rom spline path interpolating through 3D waypoints.
+   */
+  static catmullRom(waypoints: Vec3[], options?: CatmullRomOptions): Path3D;
+  /**
+   * Creates a continuous 3D path from a chain of cubic Bezier segments.
+   */
+  static bezier(segments: BezierSegment3D[], samplesPerSegment?: number): Path3D;
+  /**
+   * Creates a 3D volumetric helix / spiral path.
+   */
+  static helix(options: HelixOptions): Path3D;
+  /**
+   * Creates a 3D circular or arc orbit path.
+   */
+  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;
+  name?: string;
+  positions: Float32Array;
+  normals: Float32Array;
+  uvs: Float32Array;
+  indices: Uint16Array | Uint32Array;
+  colors?: Float32Array;
+  tangents?: Float32Array;
+  jointIndices?: Float32Array;
+  jointWeights?: 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;
+}
+interface Material3D {
+  name: string;
+  diffuseColor?: [number, number, number, number];
+  specularColor?: [number, number, number];
+  ambientColor?: [number, number, number];
+  shininess?: number;
+  /**
+   * Specular strength parsed from the file (e.g. OBJ `Ks`). The mesh pass
+   * lights with the layer's `specularIntensity`; this is not applied yet.
+   */
+  specularIntensity?: number;
+  roughness?: number;
+  metallic?: number;
+  opacity?: number;
+  diffuseTexture?: string;
+  diffuseTextureBuffer?: Uint8Array | ArrayBuffer;
+  /** MIME type of `diffuseTextureBuffer` (image/png, image/jpeg, …). */
+  diffuseTextureMime?: string;
+  /** Texture addressing for UVs outside [0, 1] (glTF samplers default to repeat). */
+  textureWrap?: "repeat" | "clamp" | "mirror";
+  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";
+  /** Toon shading: the color multiplier of the shadowed side. */
+  shadeColor?: [number, number, number];
+}
+/** A scene-graph node: its rest transform and parent (glTF node semantics). */
+interface ModelNode3D {
+  name: string;
+  /** Index into Model3DData.nodes, -1 for a root. */
+  parent: number;
+  translation: Vec3;
+  /** Unit quaternion [x, y, z, w]. */
+  rotation: [number, number, number, number];
+  scale: Vec3;
+  /** A fixed local matrix (glTF `matrix`): such a node is not animated by TRS tracks. */
+  matrix?: Mat4;
+}
+interface Skin3D {
+  /** Joint node indices (Model3DData.nodes), in the order jointIndices refer to them. */
+  joints: number[];
+  /** One column-major 4x4 per joint. */
+  inverseBindMatrices: Float32Array;
+}
+interface Bone3D {
+  name: string;
+  index: number;
+  parentIndex: number;
+  inverseBindMatrix: Mat4;
+  bindMatrix: Mat4;
+  localTransform: Mat4;
+  worldTransform?: Mat4;
+}
+interface Skeleton3D {
+  bones: Bone3D[];
+  boneIndicesByName: Record<string, number>;
+}
+interface NodeAnimationTrack3D {
+  nodeName: string;
+  /** Target node index (Model3DData.nodes) when the model has a scene graph. */
+  node?: number;
+  times: Float32Array;
+  translations?: Float32Array;
+  rotations?: Float32Array;
+  scales?: Float32Array;
+  /** "cubic" (glTF CUBICSPLINE) stores [inTangent, value, outTangent] per keyframe. */
+  interpolation?: "linear" | "step" | "cubic";
+}
+interface AnimationClip3D {
+  name: string;
+  duration: number;
+  fps: number;
+  tracks: NodeAnimationTrack3D[];
+}
+interface Model3DData {
+  name?: string;
+  meshes: Mesh3DData[];
+  materials: Record<string, Material3D>;
+  skeleton?: Skeleton3D;
+  /** Scene graph (glTF): meshes, skins and animation tracks refer to these by index. */
+  nodes?: ModelNode3D[];
+  skins?: Skin3D[];
+  /** Centering and size normalization, applied above the scene graph instead of baked into vertices. */
+  rootTransform?: Mat4;
+  animations: AnimationClip3D[];
+  bounds: {
+    min: Vec3;
+    max: Vec3;
+    center: Vec3;
+    size: Vec3;
+    boundingSphereRadius: number;
+  };
+}
+interface LoadModelOptions {
+  center?: boolean;
+  normalizeSize?: number;
+  scale?: number | [number, number, number];
+  smoothNormals?: boolean;
+  defaultMaterial?: Partial<Material3D>;
+  basePath?: string;
+  mtlText?: string;
+}
+//#endregion
+//#region src/loaders/obj-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
+
+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
+
+//#endregion
+//#region src/renderer3d/audio-mesh-deform-pipeline.d.ts
+interface DeformDispatchOptions {
+  config: MeshAudioDeformConfig;
+  audioLatentBuffer: GPUBuffer;
+  vertexCount: number;
+  timeMs?: number;
+  sampleRate?: number;
+}
+declare class AudioMeshDeformPipeline {
+  private device;
+  pipeline: GPUComputePipeline;
+  bindGroupLayout: GPUBindGroupLayout;
+  private uniformPool;
+  private deformedBuffers;
+  private uniformData;
+  private uniformUint32;
+  private uniformFloat32;
+  constructor(device: GPUDevice);
+  getOrCreateDeformedBuffer(srcBuffer: GPUBuffer, byteLength: number): GPUBuffer;
+  execute(encoder: GPUCommandEncoder, srcVertexBuffer: GPUBuffer, options: DeformDispatchOptions): GPUBuffer;
+  resetPools(): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer3d/glass-pipeline.d.ts
+/**
+ * @file renderer3d/glass-pipeline.ts
+ * @module @framefields/webgpu-renderers/renderer3d/glass-pipeline
+ *
+ * WebGPU Pipeline for PBR Glass, Acrylic, Frosted & Metallic Refraction rendering.
+ */
+interface GlassUniformData {
+  ior?: number;
+  roughness?: number;
+  f0?: number;
+  transmission?: number;
+  dispersion?: number;
+  envIntensity?: number;
+  fresnelPower?: number;
+  viewportWidth: number;
+  viewportHeight: number;
+  tintColor?: [number, number, number, number];
+  modelMatrix: Float32Array | number[];
+  normalMatrix?: Float32Array | number[];
+  colorTint?: [number, number, number, number];
+  opacity?: number;
+}
+declare class GlassPipeline {
+  private device;
+  pipeline: GPURenderPipeline;
+  cameraLayout: GPUBindGroupLayout;
+  modelLayout: GPUBindGroupLayout;
+  glassLayout: GPUBindGroupLayout;
+  backdropLayout: GPUBindGroupLayout;
+  private modelPool;
+  private glassPool;
+  private vertexBuffer;
+  private indexBuffer;
+  private modelData;
+  private glassData;
+  constructor(device: GPUDevice, format: GPUTextureFormat, depthFormat?: GPUTextureFormat, cameraLayout?: GPUBindGroupLayout);
+  resetPools(): void;
+  draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, backdropTexture: GPUTexture, sampler: GPUSampler, data: GlassUniformData): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer3d/mesh3d-pipeline.d.ts
+interface MeshUniformData {
+  modelMatrix: Float32Array | number[];
+  normalMatrix?: Float32Array | number[];
+  colorTint?: [number, number, number, number];
+  opacity?: number;
+  twoSided?: boolean;
+  wireframe?: boolean;
+  isSkinned?: boolean;
+  skinningMatrices?: Float32Array;
+  material?: "lit" | "unlit" | "toon";
+  /** Toon shading: the shadowed side's color multiplier. */
+  shadeColor?: [number, number, number];
+  /** Texels with alpha below this are discarded (glTF MASK). */
+  alphaCutoff?: number;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  ambientIntensity?: number;
+  metallic?: number;
+}
+interface GPUMeshBuffers {
+  vertexBuffer: GPUBuffer;
+  indexBuffer: GPUBuffer;
+  indexCount: number;
+  indexFormat: GPUIndexFormat;
+}
+declare class Mesh3DPipeline {
+  private device;
+  pipelineSingle: GPURenderPipeline;
+  pipelineMrt: GPURenderPipeline;
+  cameraLayout: GPUBindGroupLayout;
+  modelLayout: GPUBindGroupLayout;
+  textureLayout: GPUBindGroupLayout;
+  lightsLayout: GPUBindGroupLayout;
+  private modelPool;
+  private skinningPool;
+  defaultWhiteTexture: GPUTexture;
+  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;
+  destroy(): void;
+}
+//#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 {
+  shutterAngle?: number;
+  sampleCount?: number;
+  maxVelocity?: number;
+  depthThreshold?: number;
+  curveType?: "box" | "gaussian" | "triangle";
+  width: number;
+  height: number;
+}
+declare class MotionBlurPipeline {
+  private device;
+  private pipeline;
+  private bindGroupLayout;
+  private uniformBuffer;
+  private sampler;
+  constructor(device: GPUDevice);
+  render(commandEncoder: GPUCommandEncoder, colorView: GPUTextureView, velocityView: GPUTextureView, depthView: GPUTextureView, targetView: GPUTextureView, options: MotionBlurPassOptions): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer3d/quad3d-pipeline.d.ts
+interface ModelUniformData {
+  modelMatrix: Float32Array | number[];
+  normalMatrix?: Float32Array | number[];
+  colorTint?: [number, number, number, number];
+  borderColor?: [number, number, number, number];
+  borderWidth?: number;
+  opacity?: number;
+  borderRadius?: number;
+  twoSided?: boolean;
+  width?: number;
+  height?: number;
+  /** Fraction of the texture the layer covers, [u, v] (default the whole texture) */
+  textureExtent?: [number, number];
+  material?: "lit" | "unlit";
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  ambientIntensity?: number;
+  metallic?: number;
+}
+type MaterialUniformData = Pick<ModelUniformData, "material" | "shininess" | "roughness" | "specularIntensity" | "ambientIntensity" | "metallic">;
+/** [shininess, specularIntensity, ambientIntensity, materialMode] as the 3D shaders' lighting reads them. */
+
+declare class Quad3DPipeline {
+  private device;
+  pipelineSingle: GPURenderPipeline;
+  pipelineMrt: GPURenderPipeline;
+  cameraLayout: GPUBindGroupLayout;
+  modelLayout: GPUBindGroupLayout;
+  textureLayout: GPUBindGroupLayout;
+  lightsLayout: GPUBindGroupLayout;
+  private modelPool;
+  private vertexBuffer;
+  private indexBuffer;
+  private modelData;
+  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;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer3d/slug3d-pipeline.d.ts
+interface Slug3DUniformData extends MaterialUniformData {
+  /** Paragraph px to world */
+  modelMatrix: Mat4;
+  normalMatrix: Mat4;
+  opacity: number;
+  /** Synthetic italic shear */
+  slant: number;
+  twoSided: boolean;
+  /** Fraction of the distance to the eye the glyphs slide toward it, to stack on their plane */
+  depthPull: number;
+}
+/** Slug glyphs in the 3D pass: depth-tested, lit and resolution independent. */
+declare class Slug3DPipeline {
+  private device;
+  private pipelineSingle;
+  private pipelineMrt;
+  private modelLayout;
+  private fontLayout;
+  private modelPool;
+  private instancePool;
+  private fontBindGroups;
+  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, font: SlugFont, instances: Float32Array, instanceCount: number, data: Slug3DUniformData, useMrt?: 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 {
+  /** 3D world position [x, y, z] */
+  position: [number, number, number];
+  /** Layer surface width */
+  width: number;
+  /** Layer surface height */
+  height: number;
+  /** Fraction of the texture the layer covers, [u, v] (default the whole texture) */
+  textureExtent?: [number, number];
+  /** Euler rotations in degrees [rx, ry, rz] */
+  rotation?: Vec3;
+  /** 3D scale [sx, sy, sz] */
+  scale?: Vec3;
+  /** Anchor pivot ratio [ax, ay] (default [0.5, 0.5]) */
+  anchor?: [number, number];
+  /** Layer opacity [0, 1] */
+  opacity?: number;
+  /** RGBA color tint */
+  colorTint?: [number, number, number, number];
+  /** Border color (string, Color, or [r, g, b, a]) */
+  borderColor?: [number, number, number, number] | string | Color;
+  /** Border stroke width */
+  borderWidth?: number;
+  /** Rounded corner radius */
+  borderRadius?: number;
+  /** Whether backface is rendered */
+  twoSided?: boolean;
+  /** Pre-computed model matrix overriding position/rotation/scale if supplied */
+  modelMatrix?: Mat4;
+  /** Pre-computed normal matrix */
+  normalMatrix?: Mat4;
+  /** Material shading mode ("lit" vs "unlit") */
+  material?: "lit" | "unlit";
+  /** Blinn-Phong specular shininess exponent */
+  shininess?: number;
+  /** Roughness factor [0, 1] */
+  roughness?: number;
+  /** Specular highlight intensity [0, 10] */
+  specularIntensity?: number;
+  /** Ambient light reflection multiplier */
+  ambientIntensity?: number;
+  /** Metallic factor [0, 1] */
+  metallic?: number;
+}
+interface DrawMesh3DOpts {
+  /** 3D world position [x, y, z] */
+  position?: Vec3;
+  /** Euler rotations in degrees [rx, ry, rz] */
+  rotation?: Vec3;
+  /** 3D scale [sx, sy, sz] */
+  scale?: Vec3;
+  /** Layer opacity [0, 1] */
+  opacity?: number;
+  /** RGBA color tint */
+  colorTint?: [number, number, number, number];
+  /** Whether backface is rendered */
+  twoSided?: boolean;
+  /** Wireframe mode */
+  wireframe?: boolean;
+  /** Whether vertex skinning is enabled */
+  isSkinned?: boolean;
+  /** Skinning matrices (128 * 16 floats) */
+  skinningMatrices?: Float32Array;
+  /** Pre-computed model matrix overriding position/rotation/scale if supplied */
+  modelMatrix?: Mat4;
+  /** Pre-computed normal matrix */
+  normalMatrix?: Mat4;
+  /** Material shading mode */
+  material?: "lit" | "unlit" | "toon";
+  /** Toon shading: the shadowed side's color multiplier */
+  shadeColor?: [number, number, number];
+  /** Discard texels whose alpha is below this (glTF MASK) */
+  alphaCutoff?: number;
+  /** Texture addressing outside [0, 1] */
+  textureWrap?: "repeat" | "clamp" | "mirror";
+  /** Blinn-Phong specular shininess exponent */
+  shininess?: number;
+  /** Roughness factor [0, 1] */
+  roughness?: number;
+  /** Specular highlight intensity [0, 10] */
+  specularIntensity?: number;
+  /** Ambient light reflection multiplier */
+  ambientIntensity?: number;
+  /** Metallic factor [0, 1] */
+  metallic?: number;
+  /** Optional audio latent mesh deformation options */
+  audioDeform?: {
+    config: MeshAudioDeformConfig;
+    latentBuffer: GPUBuffer;
+    timeMs?: number;
+    sampleRate?: number;
+  };
+}
+declare class Renderer3D {
+  private device;
+  format: GPUTextureFormat;
+  quad3dPipeline: Quad3DPipeline;
+  slug3dPipeline: Slug3DPipeline;
+  mesh3dPipeline: Mesh3DPipeline;
+  audioMeshDeformPipeline: AudioMeshDeformPipeline;
+  private dofPipeline;
+  private dofBindGroupLayout;
+  private cameraPool;
+  private lightsPool;
+  private cameraUniformBindGroupCache;
+  private lightsUniformBindGroupCache;
+  private samplerCache;
+  private depthTexture;
+  private linearDepthTexture;
+  private msaaColorTexture;
+  private msaaLinearDepthTexture;
+  private cameraUniformData;
+  private meshBuffersCache;
+  private materialTextures;
+  /** Parsed models by source and load options: a model file is read once, not every frame. */
+  private modelCache;
+  private lastCameraPose;
+  private lastCameraBuffer;
+  /**
+   * Samples per pixel in the 3D pass. Mesh silhouettes (extruded text,
+   * models) are rasterized triangles: without MSAA every edge is a hard
+   * stair-step. 4 is the count every WebGPU device supports; 1 turns it off.
+   */
+  readonly sampleCount: number;
+  constructor(device: GPUDevice, format: GPUTextureFormat, sampleCount?: number);
+  resetPools(): void;
+  getOrCreateDepthTexture(width: number, height: number): GPUTexture;
+  private getOrCreateMsaaTexture;
+  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[]): {
+    pass: GPURenderPassEncoder;
+    cameraBindGroup: GPUBindGroup;
+    cameraBuffer: GPUBuffer;
+    lightsBindGroup: GPUBindGroup;
+  };
+  /**
+   * 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).
+   */
+  private quadModelMatrix;
+  /**
+   * 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
+   * as sharp at a glancing angle or up close as it is flat on screen.
+   * `stackBase` is how many passes already sit on this plane (a backdrop
+   * quad): each batch draws just in front of the one before.
+   */
+  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;
+  getOrCreateMeshBuffers(mesh: Mesh3DData): GPUMeshBuffers;
+  deformMesh(encoder: GPUCommandEncoder, mesh: Mesh3DData, audioDeform: {
+    config: MeshAudioDeformConfig;
+    latentBuffer: GPUBuffer;
+    timeMs?: number;
+    sampleRate?: number;
+  }): GPUMeshBuffers;
+  drawMesh3D(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, meshOrBuffers: Mesh3DData | GPUMeshBuffers, texture: GPUTexture | undefined, opts?: DrawMesh3DOpts, useMrt?: boolean): void;
+  loadModel(srcOrData: string | ArrayBuffer | Uint8Array, format?: "obj" | "fbx" | "gltf" | "glb" | "stl" | "ply" | "vox" | "3ds" | "off" | "auto", options?: LoadModelOptions): Model3DData;
+  /**
+   * The material's diffuse texture on the GPU, decoded once with a full mip
+   * chain (a character's 2K maps are drawn a few hundred pixels tall).
+   */
+  materialTexture(material: Material3D): Promise<GPUTexture | undefined>;
+  private uploadMaterialTexture;
+  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
+
+declare class ShadowPipeline {
+  shadowDepthTexture: GPUTexture;
+  shadowDepthView: GPUTextureView;
+  shadowComparisonSampler: GPUSampler;
+  lightViewProjMatrix: Mat4;
+  constructor(device: GPUDevice, resolution?: number);
+  computeDirectionalLightMatrix(lightPos: Vec3, targetPos: Vec3, orthoSize?: number, near?: number, far?: number): Mat4;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderer3d/ssao-pipeline.d.ts
+interface SSAOPassOptions {
+  projMatrix: Mat4;
+  invProjMatrix?: Mat4;
+  viewMatrix: Mat4;
+  radius?: number;
+  bias?: number;
+  intensity?: number;
+  kernelSamples?: number;
+  blurRadius?: number;
+  depthThreshold?: number;
+  width: number;
+  height: number;
+}
+declare class SSAOPipeline {
+  private device;
+  private ssaoPipeline;
+  private blurPipeline;
+  private ssaoBindGroupLayout;
+  private blurBindGroupLayout;
+  private ssaoUniformBuffer;
+  private blurUniformBuffer;
+  private kernelBuffer;
+  private noiseTexture;
+  private sampler;
+  constructor(device: GPUDevice);
+  render(commandEncoder: GPUCommandEncoder, depthView: GPUTextureView, normalView: GPUTextureView, rawAOView: GPUTextureView, finalAOView: GPUTextureView, options: SSAOPassOptions): void;
+  destroy(): void;
+}
+//#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 _, 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, signal as ci, ModerationError as cn, TimelineSegmentSchema as cr, CannyOptions as ct, EffectPipeline as d, stampResult 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, takeRenderDiagnostics as fi, NodeMetadata as fn, Transition as fr, ConnectedInput as ft, LoadModelOptions as g, NodeResult as gn, VideoAnimation as gr, DEFAULT_FPS as gt, Light3DOptions as h, 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, signalBuilder as li, ModerationUnrefundableError as ln, TimelineTransform as lr, ConfigHandle as lt, Light3D as m, updateClockSignals 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, resolveMediaMimeType as oi, MediaSourceSchema as on, TextSpan as or, COMPOSITE_OPERATIONS as ot, GlassPipeline as p, timeSignal 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, serializeSignalData 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, sineSignal as ui, MultiOutputGeneric as un, TimelineTransformSchema as ur, ConfigHandleSchema as ut, Material3D as v, 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-D2jDC7O5.d.mts.map