framefields 2.0.2

package/dist/index.d.mts

@@ -0,0 +1,4425 @@
+import "./chunk-GMkBE123.mjs";
+import { $ as AudioExtractorSignalData, $n as TEXT_LAYER_DEFAULTS, $r as isEqual, $t as MediaMetadata, An as ProgrammaticSignal, Ar as WritableSignal, At as ExportResultSchema, B as loadModel3D, Bn as SignalDataSchema, Br as deserializeSignalData, Bt as GPUTextureBinding, C as Path3D, Cn as NormalizedLandmarkList, Cr as VideoTimingPropsSchema, Ct as DeflickerOptions, D as SSAOPipeline, Dn as OutputItem, Dr as VisionNodeSpec, Dt as EffectConfig, E as Renderer3D, En as Output, Er as VisionConfig, Et as Effect$1, Fn as SignalBuilderConfig, Fr as computed, Ft as FileAssetSchema, G as parseOBJ, Gn as SignalStats, Gr as generateId, Gt as HandleType, H as lutStore, Hn as SignalGateDataSchema, Hr as findSourceAsset, Ht as GeneratorSignalData, I as ensureDevice, In as SignalChannelMeta, Ir as cosineSignal, It as FileData, J as textureCache, Jn as SineSignalOptions, Jr as getFingerprint, Jt as JsonObject, K as shaderStore, Kn as SignalStatsSchema, Kr as getActiveMediaMetadata, Kt as HandleTypeVal, Ln as SignalChannelMetaSchema, Lr as createOutputItemSchema, Lt as FileDataSchema, M as SlugFontCache, Mn as RenderDiagnostic, Mr as appendOperation, Mt as ExtendedLayerSchema, N as SlugPipeline, Nn as SegmentationOptions, Nr as checkNodeResultCache, Nt as FaceLandmarksOptions, O as ShadowPipeline, On as OutputItemSchema, Or as VisionTask, Ot as EffectConfigValue, Pn as Signal, Pr as computeVideoCropRenderProps, Pt as FileAsset, Q as AnyOutputUnionSchema, Qn as StorageService, Qr as hasOnlySingleSource, Qt as MIME_TYPES, R as inputStore, Rn as SignalContext, Rr as createVirtualMedia, Rt as FrameContext, S as NodeAnimationTrack3D, Sn as NormalRelightingOptions, Sr as VideoTextPropsSchema, St as DataTypes, T as Renderer2D, Tn as OpticalFlowOptions, Tr as VirtualMediaDataSchema, Tt as DetectedObject, U as parseFBX, Un as SignalMathData, Ur as frameArraySignal, Ut as GeneratorSignalDataSchema, V as loadOBJ, Vn as SignalGateData, Vr as extractSvgDimensions, Vt as GateSignalOptions, W as parseMTL, Wn as SignalMathDataSchema, Wr as frameSignal, Wt as GlobalCompositeOperation, X as AnimationTypeSchema, Xn as SingleOutputGenericSchema, Xr as getMediaType, Xt as JsonValueSchema, Y as AnimationType, Yn as SingleOutputGeneric, Yr as getLeafMediaType, Yt as JsonValue, Z as AnyOutputUnion, Zn as SourceOperationSchema, Zr as getRenderFingerprint, Zt as Landmark3D, _n as NodeResultSchema, _r as VideoAnimationSchema, _t as DEFAULT_MEDIA_DIMENSION, a as AudioMeshDeformPipeline, ai as reportRenderDiagnostic, an as MediaSourceInput, ar as TextOperationSchema, at as CAPTION_LAYER_DEFAULTS, b as Model3DData, bn as NodeVisualConfig, br as VideoSpatialPropsSchema, bt as DataTypeEnum, c as BlendMode, ci as signal, cn as ModerationError, cr as TimelineSegmentSchema, ct as CannyOptions, d as EffectPipeline, di as stampResult, dn as MultiOutputGenericSchema, dr as TrackedObject, dt as ConfigSchemaRegistry, ei as isSignal, en as MediaMetadataSchema, er as TensorData, et as AudioExtractorSignalDataSchema, f as GPULightData, fi as takeRenderDiagnostics, fn as NodeMetadata, fr as Transition, ft as ConnectedInput, g as LoadModelOptions, gn as NodeResult, gr as VideoAnimation, gt as DEFAULT_FPS, h as Light3DOptions, hn as NodeProcessorParams, hr as TransitionTypeSchema, ht as DEFAULT_DURATION_MS, i as AudioLatentTrackCache, ii as registerSignalDependency, in as MediaSourceDescriptor, ir as TensorPipelineConfig, it as BaseVideoLayerPropsSchema, j as Skeleton3D, jn as ProgrammaticSignalOptions, jr as XYPosition, jt as ExtendedLayer, kn as PoseSkeletonOptions, kr as VisionVariant, kt as ExportResult, l as Bone3D, li as signalBuilder, ln as ModerationUnrefundableError, lr as TimelineTransform, lt as ConfigHandle, m as Light3D, mi as updateClockSignals, mn as NodeProcessorContext, mr as TransitionType, mt as DATA_TYPE_EXTENSIONS, n as AudioLatentData, ni as programmaticSignal, nn as MediaOperationSchema, nr as TensorFormat, nt as BaseMediaOperationPropsSchema, oi as resolveMediaMimeType, on as MediaSourceSchema, or as TextSpan, ot as COMPOSITE_OPERATIONS, p as GlassPipeline, pi as timeSignal, pn as NodeMetadataSchema, pr as TransitionSchema, pt as ControlNetConditioningOutputs, q as signalRegistry, qn as SignalValue, qr as getFileDataMetadata, qt as JsonArray, r as AudioLatentEngine, ri as progressSignal, rn as MediaService, rr as TensorNode, rt as BaseVideoLayerProps, si as serializeSignalData, sn as MeshAudioDeformConfig, sr as TextSpanMark, st as COMPOSITOR_DEFAULTS, t as AnimationClip3D, ti as isVirtualMediaData, tn as MediaOperation, tr as TensorDimensions, tt as BaseMediaOperationProps, u as Camera3D, ui as sineSignal, un as MultiOutputGeneric, ur as TimelineTransformSchema, ut as ConfigHandleSchema, v as Material3D, vn as NodeRunFunction, vr as VideoLayerType, vt as DataForType, w as RenderContextValue, wn as ObjectBoundingBox, wr as VirtualMediaData, wt as DepthNormalsOptions, x as MotionBlurPipeline, xn as NodeVisualConfigSchema, xr as VideoStylePropsSchema, xt as DataTypeVal, y as Mesh3DData, yn as NodeValidationFn, yr as VideoLayerTypeSchema, yt as DataType, z as loadFBX, zn as SignalData, zr as dataTypeColors, zt as FrameSignal } from "./index-D2jDC7O5.mjs";
+import { a as SfxTrigger, c as softLimit, g as mixAudioTracks, i as SfxRenderContext, n as encodeStereoWav, o as mixSfxInto, r as RenderedSfx, s as renderSfx } from "./index-D2wJqSl5.mjs";
+import "./index-BMVVmc4G.mjs";
+import "./renderer-DDp7_TUi.mjs";
+import { $ as Blur, A as MotionBlur, At as TemporalObjectTracker, B as SelectiveColorProps, Bt as DepthNormalsComputePipeline, C as HighPass, Ct as PinToObjectOptions, D as LevelsProps, Dt as SegmentationResult, E as Levels, Et as PoseSkeletonRenderer, F as Relight3DProps, Ft as analyzeSequence, G as TileOffsetEdgeMode, Gt as TensorViewExport, H as ShadowsHighlightsProps, Ht as TemporalDeflickerPipeline, I as SSAO, It as pinNodeToLandmark, J as UnsharpMaskProps, K as TileOffsetProps, L as SSAOProps, Lt as pinNodeToObject, M as PBRGlass, Mt as VisionBundle, N as PBRGlassProps, Nt as VisionNode, O as Modulate, Ot as SegmentationTexturePool, P as Relight3D, Pt as VisionRunner, R as SelectiveColor, Rt as CannyComputePipeline, S as HalftoneScreenProps, St as PinToLandmarkOptions, T as LevelChannel, Tt as PoseResult, U as TemporalDeflicker, Ut as TensorPipeline, V as ShadowsHighlights, Vt as OpticalFlowComputePipeline, W as TileOffset, Wt as TensorSource, X as VisionProps, Y as Vision, _ as GradientMapProps, _t as ObjectBoundingBoxSignals, a as Crop, b as HalftoneMode, bt as ObjectTrackSignals, c as CurvesChannelPoint, ct as COCO17_BONES, d as DeflickerProps, dt as COCO_CLASSES, et as BlurProps, f as DepthOfField, ft as InstanceMask, g as GradientMap, gt as ObjectAnchorsSignals, h as FilmGrainProps, ht as ObjectAnchorName, i as AudioSignalExtractorProps, it as ColorKeyProps, j as MotionBlurProps, jt as VisionAnalysisReport, k as ModulateProps, kt as SpatialLandmarkTransformer, l as CurvesProps, lt as COCO17_KEYPOINTS, m as FilmGrain, mt as MaskTrackSignals, n as ApplyLUTProps, nt as ColorBalanceProps, o as CropProps, ot as Vignette, p as DepthOfFieldProps, pt as LandmarkCoordinateSignals, q as UnsharpMask, r as AudioSignalExtractor, rt as ColorKey, s as Curves, st as VignetteProps, t as ApplyLUT, tt as ColorBalance, u as CustomEffect, ut as COCO17_KEYPOINT_NAMES, v as GradientMapStop, vt as ObjectCollectionSignals, w as HighPassProps, wt as PoseLandmarkSignals, x as HalftoneScreen, xt as PersonMatte, y as HalftoneDotShape, yt as ObjectKinematicsSignals, z as SelectiveColorAdjustment, zt as ControlNetMultiplexer } from "./index-B0BNPEoH.mjs";
+import { n as AudioSignalOptions, r as ExtractedAudioSignalsBundle, t as AudioSignal } from "./audio-Dvwwz8xU.mjs";
+import { n as RegisterFontOptions, r as RegisteredFont, t as FontManager } from "./index-DiSKzDGR.mjs";
+import "./index-D1ZsMpke.mjs";
+import { a as renderFrameGrid, c as HeadlessMediaRenderer, d as QaSegment, f as VideoQaOptions, g as renderSemaphore, h as formatQaReport, i as computeGridLayout, l as HeadlessWebGPURenderer, m as VideoQaStats, n as FrameGridRenderable, o as resolveSamplePoints, p as VideoQaReport, r as FrameSamplePoint, s as AudioQaStats, t as FrameGridOptions, u as QaIssue } from "./index-DKFGNyMB.mjs";
+import { PreviewCloseReason, PreviewOptions, PreviewSession, PreviewSource, startPreview } from "./preview/index.mjs";
+import { z } from "zod";
+import { Yoga } from "yoga-layout/load";
+
+//#region src/rich-text.d.ts
+type TextSpanItem = string | number | boolean | Signal<unknown> | TextSpan | (string | TextSpan)[] | null | undefined;
+/**
+ * Tagged template literal for authoring rich, multi-style text runs.
+ *
+ * Interpolates strings, numbers, reactive signals, and typed span modifiers
+ * directly into a structured TextSpan[] array with zero runtime parsing.
+ *
+ * @example
+ * rich`Scale ${bold("10x", { fill: "#6366f1" })} faster with ${mark("120 FPS", { bg: "#10b98133" })}`
+ */
+declare function rich(strings: TemplateStringsArray, ...values: TextSpanItem[]): TextSpan[];
+declare function span(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function bold(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function italic(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function accent(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function color(text: string | Signal<string>, fill: string | Signal<string>, options?: Omit<TextSpan, "text" | "fill">): TextSpan;
+declare function size(text: string | Signal<string>, fontSize: number | Signal<number>, options?: Omit<TextSpan, "text" | "fontSize">): TextSpan;
+interface MarkOptions extends Omit<TextSpan, "text" | "mark" | "fill"> {
+  bg?: string | Signal<string>;
+  fill?: string | Signal<string>;
+  radius?: number;
+  paddingX?: number;
+  paddingY?: number;
+}
+declare function mark(text: string | Signal<string>, options?: MarkOptions): TextSpan;
+declare function sup(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function sub(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function code(text: string | Signal<string>, options?: Omit<TextSpan, "text">): TextSpan;
+/**
+ * Normalizes string, TextSpan[], or array of mixed strings/spans into plain text and spans.
+ */
+declare function normalizeTextSpans(input: string | TextSpan[] | (string | TextSpan)[]): {
+  text: string;
+  spans?: TextSpan[];
+};
+/**
+ * Upfront parser for external CMS or subtitle strings containing basic tags
+ * (<b>, <i>, <span>, <color>, <mark>, <accent>, <code>, <sup>, <sub>).
+ *
+ * Compiles string markup into clean TextSpan[] before entering the composition pipeline.
+ */
+declare function parseMarkup(markup: string): TextSpan[];
+//#endregion
+//#region ../compositions/dist/program/index.d.mts
+//#region src/program/text-animations/advanced-types.d.ts
+declare const AnchorGroupingSchema: z.ZodEnum<{
+  character: "character";
+  word: "word";
+  line: "line";
+  all: "all";
+}>;
+type AnchorGrouping = z.infer<typeof AnchorGroupingSchema>;
+declare const AnchorPresetSchema: z.ZodEnum<{
+  custom: "custom";
+  center: "center";
+  baseline: "baseline";
+  bottom_left: "bottom_left";
+  bottom_center: "bottom_center";
+  bottom_right: "bottom_right";
+  top_left: "top_left";
+  top_center: "top_center";
+  top_right: "top_right";
+}>;
+type AnchorPreset = z.infer<typeof AnchorPresetSchema>;
+declare const TextAnchorConfigSchema: z.ZodObject<{
+  grouping: z.ZodDefault<z.ZodEnum<{
+    character: "character";
+    word: "word";
+    line: "line";
+    all: "all";
+  }>>;
+  preset: z.ZodDefault<z.ZodEnum<{
+    custom: "custom";
+    center: "center";
+    baseline: "baseline";
+    bottom_left: "bottom_left";
+    bottom_center: "bottom_center";
+    bottom_right: "bottom_right";
+    top_left: "top_left";
+    top_center: "top_center";
+    top_right: "top_right";
+  }>>;
+  anchorX: z.ZodDefault<z.ZodNumber>;
+  anchorY: z.ZodDefault<z.ZodNumber>;
+  offsetX: z.ZodDefault<z.ZodNumber>;
+  offsetY: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type TextAnchorConfig = z.infer<typeof TextAnchorConfigSchema>;
+declare const SkewPropertiesSchema: z.ZodObject<{
+  skew: z.ZodNumber;
+  skewAxis: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type SkewProperties = z.infer<typeof SkewPropertiesSchema>;
+declare const LineSpacingDynamicsSchema: z.ZodObject<{
+  lineSpacing: z.ZodNumber;
+  lineAnchor: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type LineSpacingDynamics = z.infer<typeof LineSpacingDynamicsSchema>;
+declare const VolumetricFormationModeSchema: z.ZodEnum<{
+  planar: "planar";
+  vortex: "vortex";
+  cylinder: "cylinder";
+  helix: "helix";
+}>;
+type VolumetricFormationMode = z.infer<typeof VolumetricFormationModeSchema>;
+declare const VolumetricFormationConfigSchema: z.ZodObject<{
+  mode: z.ZodDefault<z.ZodEnum<{
+    planar: "planar";
+    vortex: "vortex";
+    cylinder: "cylinder";
+    helix: "helix";
+  }>>;
+  radius: z.ZodDefault<z.ZodNumber>;
+  pitch: z.ZodDefault<z.ZodNumber>;
+  totalAngle: z.ZodDefault<z.ZodNumber>;
+  axis: z.ZodDefault<z.ZodEnum<{
+    x: "x";
+    y: "y";
+    z: "z";
+  }>>;
+  perspective: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type VolumetricFormationConfig = z.infer<typeof VolumetricFormationConfigSchema>;
+declare const Spatial3DPropertiesSchema: z.ZodObject<{
+  translateZ: z.ZodOptional<z.ZodNumber>;
+  rotationX: z.ZodOptional<z.ZodNumber>;
+  rotationY: z.ZodOptional<z.ZodNumber>;
+  rotationZ: z.ZodOptional<z.ZodNumber>;
+  formation: z.ZodOptional<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+      planar: "planar";
+      vortex: "vortex";
+      cylinder: "cylinder";
+      helix: "helix";
+    }>>;
+    radius: z.ZodDefault<z.ZodNumber>;
+    pitch: z.ZodDefault<z.ZodNumber>;
+    totalAngle: z.ZodDefault<z.ZodNumber>;
+    axis: z.ZodDefault<z.ZodEnum<{
+      x: "x";
+      y: "y";
+      z: "z";
+    }>>;
+    perspective: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Spatial3DProperties = z.infer<typeof Spatial3DPropertiesSchema>;
+declare const SpringPhysicsSchema: z.ZodObject<{
+  stiffness: z.ZodDefault<z.ZodNumber>;
+  damping: z.ZodDefault<z.ZodNumber>;
+  mass: z.ZodDefault<z.ZodNumber>;
+  initialVelocity: z.ZodDefault<z.ZodNumber>;
+  overshootMultiplier: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type SpringPhysics = z.infer<typeof SpringPhysicsSchema>;
+interface ExpressionEvaluationContext {
+  /** 0-based index of the current character */
+  charIndex: number;
+  /** 0-based index of the current word */
+  wordIndex: number;
+  /** 0-based index of the current line */
+  lineIndex: number;
+  /** Total count of characters in paragraph */
+  totalChars: number;
+  /** Total count of words in paragraph */
+  totalWords: number;
+  /** Total count of lines in paragraph */
+  totalLines: number;
+  /** Current timeline frame number */
+  frame: number;
+  /** Timeline frame rate */
+  fps: number;
+  /** Current timeline timestamp in seconds */
+  time: number;
+  /** Bound reactive signals map */
+  signals?: Record<string, unknown>;
+}
+declare const ExpressionSelectorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"expression">;
+  name: z.ZodOptional<z.ZodString>;
+  expression: z.ZodString;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+  amount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ExpressionSelector = z.infer<typeof ExpressionSelectorSchema>;
+declare const DynamicStrokePropertiesSchema: z.ZodObject<{
+  strokeWidth: z.ZodDefault<z.ZodNumber>;
+  strokeColor: z.ZodDefault<z.ZodString>;
+  strokeAlign: z.ZodDefault<z.ZodEnum<{
+    inside: "inside";
+    center: "center";
+    outside: "outside";
+  }>>;
+  fillOpacity: z.ZodDefault<z.ZodNumber>;
+  dashArray: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+  dashOffset: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type DynamicStrokeProperties = z.infer<typeof DynamicStrokePropertiesSchema>;
+declare const KineticMarqueeConfigSchema: z.ZodObject<{
+  direction: z.ZodDefault<z.ZodEnum<{
+    left: "left";
+    right: "right";
+    up: "up";
+    down: "down";
+  }>>;
+  velocity: z.ZodDefault<z.ZodNumber>;
+  loop: z.ZodDefault<z.ZodBoolean>;
+  repeatGap: z.ZodDefault<z.ZodNumber>;
+  snap: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    granularity: z.ZodDefault<z.ZodEnum<{
+      character: "character";
+      word: "word";
+      line: "line";
+    }>>;
+    stopIndex: z.ZodDefault<z.ZodNumber>;
+    decelEase: z.ZodDefault<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type KineticMarqueeConfig = z.infer<typeof KineticMarqueeConfigSchema>;
+declare const VariableFontAxesSchema: z.ZodObject<{
+  weight: z.ZodOptional<z.ZodNumber>;
+  width: z.ZodOptional<z.ZodNumber>;
+  slant: z.ZodOptional<z.ZodNumber>;
+  italic: z.ZodOptional<z.ZodNumber>;
+  opticalSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type VariableFontAxes = z.infer<typeof VariableFontAxesSchema>;
+declare const ChromaticGlitchConfigSchema: z.ZodObject<{
+  redShiftX: z.ZodDefault<z.ZodNumber>;
+  redShiftY: z.ZodDefault<z.ZodNumber>;
+  blueShiftX: z.ZodDefault<z.ZodNumber>;
+  blueShiftY: z.ZodDefault<z.ZodNumber>;
+  sliceProbability: z.ZodDefault<z.ZodNumber>;
+  sliceAmplitude: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ChromaticGlitchConfig = z.infer<typeof ChromaticGlitchConfigSchema>;
+declare const AudioSpectrumTypographySchema: z.ZodObject<{
+  signalChannel: z.ZodString;
+  minFreqHz: z.ZodDefault<z.ZodNumber>;
+  maxFreqHz: z.ZodDefault<z.ZodNumber>;
+  scaleAxis: z.ZodDefault<z.ZodEnum<{
+    y: "y";
+    scale: "scale";
+    scaleX: "scaleX";
+    scaleY: "scaleY";
+  }>>;
+  minScale: z.ZodDefault<z.ZodNumber>;
+  maxScale: z.ZodDefault<z.ZodNumber>;
+  peakDecay: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type AudioSpectrumTypography = z.infer<typeof AudioSpectrumTypographySchema>;
+declare const LongShadowConfigSchema: z.ZodObject<{
+  angle: z.ZodDefault<z.ZodNumber>;
+  length: z.ZodDefault<z.ZodNumber>;
+  color: z.ZodDefault<z.ZodString>;
+  startOpacity: z.ZodDefault<z.ZodNumber>;
+  endOpacity: z.ZodDefault<z.ZodNumber>;
+  steps: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type LongShadowConfig = z.infer<typeof LongShadowConfigSchema>;
+declare const ParticleDissolveConfigSchema: z.ZodObject<{
+  progress: z.ZodDefault<z.ZodNumber>;
+  dispersalAngle: z.ZodDefault<z.ZodNumber>;
+  maxDisplacement: z.ZodDefault<z.ZodNumber>;
+  turbulence: z.ZodDefault<z.ZodNumber>;
+  particleSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ParticleDissolveConfig = z.infer<typeof ParticleDissolveConfigSchema>;
+declare const ExtendedGlyphPropertiesSchema: z.ZodObject<{
+  x: z.ZodOptional<z.ZodNumber>;
+  y: z.ZodOptional<z.ZodNumber>;
+  translateZ: z.ZodOptional<z.ZodNumber>;
+  scale: z.ZodOptional<z.ZodNumber>;
+  scaleX: z.ZodOptional<z.ZodNumber>;
+  scaleY: z.ZodOptional<z.ZodNumber>;
+  rotation: z.ZodOptional<z.ZodNumber>;
+  rotationX: z.ZodOptional<z.ZodNumber>;
+  rotationY: z.ZodOptional<z.ZodNumber>;
+  rotationZ: z.ZodOptional<z.ZodNumber>;
+  formation: z.ZodOptional<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+      planar: "planar";
+      vortex: "vortex";
+      cylinder: "cylinder";
+      helix: "helix";
+    }>>;
+    radius: z.ZodDefault<z.ZodNumber>;
+    pitch: z.ZodDefault<z.ZodNumber>;
+    totalAngle: z.ZodDefault<z.ZodNumber>;
+    axis: z.ZodDefault<z.ZodEnum<{
+      x: "x";
+      y: "y";
+      z: "z";
+    }>>;
+    perspective: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  skew: z.ZodOptional<z.ZodNumber>;
+  skewAxis: z.ZodOptional<z.ZodNumber>;
+  tracking: z.ZodOptional<z.ZodNumber>;
+  lineSpacing: z.ZodOptional<z.ZodNumber>;
+  lineAnchor: z.ZodOptional<z.ZodNumber>;
+  anchor: z.ZodOptional<z.ZodObject<{
+    grouping: z.ZodDefault<z.ZodEnum<{
+      character: "character";
+      word: "word";
+      line: "line";
+      all: "all";
+    }>>;
+    preset: z.ZodDefault<z.ZodEnum<{
+      custom: "custom";
+      center: "center";
+      baseline: "baseline";
+      bottom_left: "bottom_left";
+      bottom_center: "bottom_center";
+      bottom_right: "bottom_right";
+      top_left: "top_left";
+      top_center: "top_center";
+      top_right: "top_right";
+    }>>;
+    anchorX: z.ZodDefault<z.ZodNumber>;
+    anchorY: z.ZodDefault<z.ZodNumber>;
+    offsetX: z.ZodDefault<z.ZodNumber>;
+    offsetY: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  opacity: z.ZodOptional<z.ZodNumber>;
+  blur: z.ZodOptional<z.ZodNumber>;
+  fillColor: z.ZodOptional<z.ZodString>;
+  stroke: z.ZodOptional<z.ZodObject<{
+    strokeWidth: z.ZodDefault<z.ZodNumber>;
+    strokeColor: z.ZodDefault<z.ZodString>;
+    strokeAlign: z.ZodDefault<z.ZodEnum<{
+      inside: "inside";
+      center: "center";
+      outside: "outside";
+    }>>;
+    fillOpacity: z.ZodDefault<z.ZodNumber>;
+    dashArray: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    dashOffset: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  variableAxes: z.ZodOptional<z.ZodObject<{
+    weight: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    slant: z.ZodOptional<z.ZodNumber>;
+    italic: z.ZodOptional<z.ZodNumber>;
+    opticalSize: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  chromaticGlitch: z.ZodOptional<z.ZodObject<{
+    redShiftX: z.ZodDefault<z.ZodNumber>;
+    redShiftY: z.ZodDefault<z.ZodNumber>;
+    blueShiftX: z.ZodDefault<z.ZodNumber>;
+    blueShiftY: z.ZodDefault<z.ZodNumber>;
+    sliceProbability: z.ZodDefault<z.ZodNumber>;
+    sliceAmplitude: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  longShadow: z.ZodOptional<z.ZodObject<{
+    angle: z.ZodDefault<z.ZodNumber>;
+    length: z.ZodDefault<z.ZodNumber>;
+    color: z.ZodDefault<z.ZodString>;
+    startOpacity: z.ZodDefault<z.ZodNumber>;
+    endOpacity: z.ZodDefault<z.ZodNumber>;
+    steps: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  particleDissolve: z.ZodOptional<z.ZodObject<{
+    progress: z.ZodDefault<z.ZodNumber>;
+    dispersalAngle: z.ZodDefault<z.ZodNumber>;
+    maxDisplacement: z.ZodDefault<z.ZodNumber>;
+    turbulence: z.ZodDefault<z.ZodNumber>;
+    particleSize: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  audioSpectrum: z.ZodOptional<z.ZodObject<{
+    signalChannel: z.ZodString;
+    minFreqHz: z.ZodDefault<z.ZodNumber>;
+    maxFreqHz: z.ZodDefault<z.ZodNumber>;
+    scaleAxis: z.ZodDefault<z.ZodEnum<{
+      y: "y";
+      scale: "scale";
+      scaleX: "scaleX";
+      scaleY: "scaleY";
+    }>>;
+    minScale: z.ZodDefault<z.ZodNumber>;
+    maxScale: z.ZodDefault<z.ZodNumber>;
+    peakDecay: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  spring: z.ZodOptional<z.ZodObject<{
+    stiffness: z.ZodDefault<z.ZodNumber>;
+    damping: z.ZodDefault<z.ZodNumber>;
+    mass: z.ZodDefault<z.ZodNumber>;
+    initialVelocity: z.ZodDefault<z.ZodNumber>;
+    overshootMultiplier: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ExtendedGlyphProperties = z.infer<typeof ExtendedGlyphPropertiesSchema>;
+declare const AdvancedTextAnimatorSchema: z.ZodObject<{
+  name: z.ZodDefault<z.ZodString>;
+  selectors: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  props: z.ZodObject<{
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    translateZ: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    scaleX: z.ZodOptional<z.ZodNumber>;
+    scaleY: z.ZodOptional<z.ZodNumber>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    rotationX: z.ZodOptional<z.ZodNumber>;
+    rotationY: z.ZodOptional<z.ZodNumber>;
+    rotationZ: z.ZodOptional<z.ZodNumber>;
+    formation: z.ZodOptional<z.ZodObject<{
+      mode: z.ZodDefault<z.ZodEnum<{
+        planar: "planar";
+        vortex: "vortex";
+        cylinder: "cylinder";
+        helix: "helix";
+      }>>;
+      radius: z.ZodDefault<z.ZodNumber>;
+      pitch: z.ZodDefault<z.ZodNumber>;
+      totalAngle: z.ZodDefault<z.ZodNumber>;
+      axis: z.ZodDefault<z.ZodEnum<{
+        x: "x";
+        y: "y";
+        z: "z";
+      }>>;
+      perspective: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    skew: z.ZodOptional<z.ZodNumber>;
+    skewAxis: z.ZodOptional<z.ZodNumber>;
+    tracking: z.ZodOptional<z.ZodNumber>;
+    lineSpacing: z.ZodOptional<z.ZodNumber>;
+    lineAnchor: z.ZodOptional<z.ZodNumber>;
+    anchor: z.ZodOptional<z.ZodObject<{
+      grouping: z.ZodDefault<z.ZodEnum<{
+        character: "character";
+        word: "word";
+        line: "line";
+        all: "all";
+      }>>;
+      preset: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        center: "center";
+        baseline: "baseline";
+        bottom_left: "bottom_left";
+        bottom_center: "bottom_center";
+        bottom_right: "bottom_right";
+        top_left: "top_left";
+        top_center: "top_center";
+        top_right: "top_right";
+      }>>;
+      anchorX: z.ZodDefault<z.ZodNumber>;
+      anchorY: z.ZodDefault<z.ZodNumber>;
+      offsetX: z.ZodDefault<z.ZodNumber>;
+      offsetY: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    blur: z.ZodOptional<z.ZodNumber>;
+    fillColor: z.ZodOptional<z.ZodString>;
+    stroke: z.ZodOptional<z.ZodObject<{
+      strokeWidth: z.ZodDefault<z.ZodNumber>;
+      strokeColor: z.ZodDefault<z.ZodString>;
+      strokeAlign: z.ZodDefault<z.ZodEnum<{
+        inside: "inside";
+        center: "center";
+        outside: "outside";
+      }>>;
+      fillOpacity: z.ZodDefault<z.ZodNumber>;
+      dashArray: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+      dashOffset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    variableAxes: z.ZodOptional<z.ZodObject<{
+      weight: z.ZodOptional<z.ZodNumber>;
+      width: z.ZodOptional<z.ZodNumber>;
+      slant: z.ZodOptional<z.ZodNumber>;
+      italic: z.ZodOptional<z.ZodNumber>;
+      opticalSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    chromaticGlitch: z.ZodOptional<z.ZodObject<{
+      redShiftX: z.ZodDefault<z.ZodNumber>;
+      redShiftY: z.ZodDefault<z.ZodNumber>;
+      blueShiftX: z.ZodDefault<z.ZodNumber>;
+      blueShiftY: z.ZodDefault<z.ZodNumber>;
+      sliceProbability: z.ZodDefault<z.ZodNumber>;
+      sliceAmplitude: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    longShadow: z.ZodOptional<z.ZodObject<{
+      angle: z.ZodDefault<z.ZodNumber>;
+      length: z.ZodDefault<z.ZodNumber>;
+      color: z.ZodDefault<z.ZodString>;
+      startOpacity: z.ZodDefault<z.ZodNumber>;
+      endOpacity: z.ZodDefault<z.ZodNumber>;
+      steps: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    particleDissolve: z.ZodOptional<z.ZodObject<{
+      progress: z.ZodDefault<z.ZodNumber>;
+      dispersalAngle: z.ZodDefault<z.ZodNumber>;
+      maxDisplacement: z.ZodDefault<z.ZodNumber>;
+      turbulence: z.ZodDefault<z.ZodNumber>;
+      particleSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    audioSpectrum: z.ZodOptional<z.ZodObject<{
+      signalChannel: z.ZodString;
+      minFreqHz: z.ZodDefault<z.ZodNumber>;
+      maxFreqHz: z.ZodDefault<z.ZodNumber>;
+      scaleAxis: z.ZodDefault<z.ZodEnum<{
+        y: "y";
+        scale: "scale";
+        scaleX: "scaleX";
+        scaleY: "scaleY";
+      }>>;
+      minScale: z.ZodDefault<z.ZodNumber>;
+      maxScale: z.ZodDefault<z.ZodNumber>;
+      peakDecay: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    spring: z.ZodOptional<z.ZodObject<{
+      stiffness: z.ZodDefault<z.ZodNumber>;
+      damping: z.ZodDefault<z.ZodNumber>;
+      mass: z.ZodDefault<z.ZodNumber>;
+      initialVelocity: z.ZodDefault<z.ZodNumber>;
+      overshootMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type AdvancedTextAnimator = z.infer<typeof AdvancedTextAnimatorSchema>;
+//#endregion
+//#region src/program/text-animations/advanced-builder.d.ts
+/**
+ * Fluent Builder for Extended Text Animators.
+ */
+declare class AdvancedTextAnimatorBuilder {
+  private readonly name;
+  private props;
+  private selectors;
+  constructor(name: string);
+  static create(name: string): AdvancedTextAnimatorBuilder;
+  /** Directional Skew */
+  skew(angleDeg: number, axisDeg?: number): this;
+  /** Anchor Point Grouping and Preset Pivot */
+  anchor(preset: AnchorPreset, grouping?: AnchorGrouping, offsetX?: number, offsetY?: number): this;
+  /** Custom Anchor Point Coordinates (0 to 1 normalized) */
+  anchorNormalized(ax: number, ay: number, grouping?: AnchorGrouping): this;
+  /** 3D Spatial Z-Depth */
+  translateZ(zPixels: number): this;
+  /** 3D Tilts */
+  tilt3D(rx?: number, ry?: number, rz?: number): this;
+  /** 3D Rotation along X axis */
+  rotationX(deg: number): this;
+  /** 3D Rotation along Y axis */
+  rotationY(deg: number): this;
+  /** 3D Rotation along Z axis */
+  rotationZ(deg: number): this;
+  /** 3D Volumetric Formations */
+  volumetricFormation(mode?: VolumetricFormationMode, radius?: number, pitch?: number, totalAngle?: number, perspective?: number, axis?: "x" | "y" | "z"): this;
+  /** Dynamic Line Spacing (Leading) */
+  lineSpacing(extraLeadingPixels: number, lineAnchor?: number): this;
+  /** Normalized Line Anchor (0=top, 0.5=center, 1=bottom) */
+  lineAnchor(anchor: number): this;
+  /** Inertial Spring Settling Physics */
+  spring(stiffness?: number, damping?: number, mass?: number, initialVelocity?: number): this;
+  /** Dynamic Stroke & Wireframe Properties */
+  stroke(widthPixels: number, color?: string, fillOpacity?: number): this;
+  /** Variable Font Axes */
+  variableFont(axes: VariableFontAxes): this;
+  /** Chromatic Aberration / Cyberpunk Glitch */
+  chromaticGlitch(redShiftX: number, redShiftY?: number, blueShiftX?: number, blueShiftY?: number): this;
+  /** Multi-Band Audio Spectrum Equalizer */
+  audioSpectrum(signalChannel: string, minFreqHz?: number, maxFreqHz?: number, maxScale?: number): this;
+  /** Long Shadow Extrusion */
+  longShadow(angle?: number, length?: number, color?: string, startOpacity?: number, endOpacity?: number, steps?: number): this;
+  /** Particle Dust / Quantum Dissolve */
+  particleDissolve(progress?: number, dispersalAngle?: number, maxDisplacement?: number): this;
+  /** Add Expression Selector */
+  addExpressionSelector(expression: string, mode?: "add" | "subtract" | "intersect"): this;
+  /** Alias for addExpressionSelector */
+  expressionSelector(expression: string, mode?: "add" | "subtract" | "intersect"): this;
+  /** Standard 2D Transforms */
+  x(v: number): this;
+  y(v: number): this;
+  scale(v: number): this;
+  scaleX(v: number): this;
+  scaleY(v: number): this;
+  rotation(deg: number): this;
+  opacity(v: number): this;
+  blur(v: number): this;
+  fillColor(hex: string): this;
+  build(): {
+    name: string;
+    selectors: (ExpressionSelector | Record<string, unknown>)[];
+    props: ExtendedGlyphProperties;
+  };
+}
+//#endregion
+//#region src/program/text-animations/types.d.ts
+declare const Vec2Schema: z.ZodObject<{
+  x: z.ZodNumber;
+  y: z.ZodNumber;
+}, z.core.$strip>;
+type Vec2 = z.infer<typeof Vec2Schema>;
+declare const CubicBezierSegmentSchema: z.ZodObject<{
+  p0: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>;
+  p1: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>;
+  p2: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>;
+  p3: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CubicBezierSegment = z.infer<typeof CubicBezierSegmentSchema>;
+declare const TextPathSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"svg">;
+  d: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"bezier">;
+  segments: z.ZodArray<z.ZodObject<{
+    p0: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>;
+    p1: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>;
+    p2: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>;
+    p3: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"ellipse">;
+  cx: z.ZodNumber;
+  cy: z.ZodNumber;
+  rx: z.ZodNumber;
+  ry: z.ZodNumber;
+  startAngleDeg: z.ZodDefault<z.ZodNumber>;
+  endAngleDeg: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"wave">;
+  startX: z.ZodNumber;
+  startY: z.ZodNumber;
+  length: z.ZodNumber;
+  amplitude: z.ZodNumber;
+  frequency: z.ZodNumber;
+  phaseDeg: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>], "type">;
+type TextPathSource = z.infer<typeof TextPathSourceSchema>;
+declare const TextPathOptionsSchema: z.ZodObject<{
+  path: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"svg">;
+    d: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"bezier">;
+    segments: z.ZodArray<z.ZodObject<{
+      p0: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>;
+      p1: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>;
+      p2: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>;
+      p3: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ellipse">;
+    cx: z.ZodNumber;
+    cy: z.ZodNumber;
+    rx: z.ZodNumber;
+    ry: z.ZodNumber;
+    startAngleDeg: z.ZodDefault<z.ZodNumber>;
+    endAngleDeg: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"wave">;
+    startX: z.ZodNumber;
+    startY: z.ZodNumber;
+    length: z.ZodNumber;
+    amplitude: z.ZodNumber;
+    frequency: z.ZodNumber;
+    phaseDeg: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>], "type">;
+  firstMargin: z.ZodDefault<z.ZodNumber>;
+  lastMargin: z.ZodDefault<z.ZodNumber>;
+  reversePath: z.ZodDefault<z.ZodBoolean>;
+  perpendicularToPath: z.ZodDefault<z.ZodBoolean>;
+  forceAlignment: z.ZodDefault<z.ZodBoolean>;
+  loop: z.ZodDefault<z.ZodBoolean>;
+  baselineOffset: z.ZodDefault<z.ZodEnum<{
+    center: "center";
+    baseline: "baseline";
+    ascender: "ascender";
+    descender: "descender";
+  }>>;
+  baselineShift: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type TextPathOptions = z.infer<typeof TextPathOptionsSchema>;
+declare const TextCursorStyleSchema: z.ZodEnum<{
+  custom: "custom";
+  bar: "bar";
+  underscore: "underscore";
+  block: "block";
+}>;
+type TextCursorStyle = z.infer<typeof TextCursorStyleSchema>;
+declare const TextCursorConfigSchema: z.ZodObject<{
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  style: z.ZodDefault<z.ZodEnum<{
+    custom: "custom";
+    bar: "bar";
+    underscore: "underscore";
+    block: "block";
+  }>>;
+  customChar: z.ZodDefault<z.ZodString>;
+  color: z.ZodOptional<z.ZodString>;
+  blinkFrequency: z.ZodDefault<z.ZodNumber>;
+  hideOnComplete: z.ZodDefault<z.ZodBoolean>;
+  width: z.ZodDefault<z.ZodNumber>;
+  spacing: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type TextCursorConfig = z.infer<typeof TextCursorConfigSchema>;
+declare const TypingCadenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  mode: z.ZodLiteral<"constant">;
+}, z.core.$strip>, z.ZodObject<{
+  mode: z.ZodLiteral<"human">;
+  jitter: z.ZodDefault<z.ZodNumber>;
+  commaPauseMultiplier: z.ZodDefault<z.ZodNumber>;
+  sentencePauseMultiplier: z.ZodDefault<z.ZodNumber>;
+  paragraphPauseMultiplier: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>], "mode">;
+type TypingCadence = z.infer<typeof TypingCadenceSchema>;
+declare const TextScrambleConfigSchema: z.ZodObject<{
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  charset: z.ZodDefault<z.ZodEnum<{
+    custom: "custom";
+    ascii: "ascii";
+    alphanumeric: "alphanumeric";
+    matrix: "matrix";
+    binary: "binary";
+    hex: "hex";
+  }>>;
+  customCharset: z.ZodOptional<z.ZodString>;
+  scrambleFramesPerChar: z.ZodDefault<z.ZodNumber>;
+  highlightProbability: z.ZodDefault<z.ZodNumber>;
+  scrambleColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TextScrambleConfig = z.infer<typeof TextScrambleConfigSchema>;
+declare const TypewriterAnimatorSchema: z.ZodObject<{
+  granularity: z.ZodDefault<z.ZodEnum<{
+    character: "character";
+    word: "word";
+    line: "line";
+  }>>;
+  cursor: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    style: z.ZodDefault<z.ZodEnum<{
+      custom: "custom";
+      bar: "bar";
+      underscore: "underscore";
+      block: "block";
+    }>>;
+    customChar: z.ZodDefault<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    blinkFrequency: z.ZodDefault<z.ZodNumber>;
+    hideOnComplete: z.ZodDefault<z.ZodBoolean>;
+    width: z.ZodDefault<z.ZodNumber>;
+    spacing: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  cadence: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"constant">;
+  }, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"human">;
+    jitter: z.ZodDefault<z.ZodNumber>;
+    commaPauseMultiplier: z.ZodDefault<z.ZodNumber>;
+    sentencePauseMultiplier: z.ZodDefault<z.ZodNumber>;
+    paragraphPauseMultiplier: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>], "mode">>;
+  scramble: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    charset: z.ZodDefault<z.ZodEnum<{
+      custom: "custom";
+      ascii: "ascii";
+      alphanumeric: "alphanumeric";
+      matrix: "matrix";
+      binary: "binary";
+      hex: "hex";
+    }>>;
+    customCharset: z.ZodOptional<z.ZodString>;
+    scrambleFramesPerChar: z.ZodDefault<z.ZodNumber>;
+    highlightProbability: z.ZodDefault<z.ZodNumber>;
+    scrambleColor: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  soundSync: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type TypewriterAnimator = z.infer<typeof TypewriterAnimatorSchema>;
+declare const SelectorBasedOnSchema: z.ZodEnum<{
+  characters: "characters";
+  characters_excluding_spaces: "characters_excluding_spaces";
+  words: "words";
+  lines: "lines";
+}>;
+type SelectorBasedOn = z.infer<typeof SelectorBasedOnSchema>;
+declare const SelectorUnitsSchema: z.ZodEnum<{
+  percentage: "percentage";
+  index: "index";
+}>;
+type SelectorUnits = z.infer<typeof SelectorUnitsSchema>;
+declare const SelectorShapeSchema: z.ZodEnum<{
+  round: "round";
+  square: "square";
+  ramp_up: "ramp_up";
+  ramp_down: "ramp_down";
+  triangle: "triangle";
+  smooth: "smooth";
+}>;
+type SelectorShape = z.infer<typeof SelectorShapeSchema>;
+declare const SelectorModeSchema: z.ZodEnum<{
+  difference: "difference";
+  add: "add";
+  subtract: "subtract";
+  intersect: "intersect";
+  min: "min";
+  max: "max";
+}>;
+type SelectorMode = z.infer<typeof SelectorModeSchema>;
+declare const TextRangeSelectorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"range">;
+  start: z.ZodDefault<z.ZodNumber>;
+  end: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  units: z.ZodDefault<z.ZodEnum<{
+    percentage: "percentage";
+    index: "index";
+  }>>;
+  basedOn: z.ZodDefault<z.ZodEnum<{
+    characters: "characters";
+    characters_excluding_spaces: "characters_excluding_spaces";
+    words: "words";
+    lines: "lines";
+  }>>;
+  shape: z.ZodDefault<z.ZodEnum<{
+    round: "round";
+    square: "square";
+    ramp_up: "ramp_up";
+    ramp_down: "ramp_down";
+    triangle: "triangle";
+    smooth: "smooth";
+  }>>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+  amount: z.ZodDefault<z.ZodNumber>;
+  easeHigh: z.ZodDefault<z.ZodNumber>;
+  easeLow: z.ZodDefault<z.ZodNumber>;
+  randomizeOrder: z.ZodDefault<z.ZodBoolean>;
+  randomSeed: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type TextRangeSelector = z.infer<typeof TextRangeSelectorSchema>;
+declare const TextWigglySelectorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"wiggly">;
+  wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
+  correlation: z.ZodDefault<z.ZodNumber>;
+  temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
+  spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
+  minAmount: z.ZodDefault<z.ZodNumber>;
+  maxAmount: z.ZodDefault<z.ZodNumber>;
+  randomSeed: z.ZodDefault<z.ZodNumber>;
+  basedOn: z.ZodDefault<z.ZodEnum<{
+    characters: "characters";
+    characters_excluding_spaces: "characters_excluding_spaces";
+    words: "words";
+    lines: "lines";
+  }>>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+}, z.core.$strip>;
+type TextWigglySelector = z.infer<typeof TextWigglySelectorSchema>;
+declare const TextSignalSelectorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"signal">;
+  signalId: z.ZodString;
+  multiplier: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  phaseSpread: z.ZodDefault<z.ZodNumber>;
+  basedOn: z.ZodDefault<z.ZodEnum<{
+    characters: "characters";
+    characters_excluding_spaces: "characters_excluding_spaces";
+    words: "words";
+    lines: "lines";
+  }>>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+}, z.core.$strip>;
+type TextSignalSelector = z.infer<typeof TextSignalSelectorSchema>;
+declare const TextSelectorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"range">;
+  start: z.ZodDefault<z.ZodNumber>;
+  end: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  units: z.ZodDefault<z.ZodEnum<{
+    percentage: "percentage";
+    index: "index";
+  }>>;
+  basedOn: z.ZodDefault<z.ZodEnum<{
+    characters: "characters";
+    characters_excluding_spaces: "characters_excluding_spaces";
+    words: "words";
+    lines: "lines";
+  }>>;
+  shape: z.ZodDefault<z.ZodEnum<{
+    round: "round";
+    square: "square";
+    ramp_up: "ramp_up";
+    ramp_down: "ramp_down";
+    triangle: "triangle";
+    smooth: "smooth";
+  }>>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+  amount: z.ZodDefault<z.ZodNumber>;
+  easeHigh: z.ZodDefault<z.ZodNumber>;
+  easeLow: z.ZodDefault<z.ZodNumber>;
+  randomizeOrder: z.ZodDefault<z.ZodBoolean>;
+  randomSeed: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"wiggly">;
+  wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
+  correlation: z.ZodDefault<z.ZodNumber>;
+  temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
+  spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
+  minAmount: z.ZodDefault<z.ZodNumber>;
+  maxAmount: z.ZodDefault<z.ZodNumber>;
+  randomSeed: z.ZodDefault<z.ZodNumber>;
+  basedOn: z.ZodDefault<z.ZodEnum<{
+    characters: "characters";
+    characters_excluding_spaces: "characters_excluding_spaces";
+    words: "words";
+    lines: "lines";
+  }>>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"signal">;
+  signalId: z.ZodString;
+  multiplier: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  phaseSpread: z.ZodDefault<z.ZodNumber>;
+  basedOn: z.ZodDefault<z.ZodEnum<{
+    characters: "characters";
+    characters_excluding_spaces: "characters_excluding_spaces";
+    words: "words";
+    lines: "lines";
+  }>>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    difference: "difference";
+    add: "add";
+    subtract: "subtract";
+    intersect: "intersect";
+    min: "min";
+    max: "max";
+  }>>;
+}, z.core.$strip>], "type">;
+type TextSelector = z.infer<typeof TextSelectorSchema>;
+declare const AnimatableGlyphPropsSchema: z.ZodObject<{
+  x: z.ZodOptional<z.ZodNumber>;
+  y: z.ZodOptional<z.ZodNumber>;
+  z: z.ZodOptional<z.ZodNumber>;
+  scale: z.ZodOptional<z.ZodNumber>;
+  scaleX: z.ZodOptional<z.ZodNumber>;
+  scaleY: z.ZodOptional<z.ZodNumber>;
+  rotation: z.ZodOptional<z.ZodNumber>;
+  rotationX: z.ZodOptional<z.ZodNumber>;
+  rotationY: z.ZodOptional<z.ZodNumber>;
+  skew: z.ZodOptional<z.ZodNumber>;
+  skewAxis: z.ZodOptional<z.ZodNumber>;
+  tracking: z.ZodOptional<z.ZodNumber>;
+  lineSpacing: z.ZodOptional<z.ZodNumber>;
+  opacity: z.ZodOptional<z.ZodNumber>;
+  fillColor: z.ZodOptional<z.ZodString>;
+  strokeColor: z.ZodOptional<z.ZodString>;
+  strokeWidth: z.ZodOptional<z.ZodNumber>;
+  blur: z.ZodOptional<z.ZodNumber>;
+  characterOffset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type AnimatableGlyphProps = z.infer<typeof AnimatableGlyphPropsSchema>;
+declare const GlyphAnchorGroupingSchema: z.ZodEnum<{
+  character: "character";
+  word: "word";
+  line: "line";
+  all: "all";
+}>;
+type GlyphAnchorGrouping = z.infer<typeof GlyphAnchorGroupingSchema>;
+declare const GlyphAnchorPointSchema: z.ZodObject<{
+  grouping: z.ZodDefault<z.ZodEnum<{
+    character: "character";
+    word: "word";
+    line: "line";
+    all: "all";
+  }>>;
+  anchorX: z.ZodDefault<z.ZodNumber>;
+  anchorY: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type GlyphAnchorPoint = z.infer<typeof GlyphAnchorPointSchema>;
+declare const AETextAnimatorSchema: z.ZodObject<{
+  name: z.ZodDefault<z.ZodString>;
+  selectors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"range">;
+    start: z.ZodDefault<z.ZodNumber>;
+    end: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    units: z.ZodDefault<z.ZodEnum<{
+      percentage: "percentage";
+      index: "index";
+    }>>;
+    basedOn: z.ZodDefault<z.ZodEnum<{
+      characters: "characters";
+      characters_excluding_spaces: "characters_excluding_spaces";
+      words: "words";
+      lines: "lines";
+    }>>;
+    shape: z.ZodDefault<z.ZodEnum<{
+      round: "round";
+      square: "square";
+      ramp_up: "ramp_up";
+      ramp_down: "ramp_down";
+      triangle: "triangle";
+      smooth: "smooth";
+    }>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+      difference: "difference";
+      add: "add";
+      subtract: "subtract";
+      intersect: "intersect";
+      min: "min";
+      max: "max";
+    }>>;
+    amount: z.ZodDefault<z.ZodNumber>;
+    easeHigh: z.ZodDefault<z.ZodNumber>;
+    easeLow: z.ZodDefault<z.ZodNumber>;
+    randomizeOrder: z.ZodDefault<z.ZodBoolean>;
+    randomSeed: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"wiggly">;
+    wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
+    correlation: z.ZodDefault<z.ZodNumber>;
+    temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
+    spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
+    minAmount: z.ZodDefault<z.ZodNumber>;
+    maxAmount: z.ZodDefault<z.ZodNumber>;
+    randomSeed: z.ZodDefault<z.ZodNumber>;
+    basedOn: z.ZodDefault<z.ZodEnum<{
+      characters: "characters";
+      characters_excluding_spaces: "characters_excluding_spaces";
+      words: "words";
+      lines: "lines";
+    }>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+      difference: "difference";
+      add: "add";
+      subtract: "subtract";
+      intersect: "intersect";
+      min: "min";
+      max: "max";
+    }>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"signal">;
+    signalId: z.ZodString;
+    multiplier: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    phaseSpread: z.ZodDefault<z.ZodNumber>;
+    basedOn: z.ZodDefault<z.ZodEnum<{
+      characters: "characters";
+      characters_excluding_spaces: "characters_excluding_spaces";
+      words: "words";
+      lines: "lines";
+    }>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+      difference: "difference";
+      add: "add";
+      subtract: "subtract";
+      intersect: "intersect";
+      min: "min";
+      max: "max";
+    }>>;
+  }, z.core.$strip>], "type">>;
+  props: z.ZodObject<{
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    z: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    scaleX: z.ZodOptional<z.ZodNumber>;
+    scaleY: z.ZodOptional<z.ZodNumber>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    rotationX: z.ZodOptional<z.ZodNumber>;
+    rotationY: z.ZodOptional<z.ZodNumber>;
+    skew: z.ZodOptional<z.ZodNumber>;
+    skewAxis: z.ZodOptional<z.ZodNumber>;
+    tracking: z.ZodOptional<z.ZodNumber>;
+    lineSpacing: z.ZodOptional<z.ZodNumber>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    fillColor: z.ZodOptional<z.ZodString>;
+    strokeColor: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    blur: z.ZodOptional<z.ZodNumber>;
+    characterOffset: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  anchor: z.ZodDefault<z.ZodObject<{
+    grouping: z.ZodDefault<z.ZodEnum<{
+      character: "character";
+      word: "word";
+      line: "line";
+      all: "all";
+    }>>;
+    anchorX: z.ZodDefault<z.ZodNumber>;
+    anchorY: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AETextAnimator = z.infer<typeof AETextAnimatorSchema>;
+declare const EnhancedTextNodeSchema: z.ZodObject<{
+  text: z.ZodString;
+  fontFamily: z.ZodDefault<z.ZodString>;
+  fontSize: z.ZodDefault<z.ZodNumber>;
+  fontWeight: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  fill: z.ZodDefault<z.ZodString>;
+  letterSpacing: z.ZodDefault<z.ZodNumber>;
+  lineHeight: z.ZodDefault<z.ZodNumber>;
+  textAlign: z.ZodDefault<z.ZodEnum<{
+    center: "center";
+    left: "left";
+    right: "right";
+  }>>;
+  pathOptions: z.ZodOptional<z.ZodObject<{
+    path: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"svg">;
+      d: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"bezier">;
+      segments: z.ZodArray<z.ZodObject<{
+        p0: z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>;
+        p1: z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>;
+        p2: z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>;
+        p3: z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"ellipse">;
+      cx: z.ZodNumber;
+      cy: z.ZodNumber;
+      rx: z.ZodNumber;
+      ry: z.ZodNumber;
+      startAngleDeg: z.ZodDefault<z.ZodNumber>;
+      endAngleDeg: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"wave">;
+      startX: z.ZodNumber;
+      startY: z.ZodNumber;
+      length: z.ZodNumber;
+      amplitude: z.ZodNumber;
+      frequency: z.ZodNumber;
+      phaseDeg: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>], "type">;
+    firstMargin: z.ZodDefault<z.ZodNumber>;
+    lastMargin: z.ZodDefault<z.ZodNumber>;
+    reversePath: z.ZodDefault<z.ZodBoolean>;
+    perpendicularToPath: z.ZodDefault<z.ZodBoolean>;
+    forceAlignment: z.ZodDefault<z.ZodBoolean>;
+    loop: z.ZodDefault<z.ZodBoolean>;
+    baselineOffset: z.ZodDefault<z.ZodEnum<{
+      center: "center";
+      baseline: "baseline";
+      ascender: "ascender";
+      descender: "descender";
+    }>>;
+    baselineShift: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  typewriter: z.ZodOptional<z.ZodObject<{
+    granularity: z.ZodDefault<z.ZodEnum<{
+      character: "character";
+      word: "word";
+      line: "line";
+    }>>;
+    cursor: z.ZodDefault<z.ZodObject<{
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      style: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        bar: "bar";
+        underscore: "underscore";
+        block: "block";
+      }>>;
+      customChar: z.ZodDefault<z.ZodString>;
+      color: z.ZodOptional<z.ZodString>;
+      blinkFrequency: z.ZodDefault<z.ZodNumber>;
+      hideOnComplete: z.ZodDefault<z.ZodBoolean>;
+      width: z.ZodDefault<z.ZodNumber>;
+      spacing: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    cadence: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      mode: z.ZodLiteral<"constant">;
+    }, z.core.$strip>, z.ZodObject<{
+      mode: z.ZodLiteral<"human">;
+      jitter: z.ZodDefault<z.ZodNumber>;
+      commaPauseMultiplier: z.ZodDefault<z.ZodNumber>;
+      sentencePauseMultiplier: z.ZodDefault<z.ZodNumber>;
+      paragraphPauseMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>], "mode">>;
+    scramble: z.ZodDefault<z.ZodObject<{
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      charset: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        ascii: "ascii";
+        alphanumeric: "alphanumeric";
+        matrix: "matrix";
+        binary: "binary";
+        hex: "hex";
+      }>>;
+      customCharset: z.ZodOptional<z.ZodString>;
+      scrambleFramesPerChar: z.ZodDefault<z.ZodNumber>;
+      highlightProbability: z.ZodDefault<z.ZodNumber>;
+      scrambleColor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    soundSync: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  animators: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodDefault<z.ZodString>;
+    selectors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"range">;
+      start: z.ZodDefault<z.ZodNumber>;
+      end: z.ZodDefault<z.ZodNumber>;
+      offset: z.ZodDefault<z.ZodNumber>;
+      units: z.ZodDefault<z.ZodEnum<{
+        percentage: "percentage";
+        index: "index";
+      }>>;
+      basedOn: z.ZodDefault<z.ZodEnum<{
+        characters: "characters";
+        characters_excluding_spaces: "characters_excluding_spaces";
+        words: "words";
+        lines: "lines";
+      }>>;
+      shape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        square: "square";
+        ramp_up: "ramp_up";
+        ramp_down: "ramp_down";
+        triangle: "triangle";
+        smooth: "smooth";
+      }>>;
+      mode: z.ZodDefault<z.ZodEnum<{
+        difference: "difference";
+        add: "add";
+        subtract: "subtract";
+        intersect: "intersect";
+        min: "min";
+        max: "max";
+      }>>;
+      amount: z.ZodDefault<z.ZodNumber>;
+      easeHigh: z.ZodDefault<z.ZodNumber>;
+      easeLow: z.ZodDefault<z.ZodNumber>;
+      randomizeOrder: z.ZodDefault<z.ZodBoolean>;
+      randomSeed: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"wiggly">;
+      wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
+      correlation: z.ZodDefault<z.ZodNumber>;
+      temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
+      spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
+      minAmount: z.ZodDefault<z.ZodNumber>;
+      maxAmount: z.ZodDefault<z.ZodNumber>;
+      randomSeed: z.ZodDefault<z.ZodNumber>;
+      basedOn: z.ZodDefault<z.ZodEnum<{
+        characters: "characters";
+        characters_excluding_spaces: "characters_excluding_spaces";
+        words: "words";
+        lines: "lines";
+      }>>;
+      mode: z.ZodDefault<z.ZodEnum<{
+        difference: "difference";
+        add: "add";
+        subtract: "subtract";
+        intersect: "intersect";
+        min: "min";
+        max: "max";
+      }>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"signal">;
+      signalId: z.ZodString;
+      multiplier: z.ZodDefault<z.ZodNumber>;
+      offset: z.ZodDefault<z.ZodNumber>;
+      phaseSpread: z.ZodDefault<z.ZodNumber>;
+      basedOn: z.ZodDefault<z.ZodEnum<{
+        characters: "characters";
+        characters_excluding_spaces: "characters_excluding_spaces";
+        words: "words";
+        lines: "lines";
+      }>>;
+      mode: z.ZodDefault<z.ZodEnum<{
+        difference: "difference";
+        add: "add";
+        subtract: "subtract";
+        intersect: "intersect";
+        min: "min";
+        max: "max";
+      }>>;
+    }, z.core.$strip>], "type">>;
+    props: z.ZodObject<{
+      x: z.ZodOptional<z.ZodNumber>;
+      y: z.ZodOptional<z.ZodNumber>;
+      z: z.ZodOptional<z.ZodNumber>;
+      scale: z.ZodOptional<z.ZodNumber>;
+      scaleX: z.ZodOptional<z.ZodNumber>;
+      scaleY: z.ZodOptional<z.ZodNumber>;
+      rotation: z.ZodOptional<z.ZodNumber>;
+      rotationX: z.ZodOptional<z.ZodNumber>;
+      rotationY: z.ZodOptional<z.ZodNumber>;
+      skew: z.ZodOptional<z.ZodNumber>;
+      skewAxis: z.ZodOptional<z.ZodNumber>;
+      tracking: z.ZodOptional<z.ZodNumber>;
+      lineSpacing: z.ZodOptional<z.ZodNumber>;
+      opacity: z.ZodOptional<z.ZodNumber>;
+      fillColor: z.ZodOptional<z.ZodString>;
+      strokeColor: z.ZodOptional<z.ZodString>;
+      strokeWidth: z.ZodOptional<z.ZodNumber>;
+      blur: z.ZodOptional<z.ZodNumber>;
+      characterOffset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    anchor: z.ZodDefault<z.ZodObject<{
+      grouping: z.ZodDefault<z.ZodEnum<{
+        character: "character";
+        word: "word";
+        line: "line";
+        all: "all";
+      }>>;
+      anchorX: z.ZodDefault<z.ZodNumber>;
+      anchorY: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type EnhancedTextNode = z.infer<typeof EnhancedTextNodeSchema>;
+//#endregion
+//#region src/program/text-animations/builder.d.ts
+/**
+ * Fluent builder for creating Path-Following Text configurations.
+ */
+declare class TextPathBuilder {
+  private options;
+  static fromSvg(svgPath: string): TextPathBuilder;
+  static fromBezier(segments: CubicBezierSegment[]): TextPathBuilder;
+  static fromCurve(curve: CubicBezierSegment): TextPathBuilder;
+  static circularBadge(cx: number, cy: number, radius: number): TextPathBuilder;
+  static ellipse(cx: number, cy: number, rx: number, ry: number, startAngleDeg?: number, endAngleDeg?: number): TextPathBuilder;
+  static wave(startX: number, startY: number, length: number, amplitude: number, frequency: number, phaseDeg?: number): TextPathBuilder;
+  firstMargin(margin: number): this;
+  lastMargin(margin: number): this;
+  reversePath(reverse: boolean): this;
+  perpendicularToPath(perpendicular: boolean): this;
+  forceAlignment(force: boolean): this;
+  loop(isLoop: boolean): this;
+  baselineOffset(offset: "baseline" | "center" | "ascender" | "descender"): this;
+  baselineShift(shiftPixels: number): this;
+  build(): TextPathOptions;
+}
+/**
+ * Fluent builder for After Effects Range, Wiggly, and Signal Animators.
+ */
+declare class TextAnimatorBuilder {
+  private name;
+  private selectors;
+  private props;
+  private anchor;
+  static create(name: string): TextAnimatorBuilder;
+  /** Adds an After Effects Range Selector */
+  addRangeSelector(config: {
+    start?: number;
+    end?: number;
+    offset?: number;
+    shape?: SelectorShape;
+    basedOn?: SelectorBasedOn;
+    mode?: SelectorMode;
+    easeHigh?: number;
+    easeLow?: number;
+    randomizeOrder?: boolean;
+    randomSeed?: number;
+  }): this;
+  /** Adds an After Effects Wiggly Selector for procedural organic flutter */
+  addWigglySelector(config: {
+    wigglesPerSecond?: number;
+    correlation?: number;
+    minAmount?: number;
+    maxAmount?: number;
+    randomSeed?: number;
+    mode?: SelectorMode;
+  }): this;
+  /** Adds a reactive signal selector */
+  addSignalSelector(signalId: string, multiplier?: number, phaseSpread?: number, offset?: number, mode?: SelectorMode): this;
+  x(pixels: number): this;
+  y(pixels: number): this;
+  z(pixels: number): this;
+  scale(scaleValue: number): this;
+  scaleX(scaleValue: number): this;
+  scaleY(scaleValue: number): this;
+  rotation(degrees: number): this;
+  rotationX(degrees: number): this;
+  rotationY(degrees: number): this;
+  skew(degrees: number): this;
+  skewAxis(degrees: number): this;
+  opacity(value: number): this;
+  blur(pixels: number): this;
+  fill(colorHex: string): this;
+  fillColor(colorHex: string): this;
+  strokeColor(colorHex: string): this;
+  strokeWidth(pixels: number): this;
+  tracking(spacingPixels: number): this;
+  lineSpacing(spacingPixels: number): this;
+  characterOffset(offset: number): this;
+  anchorGrouping(grouping: GlyphAnchorGrouping, anchorX?: number, anchorY?: number): this;
+  build(): AETextAnimator;
+}
+//#endregion
+//#region src/program/text-animations/math.d.ts
+/**
+ * Evaluates closed-form underdamped harmonic oscillator for spring physics:
+ *
+ *   x(t) = target + (x0 - target) * exp(-zeta * omega_n * t) *
+ *          [ cos(omega_d * t) + (zeta / sqrt(1 - zeta^2)) * sin(omega_d * t) ]
+ *
+ * @param t Time in seconds since excitation
+ * @param stiffness Spring stiffness (k)
+ * @param damping Damping coefficient (c)
+ * @param mass Mass of glyph (m)
+ * @param initialVelocity Initial velocity (v0)
+ * @returns Settled scalar progress in [0, 1] with overshoot
+ */
+declare function evaluateSpringProgress(t: number, stiffness?: number, damping?: number, mass?: number, initialVelocity?: number): number;
+/**
+ * Evaluates 2D Directional Skew matrix components:
+ *
+ *   S(theta, phi) = R(phi) * [ 1  tan(theta) ] * R(-phi)
+ *                            [ 0      1     ]
+ *
+ * @param skewDeg Skew angle in degrees
+ * @param skewAxisDeg Skew axis in degrees
+ * @returns 2x2 affine shear matrix components [m00, m01, m10, m11]
+ */
+declare function evaluateSkewMatrix(skewDeg: number, skewAxisDeg?: number): [number, number, number, number];
+/**
+ * Computes anchor pivot coordinates relative to glyph bounding box:
+ *
+ * @param bbox Glyph bounding box { width, height, ascender, descender }
+ * @param config Text anchor configuration
+ * @returns Pivot offset (px, py) relative to glyph quad center
+ */
+declare function computeAnchorPivotOffset(bbox: {
+  width: number;
+  height: number;
+  ascender: number;
+  descender: number;
+}, config: TextAnchorConfig): {
+  px: number;
+  py: number;
+};
+/**
+ * Computes leading displacement per line based on lineAnchor:
+ *
+ * @param lineIndex 0-based index of current line
+ * @param lineCount Total lines in paragraph
+ * @param lineSpacing Additional leading in pixels
+ * @param lineAnchor Pivot line anchor in [0, 1]
+ * @returns Y displacement in pixels
+ */
+declare function computeLineLeadingDisplacement(lineIndex: number, lineCount: number, lineSpacing: number, lineAnchor?: number): number;
+/**
+ * Evaluates an Expression Selector formula safely in a sandboxed numeric scope.
+ *
+ * @param expression Formula string (e.g. "Math.sin(time * 4 + textIndex * 0.2)")
+ * @param ctx Glyph evaluation context
+ * @returns Numeric selector weight clamped to [-1, 1]
+ */
+declare function evaluateExpressionSelector(expression: string, ctx: ExpressionEvaluationContext): number;
+/**
+ * 3D Volumetric arrangement transformation output.
+ */
+interface Volumetric3DTransform {
+  x: number;
+  y: number;
+  z: number;
+  rotX: number;
+  rotY: number;
+  rotZ: number;
+  scaleMult: number;
+  depthOpacity?: number;
+}
+/**
+ * Evaluates 3D Volumetric Formation parametric coordinates.
+ */
+declare function evaluateVolumetricFormation(glyphIndex: number, totalGlyphs: number, config: VolumetricFormationConfig): Volumetric3DTransform;
+/**
+ * Evaluates infinite kinetic marquee translation and snapping.
+ */
+declare function evaluateMarqueeOffset(baseX: number, containerWidth: number, contentWidth: number, config: KineticMarqueeConfig, elapsedSec: number): number;
+/**
+ * Samples audio FFT frequency bin and computes scale factor for Audio Spectrum Typography.
+ */
+declare function sampleAudioSpectrumScale(glyphIndex: number, totalGlyphs: number, config: AudioSpectrumTypography, signals: Record<string, unknown> | undefined, frame: number, fps: number): number;
+//#endregion
+//#region src/program/text-animations/path.d.ts
+interface ArcLengthLUTEntry {
+  distance: number;
+  t: number;
+}
+interface PathChainLUTEntry {
+  distance: number;
+  segmentIndex: number;
+  t: number;
+}
+interface PathSegmentLUT {
+  segmentIndex: number;
+  startDistance: number;
+  length: number;
+  lut: ArcLengthLUTEntry[];
+}
+interface PathChainLUT {
+  totalLength: number;
+  entries: PathChainLUTEntry[];
+  segments?: PathSegmentLUT[];
+}
+/**
+ * Evaluates a point on a cubic Bezier curve at parameter t in [0, 1].
+ */
+declare function evaluateCubicBezier(segment: CubicBezierSegment, t: number): Vec2;
+/**
+ * Evaluates the first derivative (tangent velocity vector) of a cubic Bezier curve at parameter t.
+ */
+declare function evaluateCubicBezierDerivative(segment: CubicBezierSegment, t: number): Vec2;
+/**
+ * Generates an arc-length parameterization lookup table (LUT) for a cubic Bezier segment.
+ * Ensures glyphs travel with uniform speed and do not bunch up on tight curve bends.
+ */
+declare function generateArcLengthLUT(segment: CubicBezierSegment, samples?: number): {
+  lut: ArcLengthLUTEntry[];
+  totalLength: number;
+};
+/**
+ * Maps a distance along the curve (in pixels) to normalized curve parameter t via binary search on the LUT.
+ */
+declare function distanceToCurveParameter(lut: ArcLengthLUTEntry[], distance: number, totalLength: number): number;
+/**
+ * Samples position and baseline tangent orientation angle along a curve at distance `dist`.
+ */
+declare function sampleCurveGeometry(segment: CubicBezierSegment, lut: ArcLengthLUTEntry[], totalLength: number, distance: number): {
+  position: Vec2;
+  tangentAngleDeg: number;
+  normal: Vec2;
+};
+/**
+ * Builds a cumulative Arc-Length LUT across a chain of Cubic Bezier segments.
+ */
+declare function buildPathLUT(segments: CubicBezierSegment[], samplesPerSegment?: number): PathChainLUT;
+/**
+ * Samples position, tangent angle, and normal across a chain of Cubic Bezier segments.
+ */
+declare function samplePathChainGeometry(segments: CubicBezierSegment[], chainLUT: PathChainLUT, distance: number): {
+  position: Vec2;
+  tangentAngleDeg: number;
+  normal: Vec2;
+};
+/**
+ * Converts an ellipse arc into cubic Bezier segments (up to 90 degrees per segment).
+ */
+declare function ellipseToCubicBeziers(cx: number, cy: number, rx: number, ry: number, startAngleDeg?: number, endAngleDeg?: number): CubicBezierSegment[];
+/**
+ * Converts a sinusoidal wave into cubic Bezier segments per half-cycle.
+ */
+declare function waveToCubicBeziers(startX: number, startY: number, length: number, amplitude: number, frequency: number, phaseDeg?: number): CubicBezierSegment[];
+/**
+ * An SVG elliptical arc (endpoint form, SVG 1.1 F.6.5) as cubic Bezier
+ * segments of at most 90° each.
+ */
+
+/**
+ * Converts SVG path data string into a chain of Cubic Bezier segments.
+ */
+declare function parseSvgPathToCubicBeziers(d: string): CubicBezierSegment[];
+/**
+ * Universal path source converter to Cubic Bezier segments.
+ */
+declare function generatePathSegments(source: TextPathSource): CubicBezierSegment[];
+//#endregion
+//#region src/program/text-animations/selectors.d.ts
+/**
+ * Computes After Effects Range Selector weight for a single glyph index.
+ *
+ * @param index Normalized position of the glyph in the string (0.0 to 1.0)
+ * @param start Start boundary (0.0 to 1.0)
+ * @param end End boundary (0.0 to 1.0)
+ * @param offset Window shift (-1.0 to 1.0)
+ * @param shape Falloff curve
+ * @param easeHigh Non-linear easing for high values
+ * @param easeLow Non-linear easing for low values
+ * @returns Weight in [0.0, 1.0]
+ */
+declare function computeRangeSelectorWeight(index: number, start: number, end: number, offset: number, shape: SelectorShape, easeHigh?: number, easeLow?: number): number;
+/**
+ * 1D Gradient deterministic hash noise for Wiggly Selectors.
+ */
+declare function deterministicWigglyNoise(seed: number, glyphIndex: number, phase: number, correlation: number): number;
+/**
+ * Deterministic pseudo-random number generator for seeded order shuffling.
+ */
+declare function getShuffledOrder(count: number, seed: number): number[];
+/**
+ * Combines consecutive selector weights using After Effects Selector Mode logic.
+ */
+declare function evaluateSelectorCombination(prevWeight: number, currWeight: number, mode: SelectorMode): number;
+//#endregion
+//#region src/program/text-animations/typewriter.d.ts
+declare function getScramblePool(charset: string, customCharset?: string): string;
+/**
+ * Evaluates typewriter visible character count and scramble state for frame `currentFrame`.
+ */
+declare function evaluateTypewriterState(fullText: string, currentFrame: number, startFrame: number, durationFrames: number, cadence?: TypingCadence, scramble?: TextScrambleConfig, blinkFrequency?: number, granularity?: "character" | "word" | "line", progressOverride?: number): {
+  visibleChars: number;
+  currentDisplayString: string;
+  isCursorVisible: boolean;
+};
+//#endregion
+//#region src/program/schema.d.ts
+/** number px | "auto" (intrinsic) | "fit" (shrink-wrap) | "fill" (parent extent). */
+declare const SizeSpecSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+  auto: "auto";
+  fit: "fit";
+  fill: "fill";
+}>, z.ZodCustom<unknown, unknown>]>;
+type SizeSpec = z.infer<typeof SizeSpecSchema>;
+declare const ShapeTypeSchema: z.ZodEnum<{
+  path: "path";
+  rect: "rect";
+  circle: "circle";
+  ellipse: "ellipse";
+  polygon: "polygon";
+  star: "star";
+  arrow: "arrow";
+}>;
+type ShapeType = z.infer<typeof ShapeTypeSchema>;
+declare const AnimatablePropSchema: z.ZodEnum<{
+  fill: "fill";
+  x: "x";
+  y: "y";
+  scale: "scale";
+  rotation: "rotation";
+  opacity: "opacity";
+  width: "width";
+  height: "height";
+  volume: "volume";
+  hidden: "hidden";
+  muted: "muted";
+  gap: "gap";
+  padding: "padding";
+  borderRadius: "borderRadius";
+  fontSize: "fontSize";
+  text: "text";
+  color: "color";
+  letterSpacing: "letterSpacing";
+  trimStart: "trimStart";
+  trimEnd: "trimEnd";
+  trimOffset: "trimOffset";
+  strokeWidth: "strokeWidth";
+  strokeDashOffset: "strokeDashOffset";
+  cornerRadius: "cornerRadius";
+  starInnerRadiusRatio: "starInnerRadiusRatio";
+  fillColor: "fillColor";
+  strokeColor: "strokeColor";
+  borderColor: "borderColor";
+  borderWidth: "borderWidth";
+  motionBlurShutter: "motionBlurShutter";
+  rangeStart: "rangeStart";
+  rangeEnd: "rangeEnd";
+  offset: "offset";
+  animatorRangeStart: "animatorRangeStart";
+  animatorRangeEnd: "animatorRangeEnd";
+  animatorOffset: "animatorOffset";
+  firstMargin: "firstMargin";
+  lastMargin: "lastMargin";
+  baselineShift: "baselineShift";
+  rotateX: "rotateX";
+  rotateY: "rotateY";
+  rotateZ: "rotateZ";
+  perspective: "perspective";
+  translateZ: "translateZ";
+  perspectiveOriginX: "perspectiveOriginX";
+  perspectiveOriginY: "perspectiveOriginY";
+  cameraX: "cameraX";
+  cameraY: "cameraY";
+  cameraZ: "cameraZ";
+  targetX: "targetX";
+  targetY: "targetY";
+  targetZ: "targetZ";
+  cameraPitch: "cameraPitch";
+  cameraYaw: "cameraYaw";
+  cameraRoll: "cameraRoll";
+  cameraFov: "cameraFov";
+  cameraZoom: "cameraZoom";
+  focalLength: "focalLength";
+  focusDistance: "focusDistance";
+  fStop: "fStop";
+  maxBlurRadius: "maxBlurRadius";
+  shakeTranslation: "shakeTranslation";
+  shakeRotation: "shakeRotation";
+  orbitRadius: "orbitRadius";
+  orbitAzimuth: "orbitAzimuth";
+  orbitElevation: "orbitElevation";
+  z: "z";
+  scaleZ: "scaleZ";
+  intensity: "intensity";
+  angle: "angle";
+  radius: "radius";
+  penumbra: "penumbra";
+  decay: "decay";
+  shininess: "shininess";
+  roughness: "roughness";
+  specularIntensity: "specularIntensity";
+  ambientIntensity: "ambientIntensity";
+  metallic: "metallic";
+  ior: "ior";
+  dispersion: "dispersion";
+  transmission: "transmission";
+  fresnelPower: "fresnelPower";
+  envIntensity: "envIntensity";
+  animationProgress: "animationProgress";
+  animationTime: "animationTime";
+  animationSpeed: "animationSpeed";
+  wireframe: "wireframe";
+  scaleX: "scaleX";
+  scaleY: "scaleY";
+}>;
+type AnimatableProp = z.infer<typeof AnimatablePropSchema>;
+declare const MaterialTypeSchema: z.ZodEnum<{
+  metallic: "metallic";
+  lit: "lit";
+  unlit: "unlit";
+  toon: "toon";
+  glass: "glass";
+  acrylic: "acrylic";
+  frosted: "frosted";
+}>;
+type MaterialType = z.infer<typeof MaterialTypeSchema>;
+declare const EaseRefSchema: z.ZodObject<{
+  name: z.ZodEnum<{
+    none: "none";
+    power1: "power1";
+    power2: "power2";
+    power3: "power3";
+    sine: "sine";
+    circ: "circ";
+    expo: "expo";
+    back: "back";
+    elastic: "elastic";
+    bounce: "bounce";
+    spring: "spring";
+    cubic: "cubic";
+    hold: "hold";
+  }>;
+  dir: z.ZodEnum<{
+    in: "in";
+    out: "out";
+    inOut: "inOut";
+  }>;
+  params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>;
+type EaseRef = z.infer<typeof EaseRefSchema>;
+declare const KeyframeSchema: z.ZodObject<{
+  id: z.ZodString;
+  frame: z.ZodNumber;
+  value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+  ease: z.ZodOptional<z.ZodObject<{
+    name: z.ZodEnum<{
+      none: "none";
+      power1: "power1";
+      power2: "power2";
+      power3: "power3";
+      sine: "sine";
+      circ: "circ";
+      expo: "expo";
+      back: "back";
+      elastic: "elastic";
+      bounce: "bounce";
+      spring: "spring";
+      cubic: "cubic";
+      hold: "hold";
+    }>;
+    dir: z.ZodEnum<{
+      in: "in";
+      out: "out";
+      inOut: "inOut";
+    }>;
+    params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  }, z.core.$strict>>;
+  presetGroupId: z.ZodOptional<z.ZodString>;
+  presetType: z.ZodOptional<z.ZodString>;
+  spatialTangentIn: z.ZodOptional<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>;
+  spatialTangentOut: z.ZodOptional<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strict>;
+type Keyframe = z.infer<typeof KeyframeSchema>;
+declare const RawTrackSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"keyframe">;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"signal">;
+  inputHandleId: z.ZodString;
+  multiplier: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  smoothingWindowFrames: z.ZodDefault<z.ZodNumber>;
+  colorMode: z.ZodOptional<z.ZodEnum<{
+    interpolate: "interpolate";
+    hueRotate: "hueRotate";
+    threshold: "threshold";
+  }>>;
+  colorA: z.ZodOptional<z.ZodString>;
+  colorB: z.ZodOptional<z.ZodString>;
+  colorThreshold: z.ZodOptional<z.ZodNumber>;
+  signalMode: z.ZodOptional<z.ZodEnum<{
+    continuous: "continuous";
+    accumulate: "accumulate";
+  }>>;
+  threshold: z.ZodOptional<z.ZodNumber>;
+  accumulateThreshold: z.ZodOptional<z.ZodNumber>;
+  debounceFrames: z.ZodOptional<z.ZodNumber>;
+  channel: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"wiggle">;
+  frequency: z.ZodDefault<z.ZodNumber>;
+  amplitude: z.ZodDefault<z.ZodNumber>;
+  octaves: z.ZodDefault<z.ZodNumber>;
+  seed: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"springOvershoot">;
+  damping: z.ZodDefault<z.ZodNumber>;
+  stiffness: z.ZodDefault<z.ZodNumber>;
+  mass: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>], "type">;
+type TrackSource = z.infer<typeof RawTrackSourceSchema>;
+declare const AnimationTrackSchema: z.ZodObject<{
+  id: z.ZodString;
+  prop: z.ZodEnum<{
+    fill: "fill";
+    x: "x";
+    y: "y";
+    scale: "scale";
+    rotation: "rotation";
+    opacity: "opacity";
+    width: "width";
+    height: "height";
+    volume: "volume";
+    hidden: "hidden";
+    muted: "muted";
+    gap: "gap";
+    padding: "padding";
+    borderRadius: "borderRadius";
+    fontSize: "fontSize";
+    text: "text";
+    color: "color";
+    letterSpacing: "letterSpacing";
+    trimStart: "trimStart";
+    trimEnd: "trimEnd";
+    trimOffset: "trimOffset";
+    strokeWidth: "strokeWidth";
+    strokeDashOffset: "strokeDashOffset";
+    cornerRadius: "cornerRadius";
+    starInnerRadiusRatio: "starInnerRadiusRatio";
+    fillColor: "fillColor";
+    strokeColor: "strokeColor";
+    borderColor: "borderColor";
+    borderWidth: "borderWidth";
+    motionBlurShutter: "motionBlurShutter";
+    rangeStart: "rangeStart";
+    rangeEnd: "rangeEnd";
+    offset: "offset";
+    animatorRangeStart: "animatorRangeStart";
+    animatorRangeEnd: "animatorRangeEnd";
+    animatorOffset: "animatorOffset";
+    firstMargin: "firstMargin";
+    lastMargin: "lastMargin";
+    baselineShift: "baselineShift";
+    rotateX: "rotateX";
+    rotateY: "rotateY";
+    rotateZ: "rotateZ";
+    perspective: "perspective";
+    translateZ: "translateZ";
+    perspectiveOriginX: "perspectiveOriginX";
+    perspectiveOriginY: "perspectiveOriginY";
+    cameraX: "cameraX";
+    cameraY: "cameraY";
+    cameraZ: "cameraZ";
+    targetX: "targetX";
+    targetY: "targetY";
+    targetZ: "targetZ";
+    cameraPitch: "cameraPitch";
+    cameraYaw: "cameraYaw";
+    cameraRoll: "cameraRoll";
+    cameraFov: "cameraFov";
+    cameraZoom: "cameraZoom";
+    focalLength: "focalLength";
+    focusDistance: "focusDistance";
+    fStop: "fStop";
+    maxBlurRadius: "maxBlurRadius";
+    shakeTranslation: "shakeTranslation";
+    shakeRotation: "shakeRotation";
+    orbitRadius: "orbitRadius";
+    orbitAzimuth: "orbitAzimuth";
+    orbitElevation: "orbitElevation";
+    z: "z";
+    scaleZ: "scaleZ";
+    intensity: "intensity";
+    angle: "angle";
+    radius: "radius";
+    penumbra: "penumbra";
+    decay: "decay";
+    shininess: "shininess";
+    roughness: "roughness";
+    specularIntensity: "specularIntensity";
+    ambientIntensity: "ambientIntensity";
+    metallic: "metallic";
+    ior: "ior";
+    dispersion: "dispersion";
+    transmission: "transmission";
+    fresnelPower: "fresnelPower";
+    envIntensity: "envIntensity";
+    animationProgress: "animationProgress";
+    animationTime: "animationTime";
+    animationSpeed: "animationSpeed";
+    wireframe: "wireframe";
+    scaleX: "scaleX";
+    scaleY: "scaleY";
+  }>;
+  source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"keyframe">;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"signal">;
+    inputHandleId: z.ZodString;
+    multiplier: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    smoothingWindowFrames: z.ZodDefault<z.ZodNumber>;
+    colorMode: z.ZodOptional<z.ZodEnum<{
+      interpolate: "interpolate";
+      hueRotate: "hueRotate";
+      threshold: "threshold";
+    }>>;
+    colorA: z.ZodOptional<z.ZodString>;
+    colorB: z.ZodOptional<z.ZodString>;
+    colorThreshold: z.ZodOptional<z.ZodNumber>;
+    signalMode: z.ZodOptional<z.ZodEnum<{
+      continuous: "continuous";
+      accumulate: "accumulate";
+    }>>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    accumulateThreshold: z.ZodOptional<z.ZodNumber>;
+    debounceFrames: z.ZodOptional<z.ZodNumber>;
+    channel: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"wiggle">;
+    frequency: z.ZodDefault<z.ZodNumber>;
+    amplitude: z.ZodDefault<z.ZodNumber>;
+    octaves: z.ZodDefault<z.ZodNumber>;
+    seed: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"springOvershoot">;
+    damping: z.ZodDefault<z.ZodNumber>;
+    stiffness: z.ZodDefault<z.ZodNumber>;
+    mass: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>], "type">>;
+  keyframes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    frame: z.ZodNumber;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+    ease: z.ZodOptional<z.ZodObject<{
+      name: z.ZodEnum<{
+        none: "none";
+        power1: "power1";
+        power2: "power2";
+        power3: "power3";
+        sine: "sine";
+        circ: "circ";
+        expo: "expo";
+        back: "back";
+        elastic: "elastic";
+        bounce: "bounce";
+        spring: "spring";
+        cubic: "cubic";
+        hold: "hold";
+      }>;
+      dir: z.ZodEnum<{
+        in: "in";
+        out: "out";
+        inOut: "inOut";
+      }>;
+      params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    presetGroupId: z.ZodOptional<z.ZodString>;
+    presetType: z.ZodOptional<z.ZodString>;
+    spatialTangentIn: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    spatialTangentOut: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strict>>>;
+  repeat: z.ZodOptional<z.ZodNumber>;
+  yoyo: z.ZodOptional<z.ZodBoolean>;
+  durationFrames: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type AnimationTrack = z.infer<typeof AnimationTrackSchema>;
+declare const LayerAnimationSchema: z.ZodObject<{
+  tracks: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    prop: z.ZodEnum<{
+      fill: "fill";
+      x: "x";
+      y: "y";
+      scale: "scale";
+      rotation: "rotation";
+      opacity: "opacity";
+      width: "width";
+      height: "height";
+      volume: "volume";
+      hidden: "hidden";
+      muted: "muted";
+      gap: "gap";
+      padding: "padding";
+      borderRadius: "borderRadius";
+      fontSize: "fontSize";
+      text: "text";
+      color: "color";
+      letterSpacing: "letterSpacing";
+      trimStart: "trimStart";
+      trimEnd: "trimEnd";
+      trimOffset: "trimOffset";
+      strokeWidth: "strokeWidth";
+      strokeDashOffset: "strokeDashOffset";
+      cornerRadius: "cornerRadius";
+      starInnerRadiusRatio: "starInnerRadiusRatio";
+      fillColor: "fillColor";
+      strokeColor: "strokeColor";
+      borderColor: "borderColor";
+      borderWidth: "borderWidth";
+      motionBlurShutter: "motionBlurShutter";
+      rangeStart: "rangeStart";
+      rangeEnd: "rangeEnd";
+      offset: "offset";
+      animatorRangeStart: "animatorRangeStart";
+      animatorRangeEnd: "animatorRangeEnd";
+      animatorOffset: "animatorOffset";
+      firstMargin: "firstMargin";
+      lastMargin: "lastMargin";
+      baselineShift: "baselineShift";
+      rotateX: "rotateX";
+      rotateY: "rotateY";
+      rotateZ: "rotateZ";
+      perspective: "perspective";
+      translateZ: "translateZ";
+      perspectiveOriginX: "perspectiveOriginX";
+      perspectiveOriginY: "perspectiveOriginY";
+      cameraX: "cameraX";
+      cameraY: "cameraY";
+      cameraZ: "cameraZ";
+      targetX: "targetX";
+      targetY: "targetY";
+      targetZ: "targetZ";
+      cameraPitch: "cameraPitch";
+      cameraYaw: "cameraYaw";
+      cameraRoll: "cameraRoll";
+      cameraFov: "cameraFov";
+      cameraZoom: "cameraZoom";
+      focalLength: "focalLength";
+      focusDistance: "focusDistance";
+      fStop: "fStop";
+      maxBlurRadius: "maxBlurRadius";
+      shakeTranslation: "shakeTranslation";
+      shakeRotation: "shakeRotation";
+      orbitRadius: "orbitRadius";
+      orbitAzimuth: "orbitAzimuth";
+      orbitElevation: "orbitElevation";
+      z: "z";
+      scaleZ: "scaleZ";
+      intensity: "intensity";
+      angle: "angle";
+      radius: "radius";
+      penumbra: "penumbra";
+      decay: "decay";
+      shininess: "shininess";
+      roughness: "roughness";
+      specularIntensity: "specularIntensity";
+      ambientIntensity: "ambientIntensity";
+      metallic: "metallic";
+      ior: "ior";
+      dispersion: "dispersion";
+      transmission: "transmission";
+      fresnelPower: "fresnelPower";
+      envIntensity: "envIntensity";
+      animationProgress: "animationProgress";
+      animationTime: "animationTime";
+      animationSpeed: "animationSpeed";
+      wireframe: "wireframe";
+      scaleX: "scaleX";
+      scaleY: "scaleY";
+    }>;
+    source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"keyframe">;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"signal">;
+      inputHandleId: z.ZodString;
+      multiplier: z.ZodDefault<z.ZodNumber>;
+      offset: z.ZodDefault<z.ZodNumber>;
+      smoothingWindowFrames: z.ZodDefault<z.ZodNumber>;
+      colorMode: z.ZodOptional<z.ZodEnum<{
+        interpolate: "interpolate";
+        hueRotate: "hueRotate";
+        threshold: "threshold";
+      }>>;
+      colorA: z.ZodOptional<z.ZodString>;
+      colorB: z.ZodOptional<z.ZodString>;
+      colorThreshold: z.ZodOptional<z.ZodNumber>;
+      signalMode: z.ZodOptional<z.ZodEnum<{
+        continuous: "continuous";
+        accumulate: "accumulate";
+      }>>;
+      threshold: z.ZodOptional<z.ZodNumber>;
+      accumulateThreshold: z.ZodOptional<z.ZodNumber>;
+      debounceFrames: z.ZodOptional<z.ZodNumber>;
+      channel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"wiggle">;
+      frequency: z.ZodDefault<z.ZodNumber>;
+      amplitude: z.ZodDefault<z.ZodNumber>;
+      octaves: z.ZodDefault<z.ZodNumber>;
+      seed: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"springOvershoot">;
+      damping: z.ZodDefault<z.ZodNumber>;
+      stiffness: z.ZodDefault<z.ZodNumber>;
+      mass: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>], "type">>;
+    keyframes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      frame: z.ZodNumber;
+      value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+      ease: z.ZodOptional<z.ZodObject<{
+        name: z.ZodEnum<{
+          none: "none";
+          power1: "power1";
+          power2: "power2";
+          power3: "power3";
+          sine: "sine";
+          circ: "circ";
+          expo: "expo";
+          back: "back";
+          elastic: "elastic";
+          bounce: "bounce";
+          spring: "spring";
+          cubic: "cubic";
+          hold: "hold";
+        }>;
+        dir: z.ZodEnum<{
+          in: "in";
+          out: "out";
+          inOut: "inOut";
+        }>;
+        params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+      }, z.core.$strict>>;
+      presetGroupId: z.ZodOptional<z.ZodString>;
+      presetType: z.ZodOptional<z.ZodString>;
+      spatialTangentIn: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>>;
+      spatialTangentOut: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strict>>>;
+    repeat: z.ZodOptional<z.ZodNumber>;
+    yoyo: z.ZodOptional<z.ZodBoolean>;
+    durationFrames: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type LayerAnimationSpec = z.infer<typeof LayerAnimationSchema>;
+interface CompositionNodeBase {
+  id: string;
+  inputHandleId?: string;
+  position?: "relative" | "absolute";
+  x?: number | unknown;
+  y?: number | unknown;
+  width?: SizeSpec;
+  height?: SizeSpec;
+  grow?: number;
+  flexShrink?: number;
+  flexBasis?: number;
+  alignSelf?: "auto" | "start" | "center" | "end" | "stretch" | "baseline";
+  aspectRatio?: number;
+  zIndex?: number;
+  hidden?: boolean;
+  opacity?: number;
+  blendMode?: string;
+  rotation?: number;
+  scale?: number;
+  anchorX?: number;
+  anchorY?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  perspective?: number;
+  perspectiveOriginX?: number;
+  perspectiveOriginY?: number;
+  translateZ?: number;
+  backfaceVisibility?: "visible" | "hidden";
+  transformStyle?: "flat" | "preserve-3d";
+  is3D?: boolean;
+  z?: number | unknown;
+  scaleZ?: number;
+  twoSided?: boolean;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  startFrame?: number;
+  durationFrames?: number;
+  motionBlurShutter?: number;
+  animation?: LayerAnimationSpec;
+  vision?: unknown;
+  relighting?: unknown;
+}
+interface FlexNode extends CompositionNodeBase {
+  kind: "flex";
+  dir?: "row" | "column";
+  gap?: number;
+  padding?: number;
+  justify?: "start" | "center" | "end" | "space-between" | "space-around";
+  align?: "start" | "center" | "end" | "stretch";
+  wrap?: boolean;
+  staggerFrames?: number;
+  staggerDirection?: "forward" | "reverse" | "center-out";
+  overflow?: "visible" | "hidden";
+  background?: string;
+  borderRadius?: number;
+  borderColor?: string;
+  borderWidth?: number;
+  strokeAlign?: "inside" | "center" | "outside";
+  strokeRadius?: number;
+  children?: LayoutNode[];
+}
+interface BlockNode extends CompositionNodeBase {
+  kind: "block";
+  gap?: number;
+  padding?: number;
+  align?: "start" | "center" | "end" | "stretch";
+  staggerFrames?: number;
+  staggerDirection?: "forward" | "reverse" | "center-out";
+  overflow?: "visible" | "hidden";
+  background?: string;
+  borderRadius?: number;
+  borderColor?: string;
+  borderWidth?: number;
+  strokeAlign?: "inside" | "center" | "outside";
+  strokeRadius?: number;
+  children?: LayoutNode[];
+}
+interface BoxNode extends CompositionNodeBase {
+  kind: "box";
+  background?: string;
+  borderRadius?: number;
+  padding?: number;
+  staggerFrames?: number;
+  staggerDirection?: "forward" | "reverse" | "center-out";
+  overflow?: "visible" | "hidden";
+  borderColor?: string;
+  borderWidth?: number;
+  strokeAlign?: "inside" | "center" | "outside";
+  strokeRadius?: number;
+  children?: LayoutNode[];
+}
+declare const TextShadowSchema: z.ZodObject<{
+  color: z.ZodOptional<z.ZodString>;
+  offset: z.ZodOptional<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>;
+  blurRadius: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type TextShadow = z.infer<typeof TextShadowSchema>;
+declare const TextAnimatorSchema: z.ZodObject<{
+  id: z.ZodString;
+  unit: z.ZodDefault<z.ZodEnum<{
+    character: "character";
+    word: "word";
+    line: "line";
+  }>>;
+  rangeStart: z.ZodDefault<z.ZodNumber>;
+  rangeEnd: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  easing: z.ZodDefault<z.ZodString>;
+  transform: z.ZodOptional<z.ZodObject<{
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    scaleX: z.ZodOptional<z.ZodNumber>;
+    scaleY: z.ZodOptional<z.ZodNumber>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    rotationX: z.ZodOptional<z.ZodNumber>;
+    rotationY: z.ZodOptional<z.ZodNumber>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    blur: z.ZodOptional<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strip>;
+type TextAnimator = z.infer<typeof TextAnimatorSchema>;
+declare const TextAnimator: {
+  /**
+   * Per-character staggered wave rise with baseline tilt and fade.
+   */
+  waveRise(options?: {
+    id?: string;
+    unit?: "character" | "word" | "line";
+    y?: number;
+    rotationX?: number;
+    opacity?: number;
+    blur?: number;
+    easing?: string;
+    rangeStart?: number;
+    rangeEnd?: number;
+    offset?: number;
+  }): TextAnimator;
+  /**
+   * Per-word or per-character pop / scale bounce.
+   */
+  wordPop(options?: {
+    id?: string;
+    scale?: number;
+    y?: number;
+    easing?: string;
+  }): TextAnimator;
+  /**
+   * Per-character cinematic optical blur to crisp reveal.
+   */
+  blurIn(options?: {
+    id?: string;
+    unit?: "character" | "word";
+    blur?: number;
+    y?: number;
+    opacity?: number;
+    easing?: string;
+  }): TextAnimator;
+  /**
+   * 3D letter flip (like airport split-flap display or 3D letter roll).
+   */
+  flip3D(options?: {
+    id?: string;
+    unit?: "character" | "word";
+    rotationX?: number;
+    easing?: string;
+  }): TextAnimator;
+  /**
+   * Color sweep passing across glyphs/words.
+   */
+  colorSweep(options: {
+    id?: string;
+    color: string;
+    unit?: "character" | "word";
+    easing?: string;
+  }): TextAnimator;
+};
+interface TextNode extends CompositionNodeBase {
+  kind: "text";
+  text?: string;
+  spans?: TextSpan[];
+  fontFamily?: string;
+  fontSize?: number;
+  fontWeight?: number | string;
+  fontStyle?: string;
+  fill?: string;
+  align?: "start" | "center" | "end";
+  verticalAlign?: "top" | "middle" | "bottom";
+  lineHeight?: number;
+  letterSpacing?: number;
+  background?: string;
+  borderRadius?: number;
+  padding?: number;
+  stroke?: string;
+  strokeWidth?: number;
+  strokeAlign?: "inside" | "center" | "outside";
+  textShadow?: string;
+  shadows?: TextShadow[];
+  pathOptions?: TextPathOptions;
+  typewriter?: TypewriterAnimator;
+  marquee?: KineticMarqueeConfig;
+  animators?: (TextAnimator | AETextAnimator | AdvancedTextAnimator)[];
+}
+interface MediaNode extends CompositionNodeBase {
+  kind: "media";
+  inputHandleId: string;
+  dataType?: string;
+  fit?: "cover" | "contain" | "fill" | "none";
+  borderRadius?: number;
+  borderColor?: string;
+  borderWidth?: number;
+  strokeAlign?: "inside" | "center" | "outside";
+  strokeRadius?: number;
+  volume?: number;
+  muted?: boolean;
+  /** Source in-point: seconds into the clip that play at the layer's startFrame. */
+  trimStartSec?: number;
+  fontFamily?: string;
+  fontSize?: number;
+  fontWeight?: number | string;
+  fontStyle?: string;
+  fill?: string;
+  align?: "start" | "center" | "end";
+  verticalAlign?: "top" | "middle" | "bottom";
+  lineHeight?: number;
+  letterSpacing?: number;
+  background?: string;
+  padding?: number;
+  stroke?: string;
+  strokeWidth?: number;
+  textShadow?: string;
+  shadows?: TextShadow[];
+  maxWidth?: number;
+}
+interface ShapeNode extends CompositionNodeBase {
+  kind: "shape";
+  shapeType?: ShapeType;
+  borderRadius?: number;
+  radiusTL?: number;
+  radiusTR?: number;
+  radiusBR?: number;
+  radiusBL?: number;
+  polygonSides?: number;
+  starPoints?: number;
+  starInnerRadiusRatio?: number;
+  arrowHeadWidth?: number;
+  arrowHeadLength?: number;
+  arrowShaftWidth?: number;
+  d?: string;
+  fillType?: "solid" | "linear" | "radial" | "none";
+  fillColor?: string;
+  gradientEndColor?: string;
+  gradientAngle?: number;
+  strokeColor?: string;
+  strokeWidth?: number;
+  strokeDashArray?: string;
+  strokeDashOffset?: number;
+  strokeLineCap?: "butt" | "round" | "square";
+  strokeLineJoin?: "miter" | "round" | "bevel";
+  strokeAlign?: "inside" | "center" | "outside";
+  trimStart?: number;
+  trimEnd?: number;
+  trimOffset?: number;
+}
+declare const CameraLensSchema: z.ZodObject<{
+  focalLength: z.ZodDefault<z.ZodNumber>;
+  fov: z.ZodOptional<z.ZodNumber>;
+  sensorWidth: z.ZodDefault<z.ZodNumber>;
+  near: z.ZodDefault<z.ZodNumber>;
+  far: z.ZodDefault<z.ZodNumber>;
+  zoom: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type CameraLens = z.infer<typeof CameraLensSchema>;
+declare const CameraDoFSchema: z.ZodObject<{
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  focusDistance: z.ZodDefault<z.ZodNumber>;
+  fStop: z.ZodDefault<z.ZodNumber>;
+  maxBlurRadius: z.ZodDefault<z.ZodNumber>;
+  apertureBlades: z.ZodDefault<z.ZodNumber>;
+  anamorphicRatio: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** Depth of field as authored: fields with schema defaults may be left out. */
+type CameraDoF = z.input<typeof CameraDoFSchema>;
+declare const CameraShakeSchema: z.ZodObject<{
+  translationAmplitude: z.ZodDefault<z.ZodNumber>;
+  rotationAmplitude: z.ZodDefault<z.ZodNumber>;
+  frequency: z.ZodDefault<z.ZodNumber>;
+  octaves: z.ZodDefault<z.ZodNumber>;
+  seed: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type CameraShake = z.infer<typeof CameraShakeSchema>;
+interface CameraNode {
+  id: string;
+  kind: "camera";
+  mode?: "lookAt" | "free" | "orbit";
+  x?: number;
+  y?: number;
+  z?: number;
+  targetX?: number;
+  targetY?: number;
+  targetZ?: number;
+  pitch?: number;
+  yaw?: number;
+  roll?: number;
+  lens?: CameraLens;
+  dof?: CameraDoF;
+  shake?: CameraShake;
+  startFrame?: number;
+  durationFrames?: number;
+  animation?: LayerAnimationSpec;
+}
+declare const CameraNodeSchema: z.ZodType<CameraNode>;
+type LightType = "ambient" | "directional" | "point" | "spot";
+declare const LightTypeSchema: z.ZodEnum<{
+  ambient: "ambient";
+  directional: "directional";
+  point: "point";
+  spot: "spot";
+}>;
+interface LightNode {
+  id: string;
+  kind: "light";
+  lightType?: LightType;
+  color?: string;
+  intensity?: number;
+  x?: number;
+  y?: number;
+  z?: number;
+  targetX?: number;
+  targetY?: number;
+  targetZ?: number;
+  direction?: [number, number, number];
+  radius?: number;
+  decay?: number;
+  angle?: number;
+  penumbra?: number;
+  startFrame?: number;
+  durationFrames?: number;
+  animation?: LayerAnimationSpec;
+}
+declare const LightNodeSchema: z.ZodType<LightNode>;
+interface Model3DNode {
+  id: string;
+  kind: "model3d";
+  src?: string;
+  modelFormat?: "obj" | "fbx" | "gltf" | "glb" | "stl" | "ply" | "vox" | "3ds" | "off" | "auto";
+  modelData?: unknown;
+  animationName?: string;
+  animationProgress?: number;
+  animationTime?: number;
+  animationSpeed?: number;
+  loop?: boolean;
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  scale?: number;
+  scaleX?: number;
+  scaleY?: number;
+  scaleZ?: number;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  ambientIntensity?: number;
+  metallic?: number;
+  color?: string;
+  colorTint?: string;
+  opacity?: number;
+  twoSided?: boolean;
+  wireframe?: boolean;
+  is3D?: boolean;
+  texture?: string;
+  center?: boolean;
+  normalizeSize?: number;
+  startFrame?: number;
+  durationFrames?: number;
+  animation?: LayerAnimationSpec;
+  audioDeform?: MeshAudioDeformConfig;
+  text3dOptions?: unknown;
+}
+type LayoutNode = FlexNode | BlockNode | BoxNode | TextNode | MediaNode | ShapeNode | CameraNode | LightNode | Model3DNode;
+declare const FlexNodeSchema: z.ZodType<FlexNode>;
+declare const BoxNodeSchema: z.ZodType<BoxNode>;
+declare const TextSpanMarkSchema: z.ZodObject<{
+  background: z.ZodOptional<z.ZodString>;
+  borderRadius: z.ZodOptional<z.ZodNumber>;
+  paddingX: z.ZodOptional<z.ZodNumber>;
+  paddingY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const TextSpanSchema: z.ZodObject<{
+  text: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<{
+    get: (ctx?: unknown) => string;
+  }, {
+    get: (ctx?: unknown) => string;
+  }>]>;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  fontSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodCustom<{
+    get: (ctx?: unknown) => number;
+  }, {
+    get: (ctx?: unknown) => number;
+  }>]>>;
+  fontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  fontStyle: z.ZodOptional<z.ZodEnum<{
+    normal: "normal";
+    italic: "italic";
+  }>>;
+  fill: z.ZodOptional<z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodCustom<{
+    get: (ctx?: unknown) => string;
+  }, {
+    get: (ctx?: unknown) => string;
+  }>]>>;
+  letterSpacing: z.ZodOptional<z.ZodNumber>;
+  baselineShift: z.ZodOptional<z.ZodNumber>;
+  opacity: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodCustom<{
+    get: (ctx?: unknown) => number;
+  }, {
+    get: (ctx?: unknown) => number;
+  }>]>>;
+  mark: z.ZodOptional<z.ZodObject<{
+    background: z.ZodOptional<z.ZodString>;
+    borderRadius: z.ZodOptional<z.ZodNumber>;
+    paddingX: z.ZodOptional<z.ZodNumber>;
+    paddingY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const TextNodeSchema: z.ZodType<TextNode>;
+declare const MediaNodeSchema: z.ZodType<MediaNode>;
+declare const ShapeNodeSchema: z.ZodType<ShapeNode>;
+declare const ColorStopSchema: z.ZodObject<{
+  offset: z.ZodNumber;
+  color: z.ZodString;
+}, z.core.$strip>;
+type ColorStop = z.infer<typeof ColorStopSchema>;
+declare const Model3DNodeSchema: z.ZodType<Model3DNode>;
+declare const LayoutNodeSchema: z.ZodType<LayoutNode>;
+declare const CompositorProgramSchema: z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+  backgroundColor: z.ZodOptional<z.ZodString>;
+  volume: z.ZodDefault<z.ZodNumber>;
+  fps: z.ZodDefault<z.ZodNumber>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    Video: "Video";
+    Image: "Image";
+  }>>;
+  antialias3d: z.ZodOptional<z.ZodBoolean>;
+  layout: z.ZodDefault<z.ZodArray<z.ZodType<LayoutNode, unknown, z.core.$ZodTypeInternals<LayoutNode, unknown>>>>;
+  fonts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  signals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  effects: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+  vision: z.ZodOptional<z.ZodUnknown>;
+  onRequestFrame: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
+}, z.core.$strict>;
+type CompositorProgramConfig = z.infer<typeof CompositorProgramSchema>;
+//#endregion
+//#region src/utils/layout/resolve-layout.d.ts
+interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface LayoutResult {
+  /** Final rect per node id (post-layout, pre-affine-transform). */
+  rects: Record<string, Rect>;
+  /** Resolved outer size per node id. */
+  sizes: Record<string, {
+    width: number;
+    height: number;
+  }>;
+}
+/**
+ * Intrinsic ("auto"/"fit") size for a leaf node. Return null when the node
+ * has no measurable content. In the compositor this is backed by text
+ * measurement / media metadata — the layout pass never measures itself.
+ */
+type MeasureFn = (node: LayoutNode, constraintWidth?: number) => {
+  width: number;
+  height: number;
+} | null;
+interface LayoutInput {
+  /** Document roots — the only structural input. Size comes from `viewport`. */
+  layout: LayoutNode[];
+  viewport: {
+    width: number;
+    height: number;
+  };
+  measure?: MeasureFn;
+}
+/**
+ * Ensure the Yoga WASM module is loaded. Safe to call multiple times —
+ * subsequent calls return the cached instance immediately.
+ */
+
+/** Deterministic layout (synchronous): document + viewport (+ measure) → rects. */
+declare function computeLayoutSync(yoga: Yoga, input: LayoutInput): LayoutResult;
+/** Deterministic layout: document + viewport (+ measure) → rects. */
+declare function computeLayout(input: LayoutInput): Promise<LayoutResult>;
+//#endregion
+//#region src/program/animation.d.ts
+/**
+ * One keyframe as a tuple: `[frame, value]` or `[frame, value, ease]`. The
+ * ease shapes the motion arriving at this keyframe from the one before.
+ */
+type KeyframeTuple = readonly [frame: number, value: number | string | boolean, ease?: string | EaseRef];
+interface FromToOptions {
+  from?: number;
+  to?: number;
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  durationFrames?: number;
+  ease?: string | EaseRef;
+}
+interface Tilt3DOptions {
+  from?: {
+    rotateX?: number;
+    rotateY?: number;
+    rotateZ?: number;
+    translateZ?: number;
+    perspective?: number;
+  };
+  to: {
+    rotateX?: number;
+    rotateY?: number;
+    rotateZ?: number;
+    translateZ?: number;
+    perspective?: number;
+  };
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  ease?: string | EaseRef;
+}
+interface SignalTrackOptions {
+  multiplier?: number;
+  offset?: number;
+  smoothing?: number;
+  channel?: string;
+  mode?: "continuous" | "accumulate";
+  threshold?: number;
+  debounceFrames?: number;
+}
+interface ColorSignalOptions {
+  colorA: string;
+  colorB: string;
+  colorMode?: "interpolate" | "hueRotate" | "threshold";
+  threshold?: number;
+  smoothing?: number;
+}
+interface WiggleOptions {
+  frequency?: number;
+  amplitude?: number;
+  octaves?: number;
+  seed?: number;
+}
+interface SpringOptions {
+  damping?: number;
+  stiffness?: number;
+  mass?: number;
+}
+interface PathLike3D {
+  getPointAt(u: number): {
+    position: [number, number, number];
+    tangent?: [number, number, number];
+  };
+  getFrameAt?(u: number): {
+    position: [number, number, number];
+    tangent: [number, number, number];
+    normal?: [number, number, number];
+    binormal?: [number, number, number];
+    rotation?: [number, number, number];
+  };
+  totalLength?: number;
+}
+interface FollowPathOptions {
+  fromDistance?: number;
+  toDistance?: number;
+  fromProgress?: number;
+  toProgress?: number;
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  autoOrient?: boolean;
+  banking?: number;
+  pitchOffset?: number;
+  yawOffset?: number;
+  rollOffset?: number;
+  samples?: number;
+  ease?: string | EaseRef;
+}
+interface CameraFollowPathOptions {
+  fromProgress?: number;
+  toProgress?: number;
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  mode?: "orientAlongPath" | "lookAtTarget" | "leadTarget";
+  target?: [number, number, number];
+  lookAhead?: number;
+  samples?: number;
+  ease?: string | EaseRef;
+}
+/**
+ * Fluent builder and runtime representation for layer animations.
+ * Supports chainable keyframes, reactive signal binding, Perlin wiggles, and springs.
+ */
+declare class LayerAnimation implements LayerAnimationSpec {
+  tracks: AnimationTrack[];
+  constructor(tracks?: AnimationTrack[]);
+  static create(): LayerAnimation;
+  static fromTo(prop: AnimatableProp, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): LayerAnimation;
+  /** A track from a list of `[frame, value, ease?]` keyframes; see {@link LayerAnimation.keys}. */
+  static keys(prop: AnimatableProp, keyframes: readonly KeyframeTuple[]): LayerAnimation;
+  static signal(prop: AnimatableProp, signalOrHandleId: unknown, options?: SignalTrackOptions): LayerAnimation;
+  static colorSignal(prop: AnimatableProp, signalOrHandleId: unknown, options: ColorSignalOptions): LayerAnimation;
+  static kineticSweep(fromOffset?: number, toOffset?: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
+  static typewriter(startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
+  static letterSpacing(fromSpacing: number, toSpacing: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
+  static wiggle(prop: AnimatableProp, options?: WiggleOptions): LayerAnimation;
+  static spring(prop: AnimatableProp, options?: SpringOptions): LayerAnimation;
+  static firstMargin(fromMargin: number, toMargin: number, options?: FromToOptions): LayerAnimation;
+  static strokeWidth(fromWidth: number, toWidth: number, options?: FromToOptions): LayerAnimation;
+  static rotateX(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  static rotateY(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  static rotateZ(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  static rotation(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
+  addTrack(track: AnimationTrack): this;
+  /**
+   * Creates a keyframed track animating from fromValue to toValue.
+   */
+  fromTo(prop: AnimatableProp, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): this;
+  /**
+   * Appends a keyframe to an existing track for prop, or creates a new track.
+   */
+  keyframe(prop: AnimatableProp, frame: number, value: number | string | boolean, ease?: string | EaseRef): this;
+  /**
+   * Adds several keyframes to prop's track at once:
+   * `.keys("scale", [[0, 0], [12, 1.1, "back.out"], [20, 1]])`.
+   * Frames are rounded to whole frames, so beat math can be passed straight in.
+   */
+  keys(prop: AnimatableProp, keyframes: readonly KeyframeTuple[]): this;
+  /**
+   * Animates opacity from 0 to 1 between startFrame and endFrame.
+   */
+  fadeIn(startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
+  /**
+   * Animates opacity from 1 to 0 between startFrame and endFrame.
+   */
+  fadeOut(startFrame: number, endFrame: number, ease?: string | EaseRef): this;
+  /**
+   * Slides in Y coordinate from fromY to toY.
+   */
+  slideInY(fromY: number, toY: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
+  /**
+   * Slides in X coordinate from fromX to toX.
+   */
+  slideInX(fromX: number, toX: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
+  /**
+   * Sweeps kinetic typography animator offset from fromOffset to toOffset.
+   * Cascades per-glyph or per-word transforms across the text.
+   */
+  kineticSweep(fromOffset?: number, toOffset?: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
+  /**
+   * Progressive character write-on / typewriter text reveal.
+   */
+  typewriter(startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
+  /**
+   * Animates letter-spacing (tracking expansion or compression).
+   */
+  letterSpacing(fromSpacing: number, toSpacing: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
+  /**
+   * Animates text position along a path via First Margin.
+   */
+  firstMargin(fromMargin: number, toMargin: number, options?: FromToOptions): this;
+  /**
+   * Animates Last Margin spatial limit along a path.
+   */
+  lastMargin(fromMargin: number, toMargin: number, options?: FromToOptions): this;
+  /**
+   * Animates baseline shift perpendicular to curve tangent.
+   */
+  baselineShift(fromShift: number, toShift: number, options?: FromToOptions): this;
+  /**
+   * Animate rotateX from fromAngle to toAngle.
+   */
+  rotateX(fromAngle: number, toAngle: number, options?: FromToOptions): this;
+  /**
+   * Animate rotateY from fromAngle to toAngle.
+   */
+  rotateY(fromAngle: number, toAngle: number, options?: FromToOptions): this;
+  /**
+   * Animate rotateZ from fromAngle to toAngle.
+   */
+  rotateZ(fromAngle: number, toAngle: number, options?: FromToOptions): this;
+  /**
+   * Animate perspective camera distance in pixels.
+   */
+  perspective(fromDist: number, toDist: number, options?: FromToOptions): this;
+  /**
+   * Animate depth translation (translateZ) in pixels.
+   */
+  translateZ(fromZ: number, toZ: number, options?: FromToOptions): this;
+  /**
+   * Composite helper to tilt a container across multiple 3D axes simultaneously.
+   */
+  tilt3D(options: Tilt3DOptions): this;
+  /**
+   * Binds an animatable property to a reactive continuous Signal (e.g. LFO, speech energy, audio pitch).
+   *
+   * `signalOrHandleId` is either a signal object (`Signal.fromArray`,
+   * `Signal.builder`, an audio channel …) — carried on the track and
+   * registered with the program automatically — or the name of a signal
+   * registered with `comp.addSignal(name, signal)`.
+   */
+  signal(prop: AnimatableProp, signalOrHandleId: unknown, options?: SignalTrackOptions): this;
+  /**
+   * Modulates color interpolation based on an active signal (object or
+   * registered name, as in {@link LayerAnimation.signal}).
+   */
+  colorSignal(prop: AnimatableProp, signalOrHandleId: unknown, options: ColorSignalOptions): this;
+  /**
+   * Adds organic Perlin noise wiggling to a property.
+   */
+  wiggle(prop: AnimatableProp, options?: WiggleOptions): this;
+  /**
+   * Adds physical harmonic spring overshoot behavior to a property transition.
+   */
+  spring(prop: AnimatableProp, options?: SpringOptions): this;
+  /**
+   * Follows a 2D or 3D path with constant arc-length velocity, automatic orientation,
+   * banking into turns, and optional easing.
+   */
+  followPath(path: PathLike3D, options?: FollowPathOptions): this;
+  /**
+   * Attaches this animation to a target LayoutNode and returns the node.
+   */
+  applyTo<T extends {
+    animation?: LayerAnimationSpec;
+  }>(node: T): T;
+  /**
+   * Returns the validated LayerAnimation specification object.
+   */
+  toSpec(): LayerAnimationSpec;
+  toJSON(): LayerAnimationSpec;
+}
+interface DollyOptions {
+  fromDistance: number;
+  toDistance: number;
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  ease?: string;
+}
+interface OrbitOptions {
+  radius?: {
+    from?: number;
+    to: number;
+  };
+  azimuth?: {
+    from?: number;
+    to: number;
+  };
+  elevation?: {
+    from?: number;
+    to: number;
+  };
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  ease?: string;
+}
+interface RackFocusOptions {
+  fromDistance: number;
+  toDistance: number;
+  fromFStop?: number;
+  toFStop?: number;
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+  ease?: string;
+}
+interface HandheldOptions {
+  translationAmplitude: number;
+  rotationAmplitude: number;
+  start?: number;
+  end?: number;
+  fromFrame?: number;
+  toFrame?: number;
+}
+declare class CameraAnimation extends LayerAnimation {
+  static camera(): CameraAnimation;
+  dolly(fromDistanceOrOptions: number | DollyOptions, toDistance?: number, options?: FromToOptions): this;
+  orbit(options: OrbitOptions): this;
+  truck(fromX: number, toX: number, options?: FromToOptions): this;
+  pedestal(fromY: number, toY: number, options?: FromToOptions): this;
+  pan(fromAngleDeg: number, toAngleDeg: number, options?: FromToOptions): this;
+  tilt(fromAngleDeg: number, toAngleDeg: number, options?: FromToOptions): this;
+  roll(fromAngleDeg: number, toAngleDeg: number, options?: FromToOptions): this;
+  rackFocus(options: RackFocusOptions): this;
+  handheld(options: HandheldOptions): this;
+  /**
+   * Animates camera eye and lookAt target along a 3D path with constant velocity,
+   * leading target look-ahead, or path tangent orientation.
+   */
+  followPath3D(path: PathLike3D, options?: CameraFollowPathOptions): this;
+}
+//#endregion
+//#region src/program/evaluator.d.ts
+type SignalDataSource = unknown;
+interface TrackEvaluationContext {
+  /** Root frame (timeline frame). */
+  rootFrame?: number;
+  /** Layer start frame offset. */
+  startFrame?: number;
+  /** Base layer property fallback values. */
+  baseValues?: Record<string, unknown>;
+  /** Connected signal providers indexed by inputHandleId. */
+  signals?: Record<string, SignalDataSource>;
+}
+/**
+ * Procedural wiggle generator using multi-octave coherent 1D gradient noise.
+ */
+
+/**
+ * Evaluates an AnimationTrack at a given global or local frame.
+ */
+declare function evaluateTrackAtFrame(track: AnimationTrack, frame: number, fps?: number, context?: TrackEvaluationContext): number | boolean | string;
+/**
+ * Evaluates all animation tracks for a layer at `frame`.
+ */
+declare function evaluateAnimationAtFrame(animation: LayerAnimationSpec | undefined, frame: number, fps?: number, context?: TrackEvaluationContext): Record<string, number | boolean | string>;
+//#endregion
+//#region src/program/sequence.d.ts
+/**
+ * Camera Transition Type across scene boundaries.
+ */
+declare const SceneTransitionTypeSchema: z.ZodEnum<{
+  cut: "cut";
+  carrierMatchCut: "carrierMatchCut";
+  cameraWhip: "cameraWhip";
+  focusPullDissolve: "focusPullDissolve";
+  irisAperture: "irisAperture";
+  pushDirectional: "pushDirectional";
+}>;
+type SceneTransitionType = z.infer<typeof SceneTransitionTypeSchema>;
+/**
+ * Carrier Object Handoff Configuration Schema.
+ */
+declare const CarrierHandoffConfigSchema: z.ZodObject<{
+  sourceLayerId: z.ZodString;
+  targetLayerId: z.ZodString;
+  mode: z.ZodDefault<z.ZodEnum<{
+    exact: "exact";
+    preserveVelocity: "preserveVelocity";
+    morph: "morph";
+  }>>;
+  blendFrames: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type CarrierHandoffConfig = z.infer<typeof CarrierHandoffConfigSchema>;
+/**
+ * Individual Scene Definition Schema.
+ */
+declare const SceneDefinitionSchema: z.ZodObject<{
+  id: z.ZodString;
+  chapter: z.ZodDefault<z.ZodEnum<{
+    custom: "custom";
+    hook: "hook";
+    tension: "tension";
+    solution: "solution";
+    feature_spotlight: "feature_spotlight";
+    outro: "outro";
+  }>>;
+  durationMs: z.ZodOptional<z.ZodNumber>;
+  durationFrames: z.ZodOptional<z.ZodNumber>;
+  transitionOut: z.ZodDefault<z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+      cut: "cut";
+      carrierMatchCut: "carrierMatchCut";
+      cameraWhip: "cameraWhip";
+      focusPullDissolve: "focusPullDissolve";
+      irisAperture: "irisAperture";
+      pushDirectional: "pushDirectional";
+    }>>;
+    durationFrames: z.ZodDefault<z.ZodNumber>;
+    carrier: z.ZodOptional<z.ZodObject<{
+      sourceLayerId: z.ZodString;
+      targetLayerId: z.ZodString;
+      mode: z.ZodDefault<z.ZodEnum<{
+        exact: "exact";
+        preserveVelocity: "preserveVelocity";
+        morph: "morph";
+      }>>;
+      blendFrames: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    whipDirection: z.ZodDefault<z.ZodEnum<{
+      left: "left";
+      right: "right";
+      up: "up";
+      down: "down";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$loose>;
+type SceneDefinition = z.infer<typeof SceneDefinitionSchema>;
+interface CarrierState {
+  x: number;
+  y: number;
+  scale: number;
+  vx: number;
+  vy: number;
+}
+declare function computeCarrierContinuity(stateAtCut: CarrierState, targetInitialState: Partial<CarrierState>): CarrierState;
+interface SequenceTimelineResult {
+  totalFrames: number;
+  totalDurationMs: number;
+  sceneOffsets: Array<{
+    sceneId: string;
+    startFrame: number;
+    durationFrames: number;
+  }>;
+}
+/**
+ * Calculates global scene offsets and handoff frames across a sequence.
+ */
+declare function calculateSequenceTimeline(scenes: Array<{
+  id: string;
+  durationFrames?: number;
+  durationMs?: number;
+  transitionOverlap?: number;
+  transitionOut?: {
+    durationFrames?: number;
+  };
+}>, fps?: number): SequenceTimelineResult;
+interface SceneOptions {
+  id: string;
+  chapter?: "hook" | "tension" | "solution" | "feature_spotlight" | "outro" | "custom";
+  durationMs?: number;
+  durationFrames?: number;
+  transitionOut?: {
+    type?: SceneTransitionType;
+    durationFrames?: number;
+    carrier?: CarrierHandoffConfig;
+    whipDirection?: "left" | "right" | "up" | "down";
+  };
+  layout?: LayoutNode[];
+}
+declare class Scene {
+  id: string;
+  chapter: "hook" | "tension" | "solution" | "feature_spotlight" | "outro" | "custom";
+  durationMs?: number;
+  durationFrames?: number;
+  transitionOut: {
+    type: SceneTransitionType;
+    durationFrames: number;
+    carrier?: CarrierHandoffConfig;
+    whipDirection: "left" | "right" | "up" | "down";
+  };
+  layout: LayoutNode[];
+  constructor(options: SceneOptions);
+  static create(options: SceneOptions): Scene;
+}
+interface SequenceOptions {
+  fps?: number;
+  width?: number;
+  height?: number;
+  backgroundColor?: string;
+  fonts?: string[];
+  signals?: Record<string, unknown>;
+  scenes?: Scene[];
+}
+declare class Sequence {
+  fps: number;
+  width: number;
+  height: number;
+  backgroundColor: string;
+  fonts?: string[];
+  signals?: Record<string, unknown>;
+  private scenes;
+  constructor(options?: SequenceOptions);
+  static create(options?: SequenceOptions): Sequence;
+  addScene(scene: Scene | SceneOptions): this;
+  getScenes(): readonly Scene[];
+  calculateTimeline(): SequenceTimelineResult;
+  toProgram(): CompositorProgramConfig;
+}
+//#endregion
+//#region src/program/stagger.d.ts
+type StaggerDirection = "forward" | "reverse" | "center-out";
+/**
+ * Calculates the frame delay offset for a child at `index` in a container of `totalCount` items.
+ */
+declare function computeStaggerDelay(index: number, totalCount: number, staggerFrames: number, direction?: StaggerDirection): number;
+/**
+ * Applies stagger timing offsets to child nodes, returning cloned objects with adjusted `startFrame`.
+ */
+declare function applyStaggerToChildren<T extends {
+  startFrame?: number;
+}>(children: T[], staggerFrames: number, direction?: StaggerDirection, baseOffset?: number): T[];
+//#endregion
+//#region src/program/to-virtual-media.d.ts
+interface CompositorToProgramOptions {
+  isVideoMode: boolean;
+  fps: number;
+  /** Comp duration in ms (metadata only; derived upstream). */
+  durationMs?: number;
+  /** Bind a media node's `inputHandleId` to its graph source item. */
+  resolveMedia?: (inputHandleId: string) => VirtualMediaData | undefined;
+  /** External signals mapped by inputHandleId. */
+  signals?: Record<string, any>;
+}
+declare function compositorToProgram(config: CompositorProgramConfig, options: CompositorToProgramOptions): VirtualMediaData;
+/** Recursively gather every node op from a render tree (in order). */
+declare function collectNodeOps(nodes: VirtualMediaData[]): VirtualMediaData[];
+//#endregion
+//#region src/program/validate.d.ts
+//#endregion
+//#region src/chart.d.ts
+type ChartType = "line" | "area" | "bar" | "scatter" | "pie" | "donut" | "candlestick";
+type ChartX = number | string | Date;
+/** A plain value (x is its index or `categories[i]`), an `[x, y]` pair, or `{ x, y }`. */
+type ChartDatum = number | readonly [ChartX, number] | {
+  x: ChartX;
+  y: number;
+};
+interface ChartCandle {
+  x: ChartX;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+}
+/** A pie or donut slice. */
+interface ChartSlice {
+  label: string;
+  value: number;
+  color?: string;
+}
+interface ChartSeries {
+  name?: string;
+  /** Series type in a combined chart; defaults to the chart's `type`. */
+  type?: Exclude<ChartType, "pie" | "donut">;
+  data: readonly ChartDatum[] | readonly ChartCandle[];
+  color?: string;
+  /** Line width for line and area series. Default 3. */
+  strokeWidth?: number;
+  /** Line and area interpolation. Default "smooth". */
+  curve?: "linear" | "smooth" | "step";
+  /** Dot radius drawn on line points; scatter point radius. 0 hides line dots. */
+  pointRadius?: number;
+}
+interface ChartAxisOptions {
+  /** Show tick labels. Default true. */
+  show?: boolean;
+  /** Draw grid lines across the plot. Default true for y, false for x. */
+  grid?: boolean;
+  min?: number;
+  max?: number;
+  /** Approximate number of ticks. Default 5. */
+  ticks?: number;
+  /** A d3-format specifier such as ",.0f", "$.2s" or ".0%", or a function. */
+  format?: string | ((value: ChartX) => string);
+}
+interface ChartAnimationOptions {
+  /** Frame the reveal starts, relative to the chart's own start. Default 0. */
+  start?: number;
+  /** Frames each element takes to animate in. Default 30. */
+  duration?: number;
+  /** Frames between consecutive bars, points or slices. Default spreads them over `duration`. */
+  stagger?: number;
+  /** Easing for bars, points and slices. Default "power3.out". */
+  ease?: string;
+}
+interface ChartPadding {
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+}
+interface ChartOptions {
+  /** Chart type, and the default for series without their own. Default "line". */
+  type?: ChartType;
+  width?: number;
+  height?: number;
+  series?: readonly ChartSeries[];
+  /** Shorthand for a single series, or the slices of a pie or donut. */
+  data?: readonly ChartDatum[] | readonly ChartCandle[] | readonly ChartSlice[];
+  /** Labels for x positions when data are plain values; slice labels for pie charts. */
+  categories?: readonly string[];
+  /** Stack bar and area series instead of grouping or overlapping them. */
+  stacked?: boolean;
+  colors?: readonly string[];
+  xAxis?: ChartAxisOptions;
+  yAxis?: ChartAxisOptions;
+  /** Space around the plot for axis labels and legend. Computed when omitted. */
+  padding?: number | ChartPadding;
+  fontFamily?: string;
+  /** Axis, legend and value label size. Default 18. */
+  fontSize?: number;
+  /** Axis labels; when set, also the legend and value labels. */
+  textColor?: string;
+  gridColor?: string;
+  background?: string;
+  /** Show the series or slice legend. Default: on for several series and for pies. */
+  legend?: boolean;
+  /** Print values on bars and slices (pie values print as percentages). */
+  valueLabels?: boolean;
+  /** Donut hole as a fraction of the radius. Default 0.6 for "donut". */
+  innerRadius?: number;
+  /** Corner radius of bars and slices. Default 4. */
+  cornerRadius?: number;
+  upColor?: string;
+  downColor?: string;
+  /** Reveal animation, or `false` for a static chart. */
+  animate?: false | ChartAnimationOptions;
+}
+declare const DEFAULT_CHART_COLORS: readonly ["#6366f1", "#22d3ee", "#f59e0b", "#ec4899", "#10b981", "#8b5cf6", "#f97316", "#3b82f6"];
+//#endregion
+//#region src/shapes3d.d.ts
+interface CubeFaceConfig {
+  background?: string;
+  borderRadius?: number;
+  borderWidth?: number;
+  borderColor?: string;
+  opacity?: number;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  children?: LayoutNode[];
+}
+type CubeFaceInput = CubeFaceConfig | LayoutNode | string;
+interface Cube3DOptions {
+  id?: string;
+  size: number | [number, number, number];
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  faces?: {
+    front?: CubeFaceInput;
+    back?: CubeFaceInput;
+    left?: CubeFaceInput;
+    right?: CubeFaceInput;
+    top?: CubeFaceInput;
+    bottom?: CubeFaceInput;
+  };
+  twoSided?: boolean;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  opacity?: number;
+}
+interface Carousel3DOptions {
+  id?: string;
+  radius: number;
+  items: LayoutNode[];
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  faceInward?: boolean;
+  itemWidth?: number;
+  itemHeight?: number;
+  twoSided?: boolean;
+  opacity?: number;
+}
+interface Prism3DOptions {
+  id?: string;
+  sides: number;
+  radius: number;
+  height: number;
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  sideConfigs?: Array<CubeFaceInput>;
+  twoSided?: boolean;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  opacity?: number;
+}
+interface Plane3DOptions {
+  id?: string;
+  width: number;
+  height: number;
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  background?: string;
+  borderRadius?: number;
+  twoSided?: boolean;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  opacity?: number;
+  children?: LayoutNode[];
+}
+interface Grid3DOptions {
+  id?: string;
+  width: number;
+  height: number;
+  divisions?: number;
+  color?: string;
+  /** Line thickness in world pixels (default 2). */
+  lineWidth?: number;
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  opacity?: number;
+}
+interface Text3DOptions {
+  id?: string;
+  text: string;
+  fontSize?: number;
+  fontFamily?: string;
+  fontWeight?: number | string;
+  fontStyle?: string;
+  fill?: string;
+  x?: number;
+  y?: number;
+  z?: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+  scale?: number;
+  scaleX?: number;
+  scaleY?: number;
+  scaleZ?: number;
+  align?: "start" | "center" | "end" | "left" | "right";
+  verticalAlign?: "top" | "middle" | "bottom";
+  letterSpacing?: number;
+  lineHeight?: number;
+  is3D?: boolean;
+  twoSided?: boolean;
+  material?: MaterialType;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  ambientIntensity?: number;
+  metallic?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  opacity?: number;
+  background?: string;
+  borderRadius?: number;
+  padding?: number;
+  stroke?: string;
+  strokeWidth?: number;
+  extrusionDepth?: number;
+  /** @deprecated No effect: extruded text is one solid mesh, not a stack of slices. */
+  extrusionSteps?: number;
+  /**
+   * Extruded text only: color of the side walls. `fill` colors the letter
+   * faces (front and back). Defaults to `fill`.
+   */
+  bevelColor?: string;
+}
+interface ExtrudedText3DOptions extends Text3DOptions {
+  depth: number;
+  /** @deprecated No effect: extruded text is one solid mesh, not a stack of slices. */
+  slices?: number;
+  /** Fixed straight segments per curve; by default curves split as finely as their on-screen size needs. */
+  curveSegments?: number;
+  /** Most a flattened curve strays from the outline, in on-screen px at scale 1 (default 0.1). */
+  curveTolerance?: number;
+}
+type Shape3DContainer = AnimatableNode<BoxNode> & {
+  faces?: AnimatableNode<BoxNode>[];
+  items?: LayoutNode[];
+  [Symbol.iterator](): Iterator<LayoutNode>;
+};
+declare const Layer3D: {
+  /**
+   * Creates a true 3D volumetric cube with 6 textured or colored faces.
+   * Returns a preserve-3d container that can be transformed in 3D camera space.
+   */
+  cube(options: Cube3DOptions): Shape3DContainer;
+  /**
+   * Creates a 3D cylindrical carousel of items arranged radially around a center point.
+   */
+  carousel(options: Carousel3DOptions): Shape3DContainer;
+  /**
+   * Creates an N-sided regular polygonal 3D prism.
+   */
+  prism(options: Prism3DOptions): Shape3DContainer;
+  /**
+   * Creates a standalone planar 3D card/quad.
+   */
+  plane(options: Plane3DOptions): AnimatableNode<BoxNode>;
+  /**
+   * Creates a 3D perspective ground grid: `divisions` cells per side, each
+   * line its own unlit quad so it stays crisp at any camera distance.
+   */
+  grid(options: Grid3DOptions): AnimatableNode<BoxNode>;
+  /**
+   * Creates a standalone planar 3D text node, or solid extruded 3D text when `extrusionDepth` is set.
+   */
+  text(options: Text3DOptions): AnimatableNode<LayoutNode>;
+  /**
+   * Creates solid extruded 3D typography: `fill` colors the letter faces,
+   * `bevelColor` the side walls; curves are tessellated to `curveTolerance`.
+   */
+  extrudedText(options: ExtrudedText3DOptions): Shape3DContainer;
+  /**
+   * Creates a 3D model node rendered natively with WebGPU mesh shaders.
+   */
+  model(options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D Wavefront OBJ model node.
+   */
+  obj(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D Autodesk FBX model node with skeletal animation support.
+   */
+  fbx(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D glTF 2.0 model node.
+   */
+  gltf(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D GLB binary container model node.
+   */
+  glb(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D STL CAD / 3D printing model node.
+   */
+  stl(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D Stanford PLY scan model node.
+   */
+  ply(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D MagicaVoxel VOX model node.
+   */
+  vox(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D Studio (3DS) binary model node.
+   */
+  threeDS(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+  /**
+   * Convenience helper to create a 3D Object File Format (OFF) model node.
+   */
+  off(src: string, options?: Partial<Model3DNode>): AnimatableNode<Model3DNode>;
+};
+//#endregion
+//#region ../renderers/dist/index.d.mts
+//#region src/blend.d.ts
+declare const mapBlendModeToSkia: (mode?: string) => string;
+declare const requiresIsolation: (mode?: string) => boolean;
+//#endregion
+//#region src/geometry.d.ts
+interface StrokeRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  radius: number;
+}
+declare function computeStrokeRect(w: number, h: number, cornerRadius: number, strokeWidth: number, align?: "inside" | "outside" | "center"): StrokeRect;
+//#endregion
+//#region src/interpolate.d.ts
+declare function bezier(mX1: number, mY1: number, mX2: number, mY2: number): (x: number) => number;
+declare const Easing: {
+  linear: (x: number) => number;
+  ease: (x: number) => number;
+  quad: (t: number) => number;
+  cubic: (t: number) => number;
+  poly: (n: number) => (t: number) => number;
+  sin: (t: number) => number;
+  circle: (t: number) => number;
+  exp: (t: number) => number;
+  elastic: (bounciness?: number) => (t: number) => number;
+  back: (s?: number) => (t: number) => number;
+  bounce: (t: number) => number;
+  bezier: typeof bezier;
+  in: <T extends (t: number) => number>(fn: T) => T;
+  out: <T extends (t: number) => number>(fn: T) => ((t: number) => number);
+  inOut: <T extends (t: number) => number>(fn: T) => ((t: number) => number);
+};
+interface InterpolateOptions {
+  extrapolateLeft?: "clamp" | "extend" | "identity";
+  extrapolateRight?: "clamp" | "extend" | "identity";
+  easing?: (t: number) => number;
+}
+declare function interpolate(value: number, inputRange: readonly number[], outputRange: readonly number[], options?: InterpolateOptions): number;
+//#endregion
+//#region src/math3d/vector3.d.ts
+/**
+ * 3D Vector mathematics for camera kinematics, scene projections, and spatial transforms.
+ * Fully typed, pure functional routines with zero runtime allocations where possible.
+ */
+type Vec3 = [number, number, number];
+declare const Vector3Math: {
+  create(x?: number, y?: number, z?: number): Vec3;
+  copy(v: Vec3): Vec3;
+  set(out: Vec3, x: number, y: number, z: number): Vec3;
+  add(a: Vec3, b: Vec3): Vec3;
+  subtract(a: Vec3, b: Vec3): Vec3;
+  multiplyScalar(v: Vec3, s: number): Vec3;
+  dot(a: Vec3, b: Vec3): number;
+  cross(a: Vec3, b: Vec3): Vec3;
+  lengthSq(v: Vec3): number;
+  length(v: Vec3): number;
+  distance(a: Vec3, b: Vec3): number;
+  normalize(v: Vec3): Vec3;
+  lerp(a: Vec3, b: Vec3, t: number): Vec3;
+  equals(a: Vec3, b: Vec3, epsilon?: number): boolean;
+};
+//#endregion
+//#region src/math3d/matrix4.d.ts
+type Mat4 = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+declare const Matrix4Math: {
+  identity(): Mat4;
+  copy(m: Mat4): Mat4;
+  multiply(a: Mat4, b: Mat4): Mat4;
+  translate(tx: number, ty: number, tz?: number): Mat4;
+  scale(sx: number, sy: number, sz?: number): Mat4;
+  rotateX(rad: number): Mat4;
+  rotateY(rad: number): Mat4;
+  rotateZ(rad: number): Mat4;
+  rotateAxis(axis: Vec3, rad: number): Mat4;
+  /**
+   * Computes LookAt view matrix from camera eye, target, and up vector.
+   */
+  lookAt(eye: Vec3, target: Vec3, up?: Vec3): Mat4;
+  /**
+   * Perspective projection matrix for WebGPU NDC depth range [0, 1].
+   * @param fovYRad Vertical field of view in radians.
+   * @param aspect Width / Height aspect ratio.
+   * @param near Near clipping plane (e.g. 1.0).
+   * @param far Far clipping plane (e.g. 10000.0).
+   */
+  perspective(fovYRad: number, aspect: number, near: number, far: number): Mat4;
+  /**
+   * Orthographic projection matrix for WebGPU NDC depth range [0, 1].
+   */
+  orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+  /**
+   * Inverts a 4x4 matrix using standard Cramer's rule. Returns null if singular.
+   */
+  invert(m: Mat4): Mat4 | null;
+  transpose(m: Mat4): Mat4;
+  /**
+   * Projects a 3D point through a 4x4 matrix with perspective division.
+   */
+  projectPoint(m: Mat4, p: Vec3): Vec3;
+  /**
+   * Projects a 2D rectangle (0,0, w, h) through a 4x4 matrix into 4 3D points.
+   */
+  projectRectangle(m: Mat4, width: number, height: number): [Vec3, Vec3, Vec3, Vec3];
+  toFloat32Array(m: Mat4): Float32Array;
+};
+//#endregion
+//#region src/math3d/camera3d.d.ts
+interface Camera3DPose {
+  /** Camera Eye position in world space [x, y, z] */
+  eye: Vec3;
+  /** LookAt Target / Point of Interest [x, y, z] */
+  target: Vec3;
+  /** Camera Up vector (default [0, -1, 0] for Y-down screen coordinates) */
+  up: Vec3;
+  /** Vertical field of view in degrees (default 50) */
+  fov: number;
+  /** Viewport aspect ratio (width / height) */
+  aspect: number;
+  /** Near clipping plane distance (default 1.0) */
+  near: number;
+  /** Far clipping plane distance (default 50000.0) */
+  far: number;
+  /** Optical zoom multiplier (default 1.0) */
+  zoom: number;
+  /** Focal plane distance from camera for Depth of Field in pixels */
+  focusDistance?: number;
+  /** Lens f-number / aperture (e.g. 1.4, 2.8, 5.6) */
+  fStop?: number;
+  /** Maximum bokeh blur radius in pixels (default 32) */
+  maxBlurRadius?: number;
+}
+interface CameraShakeOptions {
+  translationAmplitude: number;
+  rotationAmplitude: number;
+  frequency?: number;
+  octaves?: number;
+  seed?: number;
+}
+type FrustumPlane = [number, number, number, number];
+interface FrustumPlanes {
+  left: FrustumPlane;
+  right: FrustumPlane;
+  bottom: FrustumPlane;
+  top: FrustumPlane;
+  near: FrustumPlane;
+  far: FrustumPlane;
+}
+//#endregion
+//#region src/math3d/light3d.d.ts
+type LightKind = "ambient" | "directional" | "point" | "spot";
+interface GPULightData$1 {
+  /** xyz = position, w = type (0=ambient, 1=directional, 2=point, 3=spot) */
+  posType: [number, number, number, number];
+  /** xyz = normalized direction, w = radius */
+  dirRadius: [number, number, number, number];
+  /** rgb = linear color, w = intensity */
+  colorIntensity: [number, number, number, number];
+  /** x = cos(outer), y = cos(inner), z = decay, w = 0 */
+  spotParams: [number, number, number, number];
+}
+declare const MAX_LIGHTS = 8;
+declare const LIGHT_UNIFORM_SIZE_BYTES = 544;
+interface LightsUniformData {
+  ambientColor: [number, number, number, number];
+  params: [number, number, number, number];
+  lights: GPULightData$1[];
+}
+/**
+ * Parses CSS / hex / rgb color strings, arrays, or color objects into normalized linear [r, g, b] floats in [0, 1].
+ */
+declare function parseColorToRgb(color?: string | [number, number, number] | [number, number, number, number] | {
+  r: number;
+  g: number;
+  b: number;
+  a?: number;
+} | unknown): [number, number, number];
+//#endregion
+//#region src/math3d/path3d.d.ts
+interface Path3DPoint {
+  /** Position in 3D world space [x, y, z] */
+  position: Vec3;
+  /** Normalized unit tangent forward vector */
+  tangent: Vec3;
+  /** Normalized unit normal vector (orthogonal to tangent) */
+  normal: Vec3;
+  /** Normalized unit binormal vector: cross(tangent, normal) */
+  binormal: Vec3;
+  /** Cumulative arc length distance in pixels from path origin */
+  distance: number;
+  /** Normalized progress along path in [0, 1] */
+  t: number;
+  /** Euler orientation angles in degrees [pitch, yaw, roll] */
+  rotation: Vec3;
+}
+interface Path3DSample {
+  position: Vec3;
+  tangent: Vec3;
+  distance: number;
+}
+interface CatmullRomOptions {
+  /** Tension factor between 0 (loose) and 1 (tight); defaults to 0.5 (centripetal-like) */
+  tension?: number;
+  /** Whether path closes in a continuous loop */
+  closed?: boolean;
+  /** Samples per segment for arc-length integration (default 40) */
+  samplesPerSegment?: number;
+}
+interface BezierSegment3D {
+  p0: Vec3;
+  p1: Vec3;
+  p2: Vec3;
+  p3: Vec3;
+}
+interface HelixOptions {
+  center: Vec3;
+  radius: number;
+  pitch: number;
+  turns: number;
+  axis?: "x" | "y" | "z";
+  samplesPerTurn?: number;
+}
+interface CirclePathOptions {
+  center: Vec3;
+  radius: number;
+  normal?: Vec3;
+  startAngleDeg?: number;
+  endAngleDeg?: number;
+  samples?: number;
+}
+//#endregion
+//#region src/spring.d.ts
+type AnimationNode = {
+  lastTimestamp: number;
+  toValue: number;
+  current: number;
+  velocity: number;
+  prevPosition?: number;
+};
+type SpringConfig = {
+  damping: number;
+  mass: number;
+  stiffness: number;
+  overshootClamping: boolean;
+};
+declare function springCalculation({
+  frame,
+  fps,
+  config
+}: {
+  frame: number;
+  fps: number;
+  config?: Partial<SpringConfig>;
+}): AnimationNode;
+type MeasureSpringProps = {
+  fps: number;
+  config?: Partial<SpringConfig>;
+  threshold?: number;
+};
+declare function measureSpring({
+  fps,
+  config,
+  threshold
+}: MeasureSpringProps): number;
+declare function spring({
+  frame: passedFrame,
+  fps,
+  config,
+  from,
+  to,
+  durationInFrames: passedDurationInFrames,
+  durationRestThreshold,
+  delay,
+  reverse
+}: {
+  frame: number;
+  fps: number;
+  config?: Partial<SpringConfig>;
+  from?: number;
+  to?: number;
+  durationInFrames?: number;
+  durationRestThreshold?: number;
+  delay?: number;
+  reverse?: boolean;
+}): number;
+//#endregion
+//#region src/text-measurer.d.ts
+interface TextMeasureStyle {
+  fontFamily?: string;
+  fontSize?: number;
+  fontWeight?: string | number;
+  fontStyle?: string;
+  letterSpacing?: number;
+  lineHeight?: number;
+  padding?: number;
+  align?: "left" | "center" | "right";
+  width?: number;
+  height?: number;
+  autoDimensions?: boolean;
+  strokeWidth?: number;
+  strokeAlign?: "inside" | "center" | "outside";
+  keepNaturalWidth?: boolean;
+  spans?: TextSpan[];
+}
+interface TextMeasureResult {
+  width: number;
+  height: number;
+}
+/**
+ * Shared text measurer that uses SlugGeometry.measure for all environments.
+ */
+declare function measureText(text: string | null | undefined, style: TextMeasureStyle): TextMeasureResult;
+/**
+ * Async variant of measureText. Preloads the Slug font and yields to the browser.
+ */
+declare function measureTextAsync(text: string | null | undefined, style: TextMeasureStyle): Promise<TextMeasureResult>;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Preloads a font into the browser or headless environment.
+ */
+declare function preloadFont(family: string, url: string): Promise<void>;
+//#endregion
+//#endregion
+//#region src/index.d.ts
+interface SectionOptions {
+  readonly id?: string;
+  readonly position?: "absolute" | "relative";
+  readonly source?: string | MediaNode;
+  readonly effects?: unknown[];
+  readonly padding?: number;
+  readonly borderRadius?: number;
+  readonly borderColor?: string;
+  readonly borderWidth?: number;
+  readonly opacity?: number | unknown;
+  readonly blendMode?: string;
+  readonly fit?: "cover" | "contain";
+  readonly width?: number | unknown;
+  readonly height?: number | unknown;
+  readonly x?: number | unknown;
+  readonly y?: number | unknown;
+  readonly hideWhenLost?: boolean;
+  readonly smoothFrames?: number;
+  readonly children?: LayoutNode[];
+  readonly [key: string]: unknown;
+}
+type SectionNode = AnimatableNode<BoxNode> & {
+  readonly innerMedia: AnimatableNode<MediaNode>;
+  readonly effects: Effect<object>[];
+  addEffect(effect: Effect<object>): SectionNode;
+  withEffect(effect: Effect<object>): SectionNode;
+  withEffects(effects: Effect<object>[]): SectionNode;
+};
+type TrackedRegionOptions = SectionOptions;
+/** Editing helpers attached to every tracked object (see decorateTrackSignals). */
+interface TrackEditing {
+  /** A section of the source that follows this track */
+  section(sourceOrOptions?: string | MediaNode | SectionOptions, options?: SectionOptions): SectionNode;
+  /** A blur confined to this track's region */
+  blurEffect(options?: Partial<BlurProps>): Blur;
+  /** The tracked region of `source`, cut out as a section */
+  isolate(source: string | MediaNode, options?: TrackedRegionOptions): SectionNode;
+}
+/** A tracked object with its editing helpers, as vision hands it out. */
+type EditableObjectTrack = ObjectTrackSignals & TrackEditing;
+interface CompositionOptions {
+  width: number;
+  height: number;
+  fps?: number;
+  durationMs?: number;
+  durationFrames?: number;
+  backgroundColor?: string;
+  fonts?: string[];
+  signals?: Record<string, unknown>;
+  /**
+   * Smooth the edges of 3D meshes (extruded text, models) with 4x MSAA.
+   * Default true; set false to save ~60-125 MB of GPU memory at 1080p.
+   */
+  antialias3d?: boolean;
+}
+/**
+ * Fluent builder for single clips and chained visual/audio effect pipelines.
+ */
+declare class Media {
+  readonly virtualMedia: VirtualMediaData;
+  constructor(source: MediaSourceInput, type?: DataType);
+  static video(source: MediaSourceInput, meta?: Partial<MediaMetadata>): Media;
+  static image(source: MediaSourceInput, meta?: Partial<MediaMetadata>): Media;
+  static audio(source: MediaSourceInput, meta?: Partial<MediaMetadata>): Media;
+  /**
+   * Appends any Effect instance or shader operation onto the current media AST.
+   */
+  apply<TProps extends object>(effect: Effect<TProps>): Media;
+  apply<TConfig extends Record<string, unknown> = Record<string, unknown>>(op: string, config?: TConfig): Media;
+  /**
+   * Returns the underlying VirtualMediaData AST node ready for rendering.
+   */
+  toVirtualMedia(): VirtualMediaData;
+  /**
+   * Renders a single frame from this media pipeline to a PNG Buffer.
+   * Can render either by timestamp in milliseconds (`atMs`) or by frame index (`frame`).
+   */
+  renderFrame(options?: {
+    atMs?: number;
+    frame?: number;
+    fps?: number;
+    renderer?: HeadlessMediaRenderer;
+  }): Promise<Buffer>;
+  get fps(): number | undefined;
+  get durationMs(): number | undefined;
+  get width(): number | undefined;
+  get height(): number | undefined;
+  /**
+   * Renders an image grid of sequential frames across a given frame or millisecond range.
+   * Ideal for automated visual inspection of animation motion, easing curves, and layout stability.
+   */
+  renderFrameGrid(options?: FrameGridOptions): Promise<Buffer>;
+  /**
+   * Renders this media pipeline into an MP4/WebM video file with audio.
+   */
+  renderVideo(outputPathOrOptions?: string | RenderVideoOptions, options?: RenderVideoOptions): Promise<RenderVideoResult>;
+}
+interface RenderVideoOptions {
+  codec?: string;
+  audioCodec?: string;
+  quality?: string;
+  concurrency?: number;
+  outputPath?: string;
+  renderer?: HeadlessMediaRenderer;
+  /**
+   * Check the output while it renders and return the findings as `qa`:
+   * dropped, black or frozen frames, loudness (LUFS), clipping, silence and
+   * document warnings such as truncated animations. `true` uses defaults;
+   * pass thresholds (e.g. `{ targetLufs: -14 }`) to tighten them.
+   */
+  qa?: boolean | VideoQaOptions;
+}
+interface RenderVideoResult {
+  filePath: string;
+  cleanup: () => Promise<void>;
+  /** Present when rendered with `qa`; print it with `formatQaReport` */
+  qa?: VideoQaReport;
+}
+interface SubjectSandwichOptions {
+  readonly source: string | MediaNode;
+  readonly subject?: MaskTrackSignals | ObjectTrackSignals;
+  readonly behind: readonly LayoutNode[];
+  readonly feather?: number;
+  readonly fit?: "cover" | "contain" | "fill";
+  readonly variant?: VisionProps["variant"];
+  readonly confidence?: number;
+  readonly keyBackground?: boolean;
+  readonly backgroundKeyThreshold?: number;
+  readonly muted?: boolean;
+  readonly volume?: number;
+}
+interface SmartFramingOptions {
+  readonly source: string | MediaNode;
+  readonly targetAspect?: number;
+  readonly sourceAspect?: number;
+  readonly target: ObjectTrackSignals | MaskTrackSignals;
+  readonly damping?: number;
+  readonly leadHeadroom?: number;
+  readonly fit?: "cover" | "contain" | "fill";
+  readonly variant?: VisionProps["variant"];
+  readonly muted?: boolean;
+  readonly volume?: number;
+}
+interface SubjectOutlineOptions {
+  readonly source?: string | MediaNode;
+  readonly color?: string;
+  readonly width?: number;
+  readonly blur?: number;
+  readonly pulseSignal?: ProgrammaticSignal | Signal<number>;
+  readonly muted?: boolean;
+  readonly volume?: number;
+}
+/**
+ * High-level programmatic builder for multi-layer Framefields compositions.
+ */
+declare class Composition {
+  width: number;
+  height: number;
+  fps: number;
+  durationMs?: number;
+  backgroundColor: string;
+  antialias3d?: boolean;
+  fonts: string[];
+  children: LayoutNode[];
+  audioTracks: MediaNode[];
+  signals: Record<string, unknown>;
+  private _frameHooks;
+  private _visionConfig?;
+  private _visionBundle?;
+  private _effects;
+  /**
+   * Applies a whole-composition post-processing effect or vision pipeline.
+   */
+  apply(effect: unknown): this;
+  /**
+   * Runs vision on the whole composition — the rendered frame (composition, blur, crop,
+   * anything upstream) is the inference input. Models are LAZY: nothing downloads until
+   * the first frame actually runs a task.
+   * Returns the reactive VisionBundle (objects / masks / pose / classes signals).
+   */
+  withVision(config?: VisionProps | Vision): VisionBundle;
+  /**
+   * One-shot, ffmpeg-free vision analysis of a media source.
+   *
+   * Decodes frames through the same mediabunny pipeline the renderer uses, runs the requested
+   * tasks lazily (only those models download), temporally tracks detections, and returns a
+   * zod-serializable report. The decoder is released and the runner closed on completion.
+   */
+  analyzeVisionSequence(source: string, options?: {
+    tasks?: readonly VisionTask[];
+    categories?: readonly string[];
+    fps?: number;
+    totalFrames?: number;
+    pathStride?: number;
+    includeMasks?: boolean;
+    modelsDir?: string;
+    baseUrl?: string;
+    confidence?: number;
+    variant?: VisionProps["variant"];
+    /** Tracker box-association IoU. Default 0.25. */
+    iouThreshold?: number;
+  }): Promise<VisionAnalysisReport>;
+  /**
+   * Game-engine per-frame lifecycle hook for the composition.
+   * Invoked before rendering each frame so scripts or agents can mutate properties and signals.
+   */
+  onRequestFrame(callback: (ctx: FrameContext) => void): this;
+  notifyFrame(ctx: FrameContext): void;
+  constructor(options: CompositionOptions);
+  static create(options: CompositionOptions): Composition;
+  addSignal(name: string, signal: unknown): this;
+  add(layerOrFirst: LayoutNode | LayoutNode[] | TensorPipeline | VisionNode | {
+    node: unknown;
+  }, ...rest: Array<LayoutNode | LayoutNode[] | TensorPipeline | VisionNode | {
+    node: unknown;
+  } | LayerAnimation | {
+    tracks: AnimationTrack[];
+  }>): this;
+  addAudio(track: MediaNode): this;
+  /**
+   * Turnkey "Text Behind Subject" ("Sandwich") Primitive.
+   * Lowers into:
+   * 1. Bottom Layer: Full background video plate
+   * 2. Middle Layer: User-supplied `behind` nodes
+   * 3. Top Layer: Subject cutout video with continuous matte alpha registered at identical coordinates
+   */
+  addSubjectSandwich(options: SubjectSandwichOptions): this;
+  /**
+   * Dynamic Smart Re-Framing (16:9 → 9:16 Auto-Crop).
+   * Automatically transforms landscape footage into vertical shorts/reels by framing the
+   * tracked subject with smooth camera physics and lead headroom.
+   */
+  addSmartFraming(options: SmartFramingOptions): this;
+  /**
+   * Subject Contour Glow & Neon Outline.
+   * Strokes the silhouette boundary with a stylized bloom/glow and optional audio-reactive pulse.
+   */
+  addSubjectOutline(_subject: MaskTrackSignals | ObjectTrackSignals, options?: SubjectOutlineOptions): this;
+  /**
+   * Creates an isolated, styled section of the composition or underlying source plate.
+   * Any WebGPU effects (Blur, FilmGrain, Curves, Vignette, etc.) can be applied to this section.
+   */
+  section(sourceOrTargetOrOptions?: string | MediaNode | ObjectTrackSignals | SectionOptions, targetOrOptions?: ObjectTrackSignals | SectionOptions, options?: SectionOptions): SectionNode;
+  /**
+   * Creates a section and immediately adds it to the composition layout tree.
+   */
+  addSection(sourceOrTargetOrOptions?: string | MediaNode | ObjectTrackSignals | SectionOptions, targetOrOptions?: ObjectTrackSignals | SectionOptions, options?: SectionOptions): SectionNode;
+  /**
+   * Dynamically calculates composition duration from the longest media or animation layer.
+   */
+  computeDuration(): Promise<number>;
+  registerFont(optionsOrFamilyOrSource: RegisterFontOptions | string, source?: string | Uint8Array): Promise<this>;
+  toSpec(): CompositorProgramConfig;
+  /**
+   * Compiles the composition into a VirtualMediaData AST ready for WebGPU rendering.
+   */
+  toVirtualMedia(options?: Partial<CompositorToProgramOptions>): VirtualMediaData;
+  /**
+   * Compiles the composition into a VirtualMediaData AST with dynamically resolved duration.
+   */
+  toVirtualMediaAsync(options?: Partial<CompositorToProgramOptions>): Promise<VirtualMediaData>;
+  /**
+   * Renders a single frame from the composition to a PNG Buffer.
+   * Can render either by timestamp in milliseconds (`atMs`) or by frame index (`frame`).
+   */
+  renderFrame(options?: {
+    atMs?: number;
+    frame?: number;
+    renderer?: HeadlessMediaRenderer;
+  }): Promise<Buffer>;
+  /**
+   * Renders an image grid of sequential frames across a given frame or millisecond range.
+   * Ideal for automated visual inspection of animation motion, easing curves, and layout stability.
+   */
+  renderFrameGrid(options?: FrameGridOptions): Promise<Buffer>;
+  /**
+   * Renders this composition into an MP4/WebM video file with audio.
+   */
+  renderVideo(outputPathOrOptions?: string | RenderVideoOptions, options?: RenderVideoOptions): Promise<RenderVideoResult>;
+}
+/**
+ * Layer helpers for constructing composition nodes with clean URL/path strings.
+ */
+type AnimatableNode<T extends LayoutNode> = T & {
+  mask?: unknown;
+  glass?: Record<string, unknown>;
+  audioDeform?: MeshAudioDeformConfig | Record<string, unknown>;
+  crop?: CropProps | Crop;
+  vision?: Vision;
+  relighting?: NormalRelightingOptions;
+  deflicker?: DeflickerOptions;
+  effects?: unknown[];
+  blurRegions?: unknown[];
+  [key: string]: unknown;
+  animate(...anim: (LayerAnimation | {
+    tracks: AnimationTrack[];
+  } | LayerAnimation[])[]): AnimatableNode<T>;
+  pinToLandmark(target: LandmarkCoordinateSignals | {
+    x: number;
+    y: number;
+    z?: number;
+    screenX?: number;
+    screenY?: number;
+  }, options?: PinToLandmarkOptions): AnimatableNode<T>;
+  pinToObject(target: ObjectTrackSignals | LandmarkCoordinateSignals | {
+    x: number;
+    y: number;
+    z?: number;
+    screenX?: number;
+    screenY?: number;
+  }, options?: PinToObjectOptions): AnimatableNode<T>;
+  withMask(mask: unknown): AnimatableNode<T>;
+  withPbrGlass(options?: Record<string, unknown>): AnimatableNode<T>;
+  deformWithAudio(config?: MeshAudioDeformConfig | Record<string, unknown>): AnimatableNode<T>;
+  withCrop(cropConfig: CropProps | Crop): AnimatableNode<T>;
+  /** Runs vision on this node's rendered output (see `Vision` for options and modes). */
+  withVision(config?: VisionProps | Vision): AnimatableNode<T>;
+  withRelighting(options?: NormalRelightingOptions): AnimatableNode<T>;
+  relight(options?: NormalRelightingOptions): AnimatableNode<T>;
+  withDeflicker(options?: DeflickerOptions): AnimatableNode<T>;
+  apply(effect: unknown): AnimatableNode<T>;
+  withEffect(effect: unknown): AnimatableNode<T>;
+  withEffects(effects: unknown[]): AnimatableNode<T>;
+  blurRegion(trackTarget: ObjectTrackSignals, options?: Partial<BlurProps>): AnimatableNode<T>;
+  withBlurRegion(trackTarget: ObjectTrackSignals, options?: Partial<BlurProps>): AnimatableNode<T>;
+};
+declare const Layer: {
+  video: (src: string, options?: Partial<MediaNode>) => AnimatableNode<MediaNode>;
+  image: (src: string, options?: Partial<MediaNode>) => AnimatableNode<MediaNode>;
+  svg: (src: string, options?: Partial<MediaNode>) => AnimatableNode<MediaNode>;
+  lottie: (src: string, options?: Partial<MediaNode>) => AnimatableNode<MediaNode>;
+  audio: (src: string, options?: Partial<MediaNode>) => AnimatableNode<MediaNode>;
+  text: (contentOrOptions: string | TextSpan[] | (string | TextSpan)[] | Partial<TextNode>, maybeOptions?: Partial<TextNode>) => AnimatableNode<TextNode>;
+  caption: (src: string, options?: Partial<MediaNode>) => AnimatableNode<MediaNode>;
+  shape: (shapeType?: "rect" | "circle" | "ellipse" | "polygon" | "star" | "arrow" | "path", options?: Partial<ShapeNode>) => AnimatableNode<ShapeNode>;
+  flex: (options?: Partial<FlexNode>) => AnimatableNode<FlexNode>;
+  box: (options?: Partial<BoxNode>) => AnimatableNode<BoxNode>;
+  section: (source: string | MediaNode | Composition, targetOrOptions?: ObjectTrackSignals | SectionOptions, options?: SectionOptions) => SectionNode;
+  trackedRegion: (source: string | MediaNode, target: ObjectTrackSignals, options?: TrackedRegionOptions) => SectionNode;
+  blurTrackedRegion: (source: string | MediaNode, target: ObjectTrackSignals, options?: Partial<BlurProps> & {
+    borderRadius?: number;
+    padding?: number;
+    borderColor?: string;
+    borderWidth?: number;
+  }) => SectionNode;
+  /**
+   * A line, area, bar, scatter, candlestick, pie or donut chart. Returns a box
+   * of ordinary nodes (bars are boxes, lines and slices are path shapes,
+   * labels are text), so it positions, animates and composites like any layer.
+   * `props` applies to that box: position, id, timing, effects.
+   */
+  chart: (options: ChartOptions, props?: Partial<BoxNode>) => AnimatableNode<BoxNode>;
+  camera: (options?: Partial<CameraNode>) => AnimatableNode<CameraNode>;
+  light: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  ambientLight: (color?: string, intensity?: number, options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  directionalLight: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  pointLight: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  spotLight: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  cube: (options: Cube3DOptions) => AnimatableNode<BoxNode>;
+  carousel3d: (options: Carousel3DOptions) => AnimatableNode<BoxNode>;
+  plane3d: (options: Plane3DOptions) => AnimatableNode<BoxNode>;
+  prism3d: (options: Prism3DOptions) => AnimatableNode<BoxNode>;
+  model: (options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  obj: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  fbx: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  gltf: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  glb: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  stl: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  ply: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  vox: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  threeDS: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+  off: (src: string, options?: Partial<Model3DNode>) => AnimatableNode<Model3DNode>;
+};
+declare const Light: {
+  ambient: (color?: string, intensity?: number, options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  directional: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  point: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+  spot: (options?: Partial<LightNode>) => AnimatableNode<LightNode>;
+};
+declare function section(source: string | MediaNode | Composition, targetOrOptions?: ObjectTrackSignals | SectionOptions, options?: SectionOptions): SectionNode;
+declare function blurRegion(sourceOrLayer: string | AnimatableNode<MediaNode>, target: ObjectTrackSignals, options?: Partial<BlurProps> & {
+  borderRadius?: number;
+  padding?: number;
+  borderColor?: string;
+  borderWidth?: number;
+}): AnimatableNode<MediaNode> | AnimatableNode<BoxNode>;
+declare function editTrackedRegion(source: string | MediaNode, target: ObjectTrackSignals, options?: TrackedRegionOptions): SectionNode;
+declare const Effect: typeof Effect$1 & {
+  blur: (config?: BlurProps) => Blur;
+  vignette: (config?: VignetteProps) => Vignette;
+  colorBalance: (config?: ColorBalanceProps) => ColorBalance;
+  colorKey: (config?: ColorKeyProps) => ColorKey;
+  levels: (config?: LevelsProps) => Levels;
+  filmGrain: (config?: FilmGrainProps) => FilmGrain;
+  curves: (config?: CurvesProps) => Curves;
+  selectiveColor: (config?: SelectiveColorProps) => SelectiveColor;
+  gradientMap: (config?: GradientMapProps) => GradientMap;
+  shadowsHighlights: (config?: ShadowsHighlightsProps) => ShadowsHighlights;
+  applyLut: (config?: ApplyLUTProps) => ApplyLUT;
+  unsharpMask: (config?: UnsharpMaskProps) => UnsharpMask;
+  highPass: (config?: HighPassProps) => HighPass;
+  halftoneScreen: (config?: HalftoneScreenProps) => HalftoneScreen;
+  tileOffset: (config?: TileOffsetProps) => TileOffset;
+  motionBlur: (config?: MotionBlurProps) => MotionBlur;
+  ssao: (config?: SSAOProps) => SSAO;
+  pbrGlass: (config?: PBRGlassProps) => PBRGlass;
+  depthOfField: (config?: DepthOfFieldProps) => DepthOfField;
+  crop: (config?: CropProps) => Crop;
+  vision: (config?: VisionProps) => Vision;
+  relight3d: (config?: Relight3DProps) => Relight3D;
+  modulate: (config?: ModulateProps) => Modulate;
+  deflicker: (config?: DeflickerProps) => TemporalDeflicker;
+  custom: (op: string, config?: Record<string, unknown>) => CustomEffect;
+};
+type Effect<TConfig extends object = Record<string, unknown>> = Effect$1<TConfig>;
+//#endregion
+export { type AETextAnimator, AETextAnimatorSchema, type AdvancedTextAnimator, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, type AnchorGrouping, AnchorGroupingSchema, type AnchorPreset, AnchorPresetSchema, type AnimatableGlyphProps, AnimatableGlyphPropsSchema, AnimatableNode, type AnimatableProp, type AnimationClip3D, type AnimationTrack, AnimationType, AnimationTypeSchema, AnyOutputUnion, AnyOutputUnionSchema, ApplyLUT, type ApplyLUTProps, type ArcLengthLUTEntry, AudioExtractorSignalData, AudioExtractorSignalDataSchema, type AudioLatentData, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, type AudioQaStats, AudioSignal, AudioSignalExtractor, type AudioSignalExtractorProps, type AudioSignalOptions, type AudioSpectrumTypography, AudioSpectrumTypographySchema, BaseMediaOperationProps, BaseMediaOperationPropsSchema, BaseVideoLayerProps, BaseVideoLayerPropsSchema, BezierSegment3D, type BlendMode, type BlockNode, Blur, type BlurProps, type Bone3D, type BoxNode, BoxNodeSchema, CAPTION_LAYER_DEFAULTS, COCO17_BONES, COCO17_KEYPOINTS, COCO17_KEYPOINT_NAMES, COCO_CLASSES, COMPOSITE_OPERATIONS, COMPOSITOR_DEFAULTS, Camera3D, Camera3DPose, CameraAnimation, type CameraDoF, type CameraLens, type CameraNode, CameraNodeSchema, type CameraShake, CameraShakeOptions, CannyComputePipeline, type CannyOptions, type Carousel3DOptions, type CarrierHandoffConfig, CarrierHandoffConfigSchema, type CarrierState, CatmullRomOptions, type ChartAnimationOptions, type ChartAxisOptions, type ChartCandle, type ChartDatum, type ChartOptions, type ChartPadding, type ChartSeries, type ChartSlice, type ChartType, type ChartX, type ChromaticGlitchConfig, ChromaticGlitchConfigSchema, CirclePathOptions, ColorBalance, type ColorBalanceProps, ColorKey, type ColorKeyProps, type ColorSignalOptions, type ColorStop, ColorStopSchema, Composition, CompositionOptions, type CompositorProgramConfig, CompositorProgramSchema, type CompositorToProgramOptions, ConfigHandle, ConfigHandleSchema, ConfigSchemaRegistry, ConnectedInput, type ControlNetConditioningOutputs, ControlNetMultiplexer, Crop, type CropProps, type Cube3DOptions, type CubeFaceConfig, type CubeFaceInput, type CubicBezierSegment, CubicBezierSegmentSchema, Curves, type CurvesChannelPoint, type CurvesProps, CustomEffect, DATA_TYPE_EXTENSIONS, DEFAULT_CHART_COLORS, DEFAULT_DURATION_MS, DEFAULT_FPS, DEFAULT_MEDIA_DIMENSION, DataForType, DataType, DataTypeEnum, DataTypeVal, DataTypes, type DeflickerOptions, type DeflickerProps, DepthNormalsComputePipeline, type DepthNormalsOptions, DepthOfField, type DepthOfFieldProps, type DetectedObject, type DynamicStrokeProperties, DynamicStrokePropertiesSchema, type EaseRef, Easing, EditableObjectTrack, Effect, EffectConfig, EffectConfigValue, EffectPipeline, type EnhancedTextNode, EnhancedTextNodeSchema, ExportResult, ExportResultSchema, type ExpressionEvaluationContext, type ExpressionSelector, ExpressionSelectorSchema, type ExtendedGlyphProperties, ExtendedGlyphPropertiesSchema, ExtendedLayer, ExtendedLayerSchema, type ExtractedAudioSignalsBundle, type ExtrudedText3DOptions, FaceLandmarksOptions, FileAsset, FileAssetSchema, FileData, FileDataSchema, FilmGrain, type FilmGrainProps, type FlexNode, FlexNodeSchema, FontManager, FrameContext, type FrameGridOptions, type FrameGridRenderable, type FrameSamplePoint, type FrameSignal, type FromToOptions, FrustumPlane, FrustumPlanes, type GPULightData, GPUTextureBinding, GateSignalOptions, GeneratorSignalData, GeneratorSignalDataSchema, GlassPipeline, GlobalCompositeOperation, type GlyphAnchorGrouping, GlyphAnchorGroupingSchema, type GlyphAnchorPoint, GlyphAnchorPointSchema, GradientMap, type GradientMapProps, type GradientMapStop, type Grid3DOptions, type HalftoneDotShape, type HalftoneMode, HalftoneScreen, type HalftoneScreenProps, HandleType, HandleTypeVal, HeadlessMediaRenderer, HeadlessWebGPURenderer, HelixOptions, HighPass, type HighPassProps, type InstanceMask, InterpolateOptions, JsonArray, JsonObject, JsonValue, JsonValueSchema, type Keyframe, type KeyframeTuple, type KineticMarqueeConfig, KineticMarqueeConfigSchema, LIGHT_UNIFORM_SIZE_BYTES, type Landmark3D, type LandmarkCoordinateSignals, Layer, Layer3D, LayerAnimation, type LayoutNode, LayoutNodeSchema, type LevelChannel, Levels, type LevelsProps, Light, Light3D, type Light3DOptions, LightKind, type LightNode, LightNodeSchema, type LightType, LightTypeSchema, LightsUniformData, type LineSpacingDynamics, LineSpacingDynamicsSchema, type LoadModelOptions, type LongShadowConfig, LongShadowConfigSchema, MAX_LIGHTS, MIME_TYPES, type MarkOptions, type MaskTrackSignals, Mat4, type Material3D, type MaterialType, MaterialTypeSchema, Matrix4Math, Media, MediaMetadata, MediaMetadataSchema, type MediaNode, MediaNodeSchema, MediaOperation, MediaOperationSchema, MediaService, MediaSourceDescriptor, MediaSourceInput, MediaSourceSchema, type Mesh3DData, MeshAudioDeformConfig, type Model3DData, type Model3DNode, Model3DNodeSchema, ModerationError, ModerationUnrefundableError, Modulate, type ModulateProps, MotionBlur, MotionBlurPipeline, type MotionBlurProps, MultiOutputGeneric, MultiOutputGenericSchema, type NodeAnimationTrack3D, NodeMetadata, NodeMetadataSchema, NodeProcessorContext, NodeProcessorParams, NodeResult, NodeResultSchema, NodeRunFunction, NodeValidationFn, NodeVisualConfig, NodeVisualConfigSchema, type NormalRelightingOptions, type NormalizedLandmarkList, type ObjectAnchorName, type ObjectAnchorsSignals, type ObjectBoundingBox, type ObjectBoundingBoxSignals, type ObjectCollectionSignals, type ObjectKinematicsSignals, type ObjectTrackSignals, OpticalFlowComputePipeline, type OpticalFlowOptions, Output, OutputItem, OutputItemSchema, PBRGlass, type PBRGlassProps, type ParticleDissolveConfig, ParticleDissolveConfigSchema, Path3D, Path3DPoint, Path3DSample, type PathChainLUT, type PathChainLUTEntry, type PersonMatte, type PinToLandmarkOptions, type PinToObjectOptions, type Plane3DOptions, type PoseLandmarkSignals, type PoseResult, PoseSkeletonOptions, PoseSkeletonRenderer, type PreviewCloseReason, type PreviewOptions, type PreviewSession, type PreviewSource, type Prism3DOptions, ProgrammaticSignal, ProgrammaticSignalOptions, type QaIssue, type QaSegment, type RegisterFontOptions, type RegisteredFont, Relight3D, type Relight3DProps, type RenderContextValue, RenderDiagnostic, RenderVideoOptions, RenderVideoResult, type RenderedSfx, Renderer2D, Renderer3D, SSAO, SSAOPipeline, type SSAOProps, Scene, type SceneDefinition, SceneDefinitionSchema, type SceneOptions, type SceneTransitionType, SceneTransitionTypeSchema, SectionNode, SectionOptions, SegmentationOptions, type SegmentationResult, SegmentationTexturePool, SelectiveColor, type SelectiveColorAdjustment, type SelectiveColorProps, type SelectorBasedOn, SelectorBasedOnSchema, type SelectorMode, SelectorModeSchema, type SelectorShape, SelectorShapeSchema, type SelectorUnits, SelectorUnitsSchema, Sequence, type SequenceOptions, type SequenceTimelineResult, type SfxRenderContext, type SfxTrigger, ShadowPipeline, ShadowsHighlights, type ShadowsHighlightsProps, type Shape3DContainer, type ShapeNode, ShapeNodeSchema, Signal, SignalBuilderConfig, SignalChannelMeta, SignalChannelMetaSchema, type SignalContext, SignalData, SignalDataSchema, SignalGateData, SignalGateDataSchema, SignalMathData, SignalMathDataSchema, SignalStats, SignalStatsSchema, type SignalTrackOptions, type SignalValue, type SineSignalOptions, SingleOutputGeneric, SingleOutputGenericSchema, type Skeleton3D, type SkewProperties, SkewPropertiesSchema, SlugFontCache, SlugPipeline, SmartFramingOptions, SourceOperationSchema, type Spatial3DProperties, Spatial3DPropertiesSchema, SpatialLandmarkTransformer, SpringConfig, type SpringOptions, type SpringPhysics, SpringPhysicsSchema, StorageService, StrokeRect, SubjectOutlineOptions, SubjectSandwichOptions, TEXT_LAYER_DEFAULTS, TemporalDeflicker, TemporalDeflickerPipeline, TemporalObjectTracker, TensorData, type TensorDimensions, type TensorFormat, type TensorNode, TensorPipeline, type TensorPipelineConfig, type TensorSource, type TensorViewExport, type Text3DOptions, type TextAnchorConfig, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, type TextCursorConfig, TextCursorConfigSchema, type TextCursorStyle, TextCursorStyleSchema, TextMeasureResult, TextMeasureStyle, type TextNode, TextNodeSchema, TextOperationSchema, TextPathBuilder, type TextPathOptions, TextPathOptionsSchema, type TextPathSource, TextPathSourceSchema, type TextRangeSelector, TextRangeSelectorSchema, type TextScrambleConfig, TextScrambleConfigSchema, type TextSelector, TextSelectorSchema, type TextSignalSelector, TextSignalSelectorSchema, type TextSpan, type TextSpanItem, type TextSpanMark, TextSpanMarkSchema, TextSpanSchema, type TextWigglySelector, TextWigglySelectorSchema, TileOffset, type TileOffsetEdgeMode, type TileOffsetProps, TimelineSegmentSchema, TimelineTransform, TimelineTransformSchema, TrackEditing, type TrackSource, type TrackedObject, TrackedRegionOptions, Transition, TransitionSchema, TransitionType, TransitionTypeSchema, type TypewriterAnimator, TypewriterAnimatorSchema, type TypingCadence, TypingCadenceSchema, UnsharpMask, type UnsharpMaskProps, type VariableFontAxes, VariableFontAxesSchema, type Vec2, Vec2Schema, Vec3, Vector3Math, VideoAnimation, VideoAnimationSchema, VideoLayerType, VideoLayerTypeSchema, type VideoQaOptions, type VideoQaReport, type VideoQaStats, VideoSpatialPropsSchema, VideoStylePropsSchema, VideoTextPropsSchema, VideoTimingPropsSchema, Vignette, type VignetteProps, VirtualMediaData, VirtualMediaDataSchema, Vision, type VisionAnalysisReport, VisionBundle, type VisionConfig, VisionNode, VisionNodeSpec, type VisionProps, VisionRunner, type VisionTask, type VisionVariant, type VolumetricFormationConfig, VolumetricFormationConfigSchema, type VolumetricFormationMode, VolumetricFormationModeSchema, type WiggleOptions, WritableSignal, XYPosition, accent, analyzeSequence, appendOperation, applyStaggerToChildren, bezier, blurRegion, bold, buildPathLUT, calculateSequenceTimeline, checkNodeResultCache, code, collectNodeOps, color, compositorToProgram, computeAnchorPivotOffset, computeCarrierContinuity, computeGridLayout, computeLayout, computeLayoutSync, computeLineLeadingDisplacement, computeRangeSelectorWeight, computeStaggerDelay, computeStrokeRect, computeVideoCropRenderProps, computed, cosineSignal, createOutputItemSchema, createVirtualMedia, dataTypeColors, deserializeSignalData, deterministicWigglyNoise, distanceToCurveParameter, editTrackedRegion, ellipseToCubicBeziers, encodeStereoWav, ensureDevice, evaluateAnimationAtFrame, evaluateCubicBezier, evaluateCubicBezierDerivative, evaluateExpressionSelector, evaluateMarqueeOffset, evaluateSelectorCombination, evaluateSkewMatrix, evaluateSpringProgress, evaluateTrackAtFrame, evaluateTypewriterState, evaluateVolumetricFormation, extractSvgDimensions, findSourceAsset, formatQaReport, frameArraySignal, frameSignal, generateArcLengthLUT, generateId, generatePathSegments, getActiveMediaMetadata, getFileDataMetadata, getFingerprint, getLeafMediaType, getMediaType, getRenderFingerprint, getScramblePool, getShuffledOrder, hasOnlySingleSource, inputStore, interpolate, isEqual, isSignal, isVirtualMediaData, italic, loadFBX, loadModel3D, loadOBJ, lutStore, mapBlendModeToSkia, mark, measureSpring, measureText, measureTextAsync, mixAudioTracks, mixSfxInto, normalizeTextSpans, parseColorToRgb, parseFBX, parseMTL, parseMarkup, parseOBJ, parseSvgPathToCubicBeziers, pinNodeToLandmark, pinNodeToObject, preloadFont, programmaticSignal, progressSignal, registerSignalDependency, renderFrameGrid, renderSemaphore, renderSfx, reportRenderDiagnostic, requiresIsolation, resolveMediaMimeType, resolveSamplePoints, rich, sampleAudioSpectrumScale, sampleCurveGeometry, samplePathChainGeometry, section, serializeSignalData, shaderStore, signal, signalBuilder, signalRegistry, sineSignal, size, softLimit, span, spring, springCalculation, stampResult, startPreview, sub, sup, takeRenderDiagnostics, textureCache, timeSignal, updateClockSignals, waveToCubicBeziers };
+//# sourceMappingURL=index.d.mts.map