gitframes 1.2.35

package/dist/index.d.mts

@@ -0,0 +1,736 @@
+import { _ as renderSfx, f as encodeStereoWav, g as mixSfxInto, h as SfxTrigger, m as SfxRenderContext, o as mixAudioTracks, p as RenderedSfx, v as softLimit } from "./index-FICUHo4P.mjs";
+import { n as AudioSignalOptions, r as ExtractedAudioSignalsBundle, t as AudioSignal } from "./audio-C0YslYEG.mjs";
+import { $ as HalftoneScreen, At as YoloProps, B as CurvesChannelPoint, Bt as Vignette, Ct as TemporalDeflicker, Dt as UnsharpMask, Et as TileOffsetProps, F as AudioSignalExtractor, Ft as ColorBalance, G as DepthOfFieldProps, H as CustomEffect, I as AudioSignalExtractorProps, It as ColorBalanceProps, J as GradientMap, K as FilmGrain, L as Crop, Lt as ColorKey, N as ApplyLUT, Nt as Blur, Ot as UnsharpMaskProps, P as ApplyLUTProps, Pt as BlurProps, Q as HalftoneMode, R as CropProps, Rt as ColorKeyProps, St as ShadowsHighlightsProps, Tt as TileOffsetEdgeMode, U as DeflickerProps, V as CurvesProps, Vt as VignetteProps, W as DepthOfField, X as GradientMapStop, Y as GradientMapProps, Z as HalftoneDotShape, _t as SSAOProps, at as LevelsProps, bt as SelectiveColorProps, ct as Modulate, dt as MotionBlurProps, et as HalftoneScreenProps, ft as PBRGlass, gt as SSAO, ht as Relight3DProps, it as Levels, kt as Yolo, lt as ModulateProps, mt as Relight3D, nt as HighPassProps, ot as MediaPipe, pt as PBRGlassProps, q as FilmGrainProps, rt as LevelChannel, st as MediaPipeProps, tt as HighPass, ut as MotionBlur, vt as SelectiveColor, wt as TileOffset, xt as ShadowsHighlights, yt as SelectiveColorAdjustment, z as Curves } from "./index-B1557AUi.mjs";
+import { n as RegisterFontOptions, r as RegisteredFont, t as FontManager } from "./index-DSaMXGoA.mjs";
+import { FrameSignal, Signal, SignalContext, SignalValue, SineSignalOptions, computed, cosineSignal, signal, signalBuilder, signalRegistry, sineSignal } from "./signals/index.mjs";
+import { a as FrameGridOptions, c as computeGridLayout, i as renderSemaphore, l as renderFrameGrid, n as HeadlessWebGPURenderer, o as FrameGridRenderable, s as FrameSamplePoint, t as HeadlessMediaRenderer, u as resolveSamplePoints } from "./index-YZsTjqut.mjs";
+import { AnimationClip3D, AudioLatentData, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, BlendMode, Bone3D, Camera3D, ChartGPUEngineBridge, ChartNodeProps, EffectPipeline, GPULightData, GlassPipeline, HeadlessChartCanvasElementMock, HeadlessChartContainerMock, HeadlessChartTarget, HeadlessGPUCanvasContextMock, Light3D, Light3DOptions, LoadModelOptions, Material3D, Mesh3DData, Model3DData, MotionBlurPipeline, NodeAnimationTrack3D, Path3D, RenderContextValue, Renderer2D, Renderer3D, SSAOPipeline, ShadowPipeline, Skeleton3D, SlugFontCache, SlugPipeline, chartBridgeCache, drawChartNode, ensureDevice, inputStore, loadFBX, loadModel3D, loadOBJ, lutStore, parseFBX, parseMTL, parseOBJ, shaderStore, textureCache } from "@gitframes/webgpu-renderers";
+import { DataType, Effect as Effect$1, FrameContext, MediaMetadata, MediaSourceInput, MeshAudioDeformConfig, ProgrammaticSignal, Signal as Signal$1, TextSpan, TextSpanMark, VirtualMediaData } from "@gitframes/core";
+import { DetectedObject, Landmark3D, LandmarkCoordinateSignals, LandmarkCoordinateSignals as LandmarkCoordinateSignals$1, MEDIAPIPE_TO_YOLO_POSE_INDEX, MaskTrackSignals as MaskTrackSignals$1, NormalizedLandmarkList, ObjectAnchorName, ObjectAnchorsSignals, ObjectBoundingBox, ObjectBoundingBoxSignals, ObjectCollectionSignals, ObjectKinematicsSignals, ObjectTrackSignals, ObjectTrackSignals as ObjectTrackSignals$1, POSE_LANDMARKS_YOLO, PinToLandmarkOptions, PinToLandmarkOptions as PinToLandmarkOptions$1, PinToObjectOptions, PinToObjectOptions as PinToObjectOptions$1, PoseLandmarkSignals, PoseSkeletonRenderer, SegmentationTexturePool, SpatialLandmarkTransformer, TemporalObjectTracker, TrackedObject, VisionAnalysisReport, VisionAnalysisReport as VisionAnalysisReport$1, YOLO_COCO17_BONES, YOLO_POSE_KEYPOINT_NAMES, YoloConfig, YoloInstanceMask, YoloNode, YoloNode as YoloNode$1, YoloOBBResult, YoloPoseResult, YoloSegmentationResult, YoloVisionBundle, YoloVisionBundle as YoloVisionBundle$1, YoloVisionRunner, analyzeSequence, pinNodeToLandmark, pinNodeToObject } from "@gitframes/yolo";
+import { CannyComputePipeline, CannyOptions, ControlNetConditioningOutputs, ControlNetMultiplexer, DeflickerOptions, DeflickerOptions as DeflickerOptions$1, DepthNormalsComputePipeline, DepthNormalsOptions, NormalRelightingOptions, NormalRelightingOptions as NormalRelightingOptions$1, OpticalFlowComputePipeline, OpticalFlowOptions, TemporalDeflickerPipeline, TensorDimensions, TensorFormat, TensorNode, TensorPipeline, TensorPipeline as TensorPipeline$1, TensorPipelineConfig, TensorSource, TensorViewExport } from "@gitframes/tensor-webgpu";
+import { AETextAnimator, AETextAnimatorSchema, AdvancedTextAnimator, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, AnchorGrouping, AnchorGroupingSchema, AnchorPreset, AnchorPresetSchema, AnimatableGlyphProps, AnimatableGlyphPropsSchema, AnimatableProp, AnimationTrack, AnimationTrack as AnimationTrack$1, ArcLengthLUTEntry, AudioSpectrumTypography, AudioSpectrumTypographySchema, BlockNode, BoxNode, BoxNode as BoxNode$1, BoxNodeSchema, CameraAnimation, CameraDoF, CameraLens, CameraNode, CameraNode as CameraNode$1, CameraNodeSchema, CameraShake, CarrierHandoffConfig, CarrierHandoffConfigSchema, CarrierState, ChartAreaStyle, ChartAreaStyleSchema, ChartAxis, ChartAxisSchema, ChartDataPoint2D, ChartDataPoint2DSchema, ChartDataPointOHLC, ChartDataPointOHLCSchema, ChartGPUOptions, ChartGPUOptions as ChartGPUOptions$1, ChartGPUOptionsSchema, ChartLineStyle, ChartLineStyleSchema, ChartNode, ChartNode as ChartNode$1, ChartNodeSchema, ChartPointStyle, ChartPointStyleSchema, ChartSeries, ChartSeriesSchema, ChartSeriesType, ChartSeriesTypeSchema, ChromaticGlitchConfig, ChromaticGlitchConfigSchema, ColorSignalOptions, ColorStop, ColorStopSchema, CompositionChartNodeSchema, CompositorProgramConfig, CompositorProgramConfig as CompositorProgramConfig$1, CompositorProgramSchema, CompositorToProgramOptions, CompositorToProgramOptions as CompositorToProgramOptions$1, CubicBezierSegment, CubicBezierSegmentSchema, DynamicStrokeProperties, DynamicStrokePropertiesSchema, EaseRef, EnhancedTextNode, EnhancedTextNodeSchema, ExpressionEvaluationContext, ExpressionSelector, ExpressionSelectorSchema, ExtendedGlyphProperties, ExtendedGlyphPropertiesSchema, FlexNode, FlexNode as FlexNode$1, FlexNodeSchema, FromToOptions, GlyphAnchorGrouping, GlyphAnchorGroupingSchema, GlyphAnchorPoint, GlyphAnchorPointSchema, Keyframe, KineticMarqueeConfig, KineticMarqueeConfigSchema, LayerAnimation, LayerAnimation as LayerAnimation$1, LayoutNode, LayoutNode as LayoutNode$1, LayoutNodeSchema, LightNode, LightNode as LightNode$1, LightNodeSchema, LightType, LightTypeSchema, LineSpacingDynamics, LineSpacingDynamicsSchema, LongShadowConfig, LongShadowConfigSchema, MaterialType, MaterialType as MaterialType$1, MaterialTypeSchema, MediaNode, MediaNode as MediaNode$1, MediaNodeSchema, Model3DNode, Model3DNode as Model3DNode$1, Model3DNodeSchema, ParticleDissolveConfig, ParticleDissolveConfigSchema, PathChainLUT, PathChainLUTEntry, Scene, SceneDefinition, SceneDefinitionSchema, SceneOptions, SceneTransitionType, SceneTransitionTypeSchema, SelectorBasedOn, SelectorBasedOnSchema, SelectorMode, SelectorModeSchema, SelectorShape, SelectorShapeSchema, SelectorUnits, SelectorUnitsSchema, Sequence, SequenceOptions, SequenceTimelineResult, ShapeNode, ShapeNode as ShapeNode$1, ShapeNodeSchema, SignalTrackOptions, SkewProperties, SkewPropertiesSchema, Spatial3DProperties, Spatial3DPropertiesSchema, SpringOptions, SpringPhysics, SpringPhysicsSchema, TextAnchorConfig, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, TextCursorConfig, TextCursorConfigSchema, TextCursorStyle, TextCursorStyleSchema, TextNode, TextNode as TextNode$1, TextNodeSchema, TextPathBuilder, TextPathOptions, TextPathOptionsSchema, TextPathSource, TextPathSourceSchema, TextRangeSelector, TextRangeSelectorSchema, TextScrambleConfig, TextScrambleConfigSchema, TextSelector, TextSelectorSchema, TextSignalSelector, TextSignalSelectorSchema, TextSpanMarkSchema, TextSpanSchema, TextWigglySelector, TextWigglySelectorSchema, TrackSource, TypewriterAnimator, TypewriterAnimatorSchema, TypingCadence, TypingCadenceSchema, VariableFontAxes, VariableFontAxesSchema, Vec2, Vec2Schema, VolumetricFormationConfig, VolumetricFormationConfigSchema, VolumetricFormationMode, VolumetricFormationModeSchema, WiggleOptions, applyStaggerToChildren, buildPathLUT, calculateSequenceTimeline, collectNodeOps, compositorToProgram, computeAnchorPivotOffset, computeCarrierContinuity, computeLayout, computeLayoutSync, computeLineLeadingDisplacement, computeRangeSelectorWeight, computeStaggerDelay, deterministicWigglyNoise, distanceToCurveParameter, ellipseToCubicBeziers, evaluateAnimationAtFrame, evaluateCubicBezier, evaluateCubicBezierDerivative, evaluateExpressionSelector, evaluateMarqueeOffset, evaluateSelectorCombination, evaluateSkewMatrix, evaluateSpringProgress, evaluateTrackAtFrame, evaluateTypewriterState, evaluateVolumetricFormation, generateArcLengthLUT, generatePathSegments, getScramblePool, getShuffledOrder, parseSvgPathToCubicBeziers, sampleAudioSpectrumScale, sampleCurveGeometry, samplePathChainGeometry, waveToCubicBeziers } from "@gitframes/compositions/program";
+export * from "@gitframes/core";
+export * from "@gitframes/renderers";
+
+//#region src/rich-text.d.ts
+type TextSpanItem = string | number | boolean | Signal$1<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$1<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function bold(text: string | Signal$1<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function italic(text: string | Signal$1<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function accent(text: string | Signal$1<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function color(text: string | Signal$1<string>, fill: string | Signal$1<string>, options?: Omit<TextSpan, "text" | "fill">): TextSpan;
+declare function size(text: string | Signal$1<string>, fontSize: number | Signal$1<number>, options?: Omit<TextSpan, "text" | "fontSize">): TextSpan;
+interface MarkOptions extends Omit<TextSpan, "text" | "mark" | "fill"> {
+  bg?: string | Signal$1<string>;
+  fill?: string | Signal$1<string>;
+  radius?: number;
+  paddingX?: number;
+  paddingY?: number;
+}
+declare function mark(text: string | Signal$1<string>, options?: MarkOptions): TextSpan;
+declare function sup(text: string | Signal$1<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function sub(text: string | Signal$1<string>, options?: Omit<TextSpan, "text">): TextSpan;
+declare function code(text: string | Signal$1<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 src/shapes3d.d.ts
+interface CubeFaceConfig {
+  background?: string;
+  borderRadius?: number;
+  borderWidth?: number;
+  borderColor?: string;
+  opacity?: number;
+  material?: MaterialType$1;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  children?: LayoutNode$1[];
+}
+type CubeFaceInput = CubeFaceConfig | LayoutNode$1 | 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$1;
+  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$1[];
+  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$1;
+  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$1;
+  shininess?: number;
+  roughness?: number;
+  specularIntensity?: number;
+  metallic?: number;
+  ambientIntensity?: number;
+  ior?: number;
+  transmission?: number;
+  dispersion?: number;
+  fresnelPower?: number;
+  envIntensity?: number;
+  opacity?: number;
+  children?: LayoutNode$1[];
+}
+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;
+  align?: "start" | "center" | "end" | "left" | "right";
+  verticalAlign?: "top" | "middle" | "bottom";
+  letterSpacing?: number;
+  lineHeight?: number;
+  is3D?: boolean;
+  twoSided?: boolean;
+  material?: MaterialType$1;
+  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;
+  extrusionSteps?: number;
+  bevelColor?: string;
+}
+interface ExtrudedText3DOptions extends Text3DOptions {
+  depth: number;
+  slices?: number;
+  curveSegments?: number;
+}
+type Shape3DContainer = AnimatableNode<BoxNode$1> & {
+  faces?: AnimatableNode<BoxNode$1>[];
+  items?: LayoutNode$1[];
+  [Symbol.iterator](): Iterator<LayoutNode$1>;
+};
+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$1>;
+  /**
+   * 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$1>;
+  /**
+   * Creates a standalone planar 3D text node or multi-slice extruded 3D text.
+   */
+  text(options: Text3DOptions): AnimatableNode<LayoutNode$1>;
+  /**
+   * Creates multi-slice volumetric extruded 3D typography with depth shading.
+   */
+  extrudedText(options: ExtrudedText3DOptions): Shape3DContainer;
+  /**
+   * Creates a 3D model node rendered natively with WebGPU mesh shaders.
+   */
+  model(options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D Wavefront OBJ model node.
+   */
+  obj(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D Autodesk FBX model node with skeletal animation support.
+   */
+  fbx(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D glTF 2.0 model node.
+   */
+  gltf(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D GLB binary container model node.
+   */
+  glb(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D STL CAD / 3D printing model node.
+   */
+  stl(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D Stanford PLY scan model node.
+   */
+  ply(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D MagicaVoxel VOX model node.
+   */
+  vox(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D Studio (3DS) binary model node.
+   */
+  threeDS(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+  /**
+   * Convenience helper to create a 3D Object File Format (OFF) model node.
+   */
+  off(src: string, options?: Partial<Model3DNode$1>): AnimatableNode<Model3DNode$1>;
+};
+//#endregion
+//#region src/index.d.ts
+interface SectionOptions {
+  readonly id?: string;
+  readonly position?: "absolute" | "relative";
+  readonly source?: string | MediaNode$1;
+  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$1[];
+  readonly [key: string]: unknown;
+}
+type SectionNode = AnimatableNode<BoxNode$1> & {
+  readonly innerMedia: AnimatableNode<MediaNode$1>;
+  readonly effects: Effect[];
+  addEffect(effect: Effect): SectionNode;
+  withEffect(effect: Effect): SectionNode;
+  withEffects(effects: Effect[]): SectionNode;
+};
+type TrackedRegionOptions = SectionOptions;
+interface CompositionOptions {
+  width: number;
+  height: number;
+  fps?: number;
+  durationMs?: number;
+  durationFrames?: number;
+  backgroundColor?: string;
+  fonts?: string[];
+  signals?: Record<string, unknown>;
+}
+/**
+ * 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 | {
+    codec?: string;
+    audioCodec?: string;
+    quality?: string;
+    concurrency?: number;
+    outputPath?: string;
+    renderer?: HeadlessMediaRenderer;
+  }, options?: {
+    codec?: string;
+    audioCodec?: string;
+    quality?: string;
+    concurrency?: number;
+    outputPath?: string;
+    renderer?: HeadlessMediaRenderer;
+  }): Promise<{
+    filePath: string;
+    cleanup: () => Promise<void>;
+  }>;
+}
+interface SubjectSandwichOptions {
+  readonly source: string | MediaNode$1;
+  readonly subject?: MaskTrackSignals | ObjectTrackSignals$1;
+  readonly behind: readonly LayoutNode$1[];
+  readonly feather?: number;
+  readonly fit?: "cover" | "contain" | "fill";
+  readonly variant?: "n" | "s" | "m" | "l" | "x";
+  readonly confidence?: number;
+  readonly keyBackground?: boolean;
+  readonly backgroundKeyThreshold?: number;
+  readonly muted?: boolean;
+  readonly volume?: number;
+}
+interface SmartFramingOptions {
+  readonly source: string | MediaNode$1;
+  readonly targetAspect?: number;
+  readonly sourceAspect?: number;
+  readonly target: ObjectTrackSignals$1 | MaskTrackSignals;
+  readonly damping?: number;
+  readonly leadHeadroom?: number;
+  readonly fit?: "cover" | "contain" | "fill";
+  readonly variant?: "n" | "s" | "m" | "l" | "x";
+  readonly muted?: boolean;
+  readonly volume?: number;
+}
+interface SubjectOutlineOptions {
+  readonly source?: string | MediaNode$1;
+  readonly color?: string;
+  readonly width?: number;
+  readonly blur?: number;
+  readonly pulseSignal?: ProgrammaticSignal | Signal$1<number>;
+  readonly muted?: boolean;
+  readonly volume?: number;
+}
+/**
+ * High-level programmatic builder for multi-layer Gitframes compositions.
+ */
+declare class Composition {
+  width: number;
+  height: number;
+  fps: number;
+  durationMs?: number;
+  backgroundColor: string;
+  fonts: string[];
+  children: LayoutNode$1[];
+  audioTracks: MediaNode$1[];
+  signals: Record<string, unknown>;
+  private _frameHooks;
+  private _yoloConfig?;
+  private _yoloBundle?;
+  private _effects;
+  /**
+   * Applies a whole-composition post-processing effect or vision pipeline.
+   */
+  apply(effect: unknown): this;
+  /**
+   * @deprecated Use `withYolo`. Alias that maps the legacy MediaPipe config onto the YOLO
+   * engine; the legacy option shape (`enablePoseLandmarks`, `enableSegmentation`, …) is accepted.
+   */
+  withMediaPipe(config?: MediaPipeProps | MediaPipe): YoloVisionBundle$1;
+  /**
+   * Attaches YOLO11 on top of the whole composition in one go — the rendered frame
+   * (composition, blur, modulate, crop — anything upstream) is the inference input.
+   * Models are LAZY: nothing downloads until the first frame actually runs a task.
+   * Returns a reactive YoloVisionBundle (objects / masks / pose / classes signals).
+   */
+  withYolo(config?: YoloProps | Yolo): YoloVisionBundle$1;
+  /**
+   * One-shot, ffmpeg-free vision analysis of a media source (specs/yolov4plan.ts §Phase C).
+   *
+   * Decodes frames through the same mediabunny pipeline the renderer uses, runs the requested
+   * YOLO 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 ("detect" | "segment" | "pose" | "obb" | "classify")[];
+    categories?: readonly string[];
+    fps?: number;
+    totalFrames?: number;
+    pathStride?: number;
+    includeMasks?: boolean;
+    modelsDir?: string;
+    baseUrl?: string;
+    confidence?: number;
+    iouThreshold?: number;
+  }): Promise<VisionAnalysisReport$1>;
+  /**
+   * 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$1 | LayoutNode$1[] | TensorPipeline$1 | YoloNode$1 | {
+    node: unknown;
+  }, ...rest: Array<LayoutNode$1 | LayoutNode$1[] | TensorPipeline$1 | YoloNode$1 | {
+    node: unknown;
+  } | LayerAnimation$1 | {
+    tracks: AnimationTrack$1[];
+  }>): this;
+  addAudio(track: MediaNode$1): 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$1, 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$1 | ObjectTrackSignals$1 | SectionOptions, targetOrOptions?: ObjectTrackSignals$1 | SectionOptions, options?: SectionOptions): SectionNode;
+  /**
+   * Creates a section and immediately adds it to the composition layout tree.
+   */
+  addSection(sourceOrTargetOrOptions?: string | MediaNode$1 | ObjectTrackSignals$1 | SectionOptions, targetOrOptions?: ObjectTrackSignals$1 | 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$1;
+  /**
+   * Compiles the composition into a VirtualMediaData AST ready for WebGPU rendering.
+   */
+  toVirtualMedia(options?: Partial<CompositorToProgramOptions$1>): VirtualMediaData;
+  /**
+   * Compiles the composition into a VirtualMediaData AST with dynamically resolved duration.
+   */
+  toVirtualMediaAsync(options?: Partial<CompositorToProgramOptions$1>): 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 | {
+    codec?: string;
+    audioCodec?: string;
+    quality?: string;
+    concurrency?: number;
+    outputPath?: string;
+    renderer?: HeadlessMediaRenderer;
+  }, options?: {
+    codec?: string;
+    audioCodec?: string;
+    quality?: string;
+    concurrency?: number;
+    outputPath?: string;
+    renderer?: HeadlessMediaRenderer;
+  }): Promise<{
+    filePath: string;
+    cleanup: () => Promise<void>;
+  }>;
+}
+/**
+ * Layer helpers for constructing composition nodes with clean URL/path strings.
+ */
+type AnimatableNode<T extends LayoutNode$1> = T & {
+  blendshapes?: Record<string, unknown>;
+  hasBlendshapes?: boolean;
+  mask?: unknown;
+  glass?: Record<string, unknown>;
+  audioDeform?: MeshAudioDeformConfig | Record<string, unknown>;
+  crop?: CropProps | Crop;
+  yolo?: YoloProps | Yolo;
+  relighting?: NormalRelightingOptions$1;
+  deflicker?: DeflickerOptions$1;
+  effects?: unknown[];
+  blurRegions?: unknown[];
+  [key: string]: unknown;
+  animate(...anim: (LayerAnimation$1 | {
+    tracks: AnimationTrack$1[];
+  } | LayerAnimation$1[])[]): AnimatableNode<T>;
+  pinToLandmark(target: LandmarkCoordinateSignals$1 | {
+    x: number;
+    y: number;
+    z?: number;
+    screenX?: number;
+    screenY?: number;
+  }, options?: PinToLandmarkOptions$1): AnimatableNode<T>;
+  pinToObject(target: ObjectTrackSignals$1 | LandmarkCoordinateSignals$1 | {
+    x: number;
+    y: number;
+    z?: number;
+    screenX?: number;
+    screenY?: number;
+  }, options?: PinToObjectOptions$1): AnimatableNode<T>;
+  /** @deprecated Face blendshapes were removed with MediaPipe; accepted but a no-op. */
+  driveBlendshapes(blendshapes: Record<string, unknown>): 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>;
+  withMediaPipe(config?: MediaPipeProps | MediaPipe): AnimatableNode<T>;
+  withYolo(config?: YoloProps | Yolo): AnimatableNode<T>;
+  withRelighting(options?: NormalRelightingOptions$1): AnimatableNode<T>;
+  relight(options?: NormalRelightingOptions$1): AnimatableNode<T>;
+  withDeflicker(options?: DeflickerOptions$1): AnimatableNode<T>;
+  apply(effect: unknown): AnimatableNode<T>;
+  withEffect(effect: unknown): AnimatableNode<T>;
+  withEffects(effects: unknown[]): AnimatableNode<T>;
+  blurRegion(trackTarget: ObjectTrackSignals$1, options?: Partial<BlurProps>): AnimatableNode<T>;
+  withBlurRegion(trackTarget: ObjectTrackSignals$1, options?: Partial<BlurProps>): AnimatableNode<T>;
+};
+declare const Layer: {
+  video: (src: string, options?: Partial<MediaNode$1>) => AnimatableNode<MediaNode$1>;
+  image: (src: string, options?: Partial<MediaNode$1>) => AnimatableNode<MediaNode$1>;
+  svg: (src: string, options?: Partial<MediaNode$1>) => AnimatableNode<MediaNode$1>;
+  lottie: (src: string, options?: Partial<MediaNode$1>) => AnimatableNode<MediaNode$1>;
+  audio: (src: string, options?: Partial<MediaNode$1>) => AnimatableNode<MediaNode$1>;
+  text: (contentOrOptions: string | TextSpan[] | (string | TextSpan)[] | Partial<TextNode$1>, maybeOptions?: Partial<TextNode$1>) => AnimatableNode<TextNode$1>;
+  caption: (src: string, options?: Partial<MediaNode$1>) => AnimatableNode<MediaNode$1>;
+  shape: (shapeType?: "rect" | "circle" | "ellipse" | "polygon" | "star" | "arrow" | "path", options?: Partial<ShapeNode$1>) => AnimatableNode<ShapeNode$1>;
+  flex: (options?: Partial<FlexNode$1>) => AnimatableNode<FlexNode$1>;
+  box: (options?: Partial<BoxNode$1>) => AnimatableNode<BoxNode$1>;
+  section: (source: string | MediaNode$1 | Composition, targetOrOptions?: ObjectTrackSignals$1 | SectionOptions, options?: SectionOptions) => SectionNode;
+  trackedRegion: (source: string | MediaNode$1, target: ObjectTrackSignals$1, options?: TrackedRegionOptions) => SectionNode;
+  blurTrackedRegion: (source: string | MediaNode$1, target: ObjectTrackSignals$1, options?: Partial<BlurProps> & {
+    borderRadius?: number;
+    padding?: number;
+    borderColor?: string;
+    borderWidth?: number;
+  }) => SectionNode;
+  chart: (options: ChartGPUOptions$1, props?: Partial<ChartNode$1>) => AnimatableNode<ChartNode$1>;
+  camera: (options?: Partial<CameraNode$1>) => AnimatableNode<CameraNode$1>;
+  light: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  ambientLight: (color?: string, intensity?: number, options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  directionalLight: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  pointLight: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  spotLight: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  cube: (options: Cube3DOptions) => AnimatableNode<BoxNode$1>;
+  carousel3d: (options: Carousel3DOptions) => AnimatableNode<BoxNode$1>;
+  plane3d: (options: Plane3DOptions) => AnimatableNode<BoxNode$1>;
+  prism3d: (options: Prism3DOptions) => AnimatableNode<BoxNode$1>;
+  model: (options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  obj: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  fbx: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  gltf: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  glb: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  stl: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  ply: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  vox: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  threeDS: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+  off: (src: string, options?: Partial<Model3DNode$1>) => AnimatableNode<Model3DNode$1>;
+};
+declare const Light: {
+  ambient: (color?: string, intensity?: number, options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  directional: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  point: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+  spot: (options?: Partial<LightNode$1>) => AnimatableNode<LightNode$1>;
+};
+declare function section(source: string | MediaNode$1 | Composition, targetOrOptions?: ObjectTrackSignals$1 | SectionOptions, options?: SectionOptions): SectionNode;
+declare function blurRegion(sourceOrLayer: string | AnimatableNode<MediaNode$1>, target: ObjectTrackSignals$1, options?: Partial<BlurProps> & {
+  borderRadius?: number;
+  padding?: number;
+  borderColor?: string;
+  borderWidth?: number;
+}): AnimatableNode<MediaNode$1> | AnimatableNode<BoxNode$1>;
+declare function editTrackedRegion(source: string | MediaNode$1, target: ObjectTrackSignals$1, 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;
+  mediaPipe: (config?: MediaPipeProps) => MediaPipe;
+  yolo: (config?: YoloProps) => Yolo;
+  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, ApplyLUT, type ApplyLUTProps, type ArcLengthLUTEntry, type AudioLatentData, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, AudioSignal, AudioSignalExtractor, type AudioSignalExtractorProps, type AudioSignalOptions, type AudioSpectrumTypography, AudioSpectrumTypographySchema, type BlendMode, type BlockNode, Blur, type BlurProps, type Bone3D, type BoxNode, BoxNodeSchema, Camera3D, CameraAnimation, type CameraDoF, type CameraLens, type CameraNode, CameraNodeSchema, type CameraShake, CannyComputePipeline, type CannyOptions, type Carousel3DOptions, type CarrierHandoffConfig, CarrierHandoffConfigSchema, type CarrierState, type ChartAreaStyle, ChartAreaStyleSchema, type ChartAxis, ChartAxisSchema, type ChartDataPoint2D, ChartDataPoint2DSchema, type ChartDataPointOHLC, ChartDataPointOHLCSchema, ChartGPUEngineBridge, type ChartGPUOptions, ChartGPUOptionsSchema, type ChartLineStyle, ChartLineStyleSchema, type ChartNode, type ChartNodeProps, ChartNodeSchema, type ChartPointStyle, ChartPointStyleSchema, type ChartSeries, ChartSeriesSchema, type ChartSeriesType, ChartSeriesTypeSchema, type ChromaticGlitchConfig, ChromaticGlitchConfigSchema, ColorBalance, type ColorBalanceProps, ColorKey, type ColorKeyProps, type ColorSignalOptions, type ColorStop, ColorStopSchema, Composition, CompositionChartNodeSchema, CompositionOptions, type CompositorProgramConfig, CompositorProgramSchema, type CompositorToProgramOptions, type ControlNetConditioningOutputs, ControlNetMultiplexer, Crop, type CropProps, type Cube3DOptions, type CubeFaceConfig, type CubeFaceInput, type CubicBezierSegment, CubicBezierSegmentSchema, Curves, type CurvesChannelPoint, type CurvesProps, CustomEffect, type DeflickerOptions, type DeflickerProps, DepthNormalsComputePipeline, type DepthNormalsOptions, DepthOfField, type DepthOfFieldProps, type DetectedObject, type DynamicStrokeProperties, DynamicStrokePropertiesSchema, type EaseRef, Effect, EffectPipeline, type EnhancedTextNode, EnhancedTextNodeSchema, type ExpressionEvaluationContext, type ExpressionSelector, ExpressionSelectorSchema, type ExtendedGlyphProperties, ExtendedGlyphPropertiesSchema, type ExtractedAudioSignalsBundle, type ExtrudedText3DOptions, FilmGrain, type FilmGrainProps, type FlexNode, FlexNodeSchema, FontManager, type FrameGridOptions, type FrameGridRenderable, type FrameSamplePoint, type FrameSignal, type FromToOptions, type GPULightData, GlassPipeline, type GlyphAnchorGrouping, GlyphAnchorGroupingSchema, type GlyphAnchorPoint, GlyphAnchorPointSchema, GradientMap, type GradientMapProps, type GradientMapStop, type Grid3DOptions, type HalftoneDotShape, type HalftoneMode, HalftoneScreen, type HalftoneScreenProps, HeadlessChartCanvasElementMock, HeadlessChartContainerMock, type HeadlessChartTarget, HeadlessGPUCanvasContextMock, HeadlessMediaRenderer, HeadlessWebGPURenderer, HighPass, type HighPassProps, type Keyframe, type KineticMarqueeConfig, KineticMarqueeConfigSchema, type Landmark3D, type LandmarkCoordinateSignals, Layer, Layer3D, LayerAnimation, type LayoutNode, LayoutNodeSchema, type LevelChannel, Levels, type LevelsProps, Light, Light3D, type Light3DOptions, type LightNode, LightNodeSchema, type LightType, LightTypeSchema, type LineSpacingDynamics, LineSpacingDynamicsSchema, type LoadModelOptions, type LongShadowConfig, LongShadowConfigSchema, MEDIAPIPE_TO_YOLO_POSE_INDEX, type MarkOptions, type MaskTrackSignals$1 as MaskTrackSignals, type Material3D, type MaterialType, MaterialTypeSchema, Media, type MediaNode, MediaNodeSchema, MediaPipe, type MediaPipeProps, type Mesh3DData, type Model3DData, type Model3DNode, Model3DNodeSchema, Modulate, type ModulateProps, MotionBlur, MotionBlurPipeline, type MotionBlurProps, type NodeAnimationTrack3D, type NormalRelightingOptions, type NormalizedLandmarkList, type ObjectAnchorName, type ObjectAnchorsSignals, type ObjectBoundingBox, type ObjectBoundingBoxSignals, type ObjectCollectionSignals, type ObjectKinematicsSignals, type ObjectTrackSignals, OpticalFlowComputePipeline, type OpticalFlowOptions, PBRGlass, type PBRGlassProps, POSE_LANDMARKS_YOLO, type ParticleDissolveConfig, ParticleDissolveConfigSchema, Path3D, type PathChainLUT, type PathChainLUTEntry, type PinToLandmarkOptions, type PinToObjectOptions, type Plane3DOptions, type PoseLandmarkSignals, PoseSkeletonRenderer, type Prism3DOptions, type RegisterFontOptions, type RegisteredFont, Relight3D, type Relight3DProps, type RenderContextValue, type RenderedSfx, Renderer2D, Renderer3D, SSAO, SSAOPipeline, type SSAOProps, Scene, type SceneDefinition, SceneDefinitionSchema, type SceneOptions, type SceneTransitionType, SceneTransitionTypeSchema, SectionNode, SectionOptions, 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, type SignalContext, type SignalTrackOptions, type SignalValue, type SineSignalOptions, type Skeleton3D, type SkewProperties, SkewPropertiesSchema, SlugFontCache, SlugPipeline, SmartFramingOptions, type Spatial3DProperties, Spatial3DPropertiesSchema, SpatialLandmarkTransformer, type SpringOptions, type SpringPhysics, SpringPhysicsSchema, SubjectOutlineOptions, SubjectSandwichOptions, TemporalDeflicker, TemporalDeflickerPipeline, TemporalObjectTracker, 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, type TextNode, TextNodeSchema, 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, type TrackSource, type TrackedObject, TrackedRegionOptions, type TypewriterAnimator, TypewriterAnimatorSchema, type TypingCadence, TypingCadenceSchema, UnsharpMask, type UnsharpMaskProps, type VariableFontAxes, VariableFontAxesSchema, type Vec2, Vec2Schema, Vignette, type VignetteProps, type VisionAnalysisReport, type VolumetricFormationConfig, VolumetricFormationConfigSchema, type VolumetricFormationMode, VolumetricFormationModeSchema, type WiggleOptions, YOLO_COCO17_BONES, YOLO_POSE_KEYPOINT_NAMES, Yolo, type YoloConfig, type YoloInstanceMask, YoloNode, type YoloOBBResult, type YoloPoseResult, type YoloProps, type YoloSegmentationResult, YoloVisionBundle, YoloVisionRunner, accent, analyzeSequence, applyStaggerToChildren, blurRegion, bold, buildPathLUT, calculateSequenceTimeline, chartBridgeCache, code, collectNodeOps, color, compositorToProgram, computeAnchorPivotOffset, computeCarrierContinuity, computeGridLayout, computeLayout, computeLayoutSync, computeLineLeadingDisplacement, computeRangeSelectorWeight, computeStaggerDelay, computed, cosineSignal, deterministicWigglyNoise, distanceToCurveParameter, drawChartNode, editTrackedRegion, ellipseToCubicBeziers, encodeStereoWav, ensureDevice, evaluateAnimationAtFrame, evaluateCubicBezier, evaluateCubicBezierDerivative, evaluateExpressionSelector, evaluateMarqueeOffset, evaluateSelectorCombination, evaluateSkewMatrix, evaluateSpringProgress, evaluateTrackAtFrame, evaluateTypewriterState, evaluateVolumetricFormation, generateArcLengthLUT, generatePathSegments, getScramblePool, getShuffledOrder, inputStore, italic, loadFBX, loadModel3D, loadOBJ, lutStore, mark, mixAudioTracks, mixSfxInto, normalizeTextSpans, parseFBX, parseMTL, parseMarkup, parseOBJ, parseSvgPathToCubicBeziers, pinNodeToLandmark, pinNodeToObject, renderFrameGrid, renderSemaphore, renderSfx, resolveSamplePoints, rich, sampleAudioSpectrumScale, sampleCurveGeometry, samplePathChainGeometry, section, shaderStore, signal, signalBuilder, signalRegistry, sineSignal, size, softLimit, span, sub, sup, textureCache, waveToCubicBeziers };
+//# sourceMappingURL=index.d.mts.map