framefields 2.9.2 → 2.9.3

package/dist/index-9_4X2ro1.d.mts

@@ -0,0 +1,2402 @@
+import z$1, { z } from "zod";
+
+//#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 _cachedContext?;
+  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/resolve.d.ts
+/**
+ * Extracts a numeric value from a primitive, Signal, or wrapper object.
+ * Returns the fallback if undefined, null, NaN, or non-numeric.
+ */
+declare function resolveNumber(val: unknown, fallback: number): number;
+/**
+ * Extracts a string value from a primitive, Signal, or wrapper object.
+ * Returns the fallback if undefined, null, or non-string.
+ */
+declare function resolveString(val: unknown, fallback: string): string;
+/**
+ * Extracts a boolean value from a primitive, Signal, or wrapper object.
+ * Returns the fallback if undefined, null, or non-boolean.
+ */
+declare function resolveBoolean(val: unknown, fallback: boolean): boolean;
+/**
+ * Generic parameter resolver matching the fallback value's type.
+ */
+declare function resolveParam<T>(val: unknown, fallback: T): T;
+//#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>;
+/**
+ * Whether `val` is a plain value signal (from `signal()`): it reads the same
+ * whatever frame context it is given, so one read stands for every frame.
+ */
+declare function isValueSignal(val: unknown): val is WritableSignal<unknown>;
+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/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/types/brands.d.ts
+declare const BrandTag: unique symbol;
+/**
+ * Compile-time zero-cost nominal typing tag ("newtype" pattern).
+ * Prevents accidental cross-assignment of semantically incompatible primitives
+ * (e.g. milliseconds to seconds, handle labels to handle IDs, or fractional frames).
+ */
+type Brand<T, B extends string> = T & {
+  readonly [BrandTag]: B;
+};
+/** Timeline frame number (must be a non-negative integer). */
+type FrameIndex = Brand<number, "FrameIndex">;
+/** Time in seconds. */
+type Seconds = Brand<number, "Seconds">;
+/** Time in milliseconds. */
+type Milliseconds = Brand<number, "Milliseconds">;
+/** Frame rate in frames per second. */
+type Fps = Brand<number, "Fps">;
+/** Normalized scalar in the range [0.0, 1.0]. */
+type Normalized = Brand<number, "Normalized">;
+/** Angle in degrees (0 to 360). */
+type Degrees = Brand<number, "Degrees">;
+/** Angle in radians (0 to 2*PI). */
+type Radians = Brand<number, "Radians">;
+/** Dimension in screen/canvas pixels. */
+type Pixels = Brand<number, "Pixels">;
+/** Live compositor dynamic input/output handle identifier. */
+type HandleId = Brand<string, "HandleId">;
+/** Human-readable handle label (distinct from HandleId to prevent runtime lookup failure). */
+type HandleLabel = Brand<string, "HandleLabel">;
+/** Unique layout node identifier. */
+type NodeId = Brand<string, "NodeId">;
+/** Asserts and casts a number to an integer FrameIndex. */
+declare function frame(n: number): FrameIndex;
+/** Asserts and casts a number to Seconds. */
+declare function seconds(s: number): Seconds;
+/** Asserts and casts a number to Milliseconds. */
+declare function ms(m: number): Milliseconds;
+/** Asserts and casts a number to Fps. */
+declare function fps(f: number): Fps;
+/** Clamps and casts a number to Normalized [0.0, 1.0]. */
+declare function normalized(n: number): Normalized;
+/** Asserts and casts a number to Degrees. */
+declare function degrees(deg: number): Degrees;
+/** Asserts and casts a number to Radians. */
+declare function radians(rad: number): Radians;
+/** Asserts and casts a number to Pixels. */
+declare function pixels(px: number): Pixels;
+/** Casts a string to HandleId. */
+declare function handleId(id: string): HandleId;
+/** Casts a string to HandleLabel. */
+declare function handleLabel(label: string): HandleLabel;
+/** Casts a string to NodeId. */
+declare function nodeId(id: string): NodeId;
+/** Type guard checking if a number is a valid FrameIndex. */
+declare function isFrameIndex(val: unknown): val is FrameIndex;
+/** Type guard checking if a number is in the Normalized [0, 1] range. */
+declare function isNormalized(val: unknown): val is Normalized;
+//#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>;
+  durationFrames: 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>;
+type NodeInputConnection = {
+  connectionValid: boolean;
+  outputItem: {
+    type: string;
+    data: unknown;
+  } | null;
+};
+type NodeOperation<TOp extends string = string, TConfig extends object = Record<string, unknown>> = BaseMediaOperationProps & {
+  op: TOp;
+  id?: string;
+  metadata?: MediaMetadata;
+  dataType?: DataType;
+  effect?: unknown;
+  signals?: Record<string, unknown>;
+  inputs?: Record<string, NodeInputConnection>;
+  onRequestFrame?: (ctx: FrameContext) => void;
+} & TConfig;
+/** 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>;
+  durationFrames: 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>;
+  durationFrames: 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>) | NodeOperation<string, Record<string, unknown>>);
+type VirtualMediaData<TOperation extends MediaOperation = MediaOperation> = {
+  metadata: MediaMetadata;
+  operation: TOperation;
+  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 = {
+  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>;
+  direction: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+    auto: "auto";
+  }>>;
+  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>;
+  direction: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+    auto: "auto";
+  }>>;
+  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>;
+  direction: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+    auto: "auto";
+  }>>;
+  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<MediaOperation>, unknown, z.core.$ZodTypeInternals<VirtualMediaData<MediaOperation>, 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>;
+//#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]> };
+type EffectDomain = "visual" | "audio" | "both";
+declare abstract class Effect<TConfig extends object = Record<string, unknown>, TOp extends string = string, TDomain extends EffectDomain = "visual"> {
+  abstract readonly op: TOp;
+  readonly domain: TDomain;
+  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(): NodeOperation<TOp, TConfig>;
+}
+//#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/frame-time.d.ts
+/** Frame windows are half-open: [startFrame, startFrame + durationFrames). */
+declare function frameCount(durationMs: number, fps: number): number;
+declare function assertFps(fps: number): void;
+/** Resolve once, before hooks or rendering. atMs takes precedence over frame. */
+declare function resolveFrameRequest(request: {
+  frame?: number;
+  atMs?: number;
+}, fps: number): {
+  frame: number;
+  timeMs: number;
+};
+//#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/media-time-signal.d.ts
+/** A sampled source-time curve or the integral of a sampled playback rate. */
+type SampledMediaSignal = {
+  readonly mode: "source-time";
+  readonly values: Float64Array;
+  readonly fps: number;
+} | {
+  readonly mode: "speed";
+  readonly values: Float64Array;
+  readonly positions: Float64Array;
+  readonly fps: number;
+};
+/**
+ * Sample a signal at every composition-frame boundary in layer order.
+ * Values between boundaries are linearly interpolated; speeds are integrated
+ * analytically, so picture and audio can query the same fractional frame.
+ */
+declare function sampleMediaSignal(options: {
+  mode: "source-time" | "speed";
+  fps: number;
+  startFrame: number;
+  durationFrames: number;
+  sourceStartSec?: number;
+  sample: (compositionFrame: number) => number;
+}): SampledMediaSignal;
+/** Sample an engine signal with its composition clock and full frame context. */
+declare function sampleFrameMediaSignal(options: {
+  mode: "source-time" | "speed";
+  fps: number;
+  startFrame: number;
+  durationFrames: number;
+  compositionDurationFrames: number;
+  sourceStartSec?: number;
+  signal: Signal<number>;
+}): SampledMediaSignal;
+/** The frame context a composition-clock signal sees at a composition frame. */
+declare function compositionFrameContext(frame: number, fps: number, compositionDurationFrames: number): FrameContext;
+/** Evaluate at any fractional local frame, independent of query order. */
+declare function sampledMediaSourceTime(map: SampledMediaSignal, frame: number): number;
+/** Source-time bounds over a layer interval; `max` is exclusive unless included. */
+interface MediaSourceRange {
+  min: number;
+  max: number;
+  maxIncluded: boolean;
+}
+/** Range includes direction changes inside a speed-signal interval. */
+declare function sampledMediaSourceRange(map: SampledMediaSignal, from: number, to: number): MediaSourceRange;
+/**
+ * Records a live signal at each composition-frame boundary, so its history can
+ * be replayed for audio, seeks and vision without evaluating it a second time.
+ * With a sampler, boundaries are evaluated on demand, but never past the
+ * frame the composition has reached ({@link advance}): no look-ahead.
+ */
+declare class MediaSignalRecorder {
+  private readonly values;
+  private readonly positions;
+  private recorded;
+  private evaluating;
+  private horizon;
+  private sampler;
+  private check;
+  readonly startFrame: number;
+  readonly durationFrames: number;
+  readonly fps: number;
+  readonly mode: "source-time" | "speed";
+  constructor(options: {
+    mode: "source-time" | "speed";
+    fps: number;
+    startFrame: number;
+    durationFrames: number;
+    sourceStartSec?: number;
+    sample?: (compositionFrame: number) => number;
+  });
+  /** The first composition frame whose boundary is not yet recorded. */
+  get nextFrame(): number;
+  get complete(): boolean;
+  /** Allow on-demand sampling through a composition frame the clock has reached. */
+  advance(frame: number): void;
+  /**
+   * Validate source bounds as history arrives: the recorded part now, each
+   * further interval as it is recorded.
+   */
+  checkRange(check: (range: MediaSourceRange) => void): void;
+  /** Each boundary is recorded once in composition-frame order. */
+  record(frame: number, value: number): void;
+  /**
+   * Evaluate a boundary once, reporting recursive time dependencies. A
+   * boundary already recorded is kept, and `sample` is not called again.
+   */
+  recordFrom(frame: number, sample: () => number): void;
+  /** Sample every boundary through `frame` that the clock has reached. */
+  ensure(frame: number): void;
+  /**
+   * Close a layer that outlives the clock: the boundaries past the last
+   * rendered frame hold the last recorded value.
+   */
+  close(): void;
+  /** The known source position at an already-recorded frame boundary. */
+  at(frame: number): number;
+  /** Read a recorded local frame, including fractional audio sample positions. */
+  sourceTime(localFrame: number): number;
+  /** Read the instantaneous speed for an interval whose endpoints are known. */
+  rate(localFrame: number): number;
+  isHold(localFrame: number): boolean;
+  range(from: number, to: number): MediaSourceRange;
+  /** A self-contained snapshot, available only when every boundary was recorded. */
+  finish(): SampledMediaSignal;
+  private knownInterval;
+  /** Bounds of the interval starting at boundary `i`, its end exclusive. */
+  private interval;
+  private history;
+}
+//#endregion
+//#region src/media-time.d.ts
+/** Maps layer-local frames to absolute source seconds. */
+declare const MediaTimeRemapSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"rate">;
+  sourceStartSec: z.ZodNumber;
+  rate: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"keyframes">;
+  keyframes: z.ZodArray<z.ZodObject<{
+    frame: z.ZodNumber;
+    sourceSec: z.ZodNumber;
+    interpolation: z.ZodOptional<z.ZodEnum<{
+      linear: "linear";
+      "ease-in": "ease-in";
+      "ease-out": "ease-out";
+      smooth: "smooth";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+type MediaTimeRemap = z.infer<typeof MediaTimeRemapSchema>;
+/**
+ * Drives source time from a signal on the composition clock: `"speed"` is
+ * playback rate (source seconds per second, integrated from `sourceStartSec`),
+ * `"source-time"` is absolute source seconds. `signal` is a signal instance or
+ * the name of a composition signal. The signal is read at every frame
+ * boundary of the layer, after that frame's hooks have run.
+ */
+interface MediaTimeSignalRemap {
+  kind: "signal";
+  mode: "speed" | "source-time";
+  signal: Signal<number> | string;
+  sourceStartSec?: number;
+}
+declare const MediaTimeSignalRemapSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"signal">;
+  mode: z.ZodEnum<{
+    speed: "speed";
+    "source-time": "source-time";
+  }>;
+  signal: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Signal<number>, Signal<number>>]>;
+  sourceStartSec: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** Every `timeRemap` an author can write: a fixed map or a signal binding. */
+type MediaTimeRemapInput = MediaTimeRemap | MediaTimeSignalRemap;
+declare const MediaTimeRemapInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"rate">;
+  sourceStartSec: z.ZodNumber;
+  rate: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"keyframes">;
+  keyframes: z.ZodArray<z.ZodObject<{
+    frame: z.ZodNumber;
+    sourceSec: z.ZodNumber;
+    interpolation: z.ZodOptional<z.ZodEnum<{
+      linear: "linear";
+      "ease-in": "ease-in";
+      "ease-out": "ease-out";
+      smooth: "smooth";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"signal">;
+  mode: z.ZodEnum<{
+    speed: "speed";
+    "source-time": "source-time";
+  }>;
+  signal: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Signal<number>, Signal<number>>]>;
+  sourceStartSec: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "kind">;
+/** A per-render signal history resolved by the media timing scheduler. */
+type ResolvedMediaTimeRemap = MediaTimeRemap | {
+  readonly kind: "sampled";
+  readonly history: SampledMediaSignal;
+} | {
+  readonly kind: "recorded";
+  readonly recorder: MediaSignalRecorder;
+};
+/** Validate the map against its explicit, exclusive layer duration. */
+declare function validateMediaTimeRemap(map: MediaTimeRemapInput, durationFrames: number): string | undefined;
+/** Absolute source seconds at a fractional layer-local frame. */
+declare function mediaSourceTime(map: ResolvedMediaTimeRemap, localFrame: number, fps: number): number;
+/** True only for a constant source-time interval, not a ramp with zero instantaneous velocity. */
+declare function mediaSourceIsHold(map: ResolvedMediaTimeRemap, frame: number): boolean;
+/** Source seconds per output second at a layer-local frame. */
+declare function mediaSourceRate(map: ResolvedMediaTimeRemap, frame: number, fps: number): number;
+/** Bounds over a local-frame interval, including intermediate turns. */
+declare function mediaSourceRange(map: ResolvedMediaTimeRemap, fromFrame: number, toFrame: number, fps: number): MediaSourceRange;
+//#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/utils/assert.d.ts
+/**
+ * Compile-time exhaustiveness check helper for discriminated unions and enums.
+ *
+ * In switch statements or if-else ladders, passing the unhandled variable to
+ * `assertNever(x)` will fail TypeScript compilation if any variant was missed.
+ * At runtime, if an unexpected value arrives (e.g. from unvalidated JSON), it throws
+ * a descriptive Error.
+ */
+declare function assertNever(value: never, message?: string): never;
+//#endregion
+//#region src/utils/color.d.ts
+/**
+ * CSS color parsing, perceptual mixing and authoring helpers, shared by the
+ * schema evaluator (color tracks), the GPU renderers (fills) and the public
+ * `Color` helper. Pure and dependency-free.
+ *
+ * Every helper returns a CSS string any color prop accepts: `#rrggbb`, or
+ * `#rrggbbaa` when not fully opaque.
+ */
+/** Straight (non-premultiplied) sRGB, each channel 0..1. */
+type Rgba = [r: number, g: number, b: number, a: number];
+/** sRGB (0..1) → OKLab [L, a, b]. */
+declare function rgbToOklab(r: number, g: number, b: number): [number, number, number];
+/** OKLab → sRGB (0..1, clamped to gamut). */
+declare function oklabToRgb(L: number, a: number, b: number): [number, number, number];
+/**
+ * Parses any CSS color this engine accepts: hex (3/4/6/8), `rgb()`/`rgba()`,
+ * `hsl()`/`hsla()`, `oklch()`, `oklab()` (comma or space syntax, `/ alpha`)
+ * and common named colors. Returns `null` when the string is not a color.
+ */
+declare function parseCssColor(input: string): Rgba | null;
+/** Formats straight sRGB as `#rrggbb` (or `#rrggbbaa` when translucent). */
+declare function formatHex([r, g, b, a]: Rgba): string;
+/**
+ * Mixes two colors perceptually (in OKLab), `t` = 0 → `a`, 1 → `b`.
+ * Midpoints keep their lightness and saturation instead of going muddy
+ * the way a plain sRGB lerp does.
+ */
+declare function mixColors(a: string, b: string, t: number): string;
+interface ColorStopLike {
+  offset: number;
+  color: string;
+}
+/** Samples a multi-stop gradient (stops in any order) at `t` ∈ [0, 1]. */
+declare function sampleColorStops(stops: readonly (string | ColorStopLike)[], t: number): string;
+/** Bare color strings become evenly spaced stops; result is sorted by offset. */
+declare function normalizeColorStops(stops: readonly (string | ColorStopLike)[]): ColorStopLike[];
+/**
+ * Authoring helpers for colors. Every function returns a hex string, so the
+ * result drops straight into any color prop or keyframe.
+ *
+ * ```ts
+ * Color.oklch(0.7, 0.15, 250)          // perceptual: equal L reads equally bright
+ * Color.hsl(212, 0.95, 0.74)
+ * Color.mix("#ff5a1f", "#1f6bff", 0.5) // OKLab, no muddy midpoint
+ * const wave = Color.ramp(["#3b82f6", "#8b5cf6", "#ec4899"]);
+ * wave(0.5)                            // sample a gradient
+ * Color.lighten("#ff5a1f", 0.1), Color.alpha("#000", 0.4)
+ * ```
+ */
+declare const Color: {
+  /** Parses any supported CSS color to straight sRGB 0..1, or null. */
+  readonly parse: typeof parseCssColor;
+  /** Normalizes any supported CSS color to hex. */
+  readonly hex: (c: string) => string;
+  /** `r, g, b` in 0..255, `a` in 0..1. */
+  readonly rgb: (r: number, g: number, b: number, a?: number) => string;
+  /** Hue in degrees; saturation and lightness in 0..1. */
+  readonly hsl: (h: number, s: number, l: number, a?: number) => string;
+  /**
+   * Perceptual lightness 0..1, chroma ~0..0.37, hue in degrees. Colors with
+   * the same `l` look equally bright, which makes balanced palettes easy.
+   */
+  readonly oklch: (l: number, c: number, h: number, a?: number) => string;
+  /** Perceptual (OKLab) mix; `t` = 0 → `a`, 1 → `b`. */
+  readonly mix: typeof mixColors;
+  /** A gradient sampler: `Color.ramp(["#f00", "#00f"])(0.25)`. */
+  readonly ramp: (stops: readonly (string | ColorStopLike)[]) => (t: number) => string;
+  /** `n` evenly spaced swatches along a gradient. */
+  readonly steps: (stops: readonly (string | ColorStopLike)[], n: number) => string[];
+  /** Raises perceptual lightness by `amount` (0..1). */
+  readonly lighten: (c: string, amount: number) => string;
+  readonly darken: (c: string, amount: number) => string;
+  /** Scales chroma: 0 = grey, 1 = unchanged, >1 = more vivid. */
+  readonly saturate: (c: string, factor: number) => string;
+  /** Rotates hue by `degrees`, keeping perceptual lightness. */
+  readonly rotate: (c: string, degrees: number) => string;
+  /** Replaces alpha. */
+  readonly alpha: (c: string, a: number) => string;
+  /** WCAG relative-luminance contrast ratio (1..21). ≥ 4.5 for body text. */
+  readonly contrast: (a: string, b: string) => number;
+  /** Black or white, whichever reads better on `background`. */
+  readonly readableOn: (background: string) => string;
+};
+//#endregion
+//#region src/utils/emoji.d.ts
+/**
+ * How a grapheme presents, after Unicode's emoji presentation rules
+ * (UTS #51): as a color emoji, as text, or as text when the text font has
+ * the glyph. Layout and the emoji preload use it, and so does the
+ * `missing_emoji_font` lint, so they agree on which characters need the
+ * color emoji font.
+ */
+/**
+ * `"emoji"`: draw from the color emoji font. `"text"`: draw from the text
+ * font (✓ ★ ❯, letters). `"either"`: a pictograph that defaults to text
+ * (❤ ✈ ☀ © ™ without VS16), drawn from the text font when it has the glyph
+ * and from the emoji font when it doesn't, as browsers fall back.
+ */
+type EmojiPresentation = "emoji" | "text" | "either";
+declare function emojiPresentation(grapheme: string): EmojiPresentation;
+//#endregion
+//#region src/utils/gradient.d.ts
+type GradientType = "linear" | "radial" | "conic";
+interface ParsedGradientStop {
+  /** 0..1 along the gradient line / radius / turn. */
+  offset: number;
+  /** Straight sRGB 0..1. */
+  color: Rgba;
+}
+type RadialExtent = "closest-side" | "closest-corner" | "farthest-side" | "farthest-corner";
+interface ParsedGradient {
+  type: GradientType;
+  /** Linear: CSS angle in degrees (0 = to top, 90 = to right, 180 = to bottom). */
+  angle: number;
+  /** Radial / conic center as a fraction of the box (0.5, 0.5 = middle). */
+  center: [number, number];
+  /** Radial: circle or ellipse, sized by `extent` unless `radius` gives px radii. */
+  shape: "circle" | "ellipse";
+  radius?: [number, number];
+  /** Radial size keyword (CSS): where the last stop lands. Default farthest-corner. */
+  extent?: RadialExtent;
+  /** Conic: start angle in degrees (0 = top, clockwise). */
+  from: number;
+  stops: ParsedGradientStop[];
+}
+/** Gradients this renderer draws at most this many stops (extra ones are resampled). */
+declare const MAX_GRADIENT_STOPS = 8;
+declare function isCssGradient(value: unknown): value is string;
+/** Parses a CSS gradient string; `null` when it is not one this engine draws. */
+declare function parseCssGradient(input: string): ParsedGradient | null;
+/** Up to MAX_GRADIENT_STOPS stops: longer lists are resampled evenly. */
+declare function limitGradientStops(stops: ParsedGradientStop[]): ParsedGradientStop[];
+/**
+ * Stops as OKLab + alpha for the GPU. A transparent stop borrows its
+ * neighbor's color, so fading to `transparent` keeps the hue instead of
+ * passing through grey (CSS premultiplied interpolation does the same).
+ */
+declare function gradientStopsToOklab(stops: ParsedGradientStop[]): Array<[number, number, number, number]>;
+type StopInput = string | {
+  color: string;
+  offset: number;
+};
+/**
+ * Writes CSS gradient strings for `background` / `fill`:
+ *
+ * ```ts
+ * Layer.box({ background: Gradient.linear(["#ff5a1f", "#7c3aed"], 135) })
+ * Layer.shape("circle", { fill: Gradient.radial(["#fff", "transparent"]) })
+ * Gradient.conic(["red", "yellow", "lime", "aqua", "blue", "magenta", "red"])
+ * ```
+ * Plain strings work too: `"linear-gradient(to right, #000, #fff 80%)"`.
+ */
+declare const Gradient: {
+  /** `angle` in degrees: 0 = bottom→top, 90 = left→right, 180 = top→bottom (default). */
+  readonly linear: (stops: readonly StopInput[], angle?: number) => string;
+  /** Ellipse to the farthest corner, centered unless `at` ([0..1, 0..1]) says otherwise. */
+  readonly radial: (stops: readonly StopInput[], options?: {
+    at?: [number, number];
+    circle?: boolean;
+    radius?: number;
+  }) => string;
+  /** A sweep around `at`, starting at `from` degrees (0 = top, clockwise). */
+  readonly conic: (stops: readonly StopInput[], options?: {
+    from?: number;
+    at?: [number, number];
+  }) => string;
+  readonly parse: typeof parseCssGradient;
+  readonly is: typeof isCssGradient;
+};
+//#endregion
+//#region src/utils/is-equal.d.ts
+/**
+ * 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
+export { FrameSignal as $, TransitionSchema as $n, isFrameIndex as $r, NormalRelightingOptions as $t, DataTypeVal as A, sampleColorStops as Ai, SignalMathData as An, deserializeSignalData as Ar, MediaTimeRemapInputSchema as At, EmojiPresentation as B, stampResult as Bi, TEXT_LAYER_DEFAULTS as Bn, generateId as Br, NodeId as Bt, DATA_TYPE_EXTENSIONS as C, resolveBoolean as Ci, SignalChannelMeta as Cn, computeVideoCropRenderProps as Cr, MediaSignalRecorder as Ct, DataForType as D, resolveParam as Di, SignalDataSchema as Dn, createVirtualMedia as Dr, MediaSourceSchema as Dt, DEFAULT_MEDIA_DIMENSION as E, resolveNumber as Ei, SignalData as En, createOutputItemSchema as Er, MediaSourceRange as Et, DetectedObject as F, seconds as Fi, SineSignalOptions as Fn, fps as Fr, Milliseconds as Ft, FaceLandmarksOptions as G, TensorPipelineConfig as Gn, getMediaType as Gr, NodeProcessorContext as Gt, ExportResultSchema as H, timeSignal as Hi, TensorDimensions as Hn, getFileDataMetadata as Hr, NodeMetadata as Ht, Effect as I, serializeSignalData as Ii, SingleOutputGeneric as In, frame as Ir, ModerationError as It, FileData as J, TextSpanMark as Jn, handleId as Jr, NodeResultSchema as Jt, FileAsset as K, TextOperationSchema as Kn, getRenderFingerprint as Kr, NodeProcessorParams as Kt, EffectConfig as L, signal as Li, SingleOutputGenericSchema as Ln, frameArraySignal as Lr, ModerationUnrefundableError as Lt, DeflickerOptions as M, sampleMediaSignal as Mi, SignalStats as Mn, extractSvgDimensions as Mr, MediaTimeSignalRemap as Mt, Degrees as N, sampledMediaSourceRange as Ni, SignalStatsSchema as Nn, findSourceAsset as Nr, MediaTimeSignalRemapSchema as Nt, DataType as O, resolveString as Oi, SignalGateData as On, dataTypeColors as Or, MediaTimeRemap as Ot, DepthNormalsOptions as P, sampledMediaSourceTime as Pi, SignalValue as Pn, formatHex as Pr, MeshAudioDeformConfig as Pt, FrameIndex as Q, TrackedObject as Qn, isEqual as Qr, NodeVisualConfigSchema as Qt, EffectConfigValue as R, signalBuilder as Ri, SourceOperationSchema as Rn, frameCount as Rr, MultiOutputGeneric as Rt, ControlNetConditioningOutputs as S, reportRenderDiagnostic as Si, SignalBuilderConfig as Sn, compositionFrameContext as Sr, MediaService as St, DEFAULT_FPS as T, resolveMediaMimeType as Ti, SignalContext as Tn, cosineSignal as Tr, MediaSourceInput as Tt, ExtendedLayer as U, updateClockSignals as Ui, TensorFormat as Un, getFingerprint as Ur, NodeMetadataSchema as Ut, ExportResult as V, takeRenderDiagnostics as Vi, TensorData as Vn, getActiveMediaMetadata as Vr, NodeInputConnection as Vt, ExtendedLayerSchema as W, validateMediaTimeRemap as Wi, TensorNode as Wn, getLeafMediaType as Wr, NodeOperation as Wt, Fps as X, TimelineTransform as Xn, hasOnlySingleSource as Xr, NodeValidationFn as Xt, FileDataSchema as Y, TimelineSegmentSchema as Yn, handleLabel as Yr, NodeRunFunction as Yt, FrameContext as Z, TimelineTransformSchema as Zn, isCssGradient as Zr, NodeVisualConfig as Zt, ColorStopLike as _, pixels as _i, Rgba as _n, XYPosition as _r, MIME_TYPES as _t, AudioExtractorSignalData as a, mediaSourceIsHold as ai, OutputItem as an, VideoLayerTypeSchema as ar, Gradient as at, ConfigSchemaRegistry as b, radians as bi, SegmentationOptions as bn, assertNever as br, MediaOperation as bt, BaseMediaOperationPropsSchema as c, mediaSourceTime as ci, ParsedGradientStop as cn, VideoTextPropsSchema as cr, HandleLabel as ct, Brand as d, nodeId as di, ProgrammaticSignal as dn, VirtualMediaDataSchema as dr, JsonArray as dt, isNormalized as ei, Normalized as en, TransitionType as er, GPUTextureBinding as et, CAPTION_LAYER_DEFAULTS as f, normalizeColorStops as fi, ProgrammaticSignalOptions as fn, VisionConfig as fr, JsonObject as ft, Color as g, parseCssGradient as gi, ResolvedMediaTimeRemap as gn, WritableSignal as gr, MAX_GRADIENT_STOPS as gt, CannyOptions as h, parseCssColor as hi, RenderDiagnostic as hn, VisionVariant as hr, Landmark3D as ht, AnyOutputUnionSchema as i, limitGradientStops as ii, Output as in, VideoLayerType as ir, GlobalCompositeOperation as it, DataTypes as j, sampleFrameMediaSignal as ji, SignalMathDataSchema as jn, emojiPresentation as jr, MediaTimeRemapSchema as jt, DataTypeEnum as k, rgbToOklab as ki, SignalGateDataSchema as kn, degrees as kr, MediaTimeRemapInput as kt, BaseVideoLayerProps as l, mixColors as li, Pixels as ln, VideoTimingPropsSchema as lr, HandleType as lt, COMPOSITOR_DEFAULTS as m, oklabToRgb as mi, Radians as mn, VisionTask as mr, JsonValueSchema as mt, AnimationTypeSchema as n, isValueSignal as ni, ObjectBoundingBox as nn, VideoAnimation as nr, GeneratorSignalData as nt, AudioExtractorSignalDataSchema as o, mediaSourceRange as oi, OutputItemSchema as on, VideoSpatialPropsSchema as or, GradientType as ot, COMPOSITE_OPERATIONS as p, normalized as pi, RadialExtent as pn, VisionNodeSpec as pr, JsonValue as pt, FileAssetSchema as q, TextSpan as qn, gradientStopsToOklab as qr, NodeResult as qt, AnyOutputUnion as r, isVirtualMediaData as ri, OpticalFlowOptions as rn, VideoAnimationSchema as rr, GeneratorSignalDataSchema as rt, BaseMediaOperationProps as s, mediaSourceRate as si, ParsedGradient as sn, VideoStylePropsSchema as sr, HandleId as st, AnimationType as t, isSignal as ti, NormalizedLandmarkList as tn, TransitionTypeSchema as tr, GateSignalOptions as tt, BaseVideoLayerPropsSchema as u, ms as ui, PoseSkeletonOptions as un, VirtualMediaData as ur, HandleTypeVal as ut, ConfigHandle as v, programmaticSignal as vi, SampledMediaSignal as vn, appendOperation as vr, MediaMetadata as vt, DEFAULT_DURATION_MS as w, resolveFrameRequest as wi, SignalChannelMetaSchema as wn, computed as wr, MediaSourceDescriptor as wt, ConnectedInput as x, registerSignalDependency as xi, Signal as xn, checkNodeResultCache as xr, MediaOperationSchema as xt, ConfigHandleSchema as y, progressSignal as yi, Seconds as yn, assertFps as yr, MediaMetadataSchema as yt, EffectDomain as z, sineSignal as zi, StorageService as zn, frameSignal as zr, MultiOutputGenericSchema as zt };
+//# sourceMappingURL=index-9_4X2ro1.d.mts.map