framefields 2.0.2

package/dist/index-B0BNPEoH.d.mts

@@ -0,0 +1,2117 @@
+import { An as ProgrammaticSignal, Cn as NormalizedLandmarkList, Ct as DeflickerOptions, Dr as VisionNodeSpec, Er as VisionConfig, Et as Effect, Nn as SegmentationOptions, Nt as FaceLandmarksOptions, Or as VisionTask, Ot as EffectConfigValue, Rt as FrameContext, Tn as OpticalFlowOptions, Tt as DetectedObject, Zt as Landmark3D, ct as CannyOptions, dr as TrackedObject, er as TensorData, ir as TensorPipelineConfig, kn as PoseSkeletonOptions, kr as VisionVariant, pt as ControlNetConditioningOutputs, rr as TensorNode, wn as ObjectBoundingBox, wt as DepthNormalsOptions } from "./index-D2jDC7O5.mjs";
+import { n as NodeRendererPlugin, r as WebGPUNodeRenderer } from "./index-BMVVmc4G.mjs";
+import { n as AudioSignalOptions, r as ExtractedAudioSignalsBundle } from "./audio-Dvwwz8xU.mjs";
+
+//#region ../../nodes/node-blur/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$29: Readonly<NodeRendererPlugin>;
+//#endregion
+
+//#endregion
+//#region ../../nodes/node-color-balance/dist/index-DtnEFgTT.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$28: {
+  WebGPURenderer: WebGPUNodeRenderer;
+};
+//#endregion
+//#endregion
+//#region ../../nodes/node-colorkey/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$27: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-corner-pin/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$26: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-crop/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$25: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-curves/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const rendererNode: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-deflicker/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$24: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-displacement-map/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$23: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-film-grain/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$22: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-flip/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$21: Readonly<NodeRendererPlugin>;
+//#endregion
+
+//#endregion
+//#region ../../nodes/node-gradient-map/dist/index-CwsP0R_D.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$20: {
+  WebGPURenderer: WebGPUNodeRenderer;
+};
+//#endregion
+//#endregion
+//#region ../../nodes/node-halftone-screen/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$19: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-high-pass/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$18: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-kenburns/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$17: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-layer-style/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$16: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-levels/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$15: Readonly<NodeRendererPlugin>;
+//#endregion
+
+//#endregion
+//#region ../../nodes/node-liquify/dist/index-nLEHoail.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$14: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-apply-lut/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$13: Readonly<NodeRendererPlugin>;
+//#endregion
+
+//#endregion
+//#region ../../nodes/node-mask-math/dist/index-DaeM7Wai.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$12: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-mesh-warp/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$11: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-paint/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$10: Readonly<NodeRendererPlugin>;
+//#endregion
+
+//#endregion
+//#region ../../nodes/node-patch-heal/dist/index-CD55q9I2.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$9: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-refine-edge/dist/index-DaeM7Wai.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$8: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-refraction-caustics/dist/index-UMBw6e-q.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$7: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-relight-3d/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$6: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-selective-color/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$5: Readonly<NodeRendererPlugin>;
+//#endregion
+
+//#endregion
+//#region ../../nodes/node-shadows-highlights/dist/index-B_GL0b2Y.d.mts
+//#endregion
+//#region src/renderers/index.d.ts
+declare const _default$4: {
+  WebGPURenderer: WebGPUNodeRenderer;
+};
+//#endregion
+//#endregion
+//#region ../../nodes/node-tile-offset/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$3: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-unsharp-mask/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$2: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-vignette/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default$1: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region ../../nodes/node-vision/dist/renderer.d.mts
+//#region src/renderers/index.d.ts
+declare const _default: Readonly<NodeRendererPlugin>;
+//#endregion
+//#endregion
+//#region src/effects/types.d.ts
+/** A prop that accepts a plain value, a reactive signal, or a frame signal. */
+type EffectProp<T> = EffectConfigValue<T>;
+//#endregion
+//#region ../tensor-webgpu/dist/index.d.mts
+//#region src/types.d.ts
+type TensorSource = GPUTexture | {
+  inputHandleId?: string;
+  id?: string;
+  [key: string]: unknown;
+} | string;
+interface TensorViewExport {
+  readonly texture: GPUTexture;
+  readonly width: number;
+  readonly height: number;
+  readonly format: GPUTextureFormat;
+}
+//#endregion
+//#region src/multiplexer/controlnet-multiplexer.d.ts
+declare class ControlNetMultiplexer {
+  private textures;
+  set(type: keyof ControlNetConditioningOutputs, texture: GPUTexture): void;
+  get(type: keyof ControlNetConditioningOutputs): GPUTexture | undefined;
+  has(type: keyof ControlNetConditioningOutputs): boolean;
+  getOutputs(): ControlNetConditioningOutputs;
+  createBindGroupEntry(type: keyof ControlNetConditioningOutputs, bindingIndex: number): GPUBindGroupEntry;
+  exportTensorView(type: keyof ControlNetConditioningOutputs): TensorViewExport;
+  readPixelsAsync(device: GPUDevice, type: keyof ControlNetConditioningOutputs): Promise<{
+    width: number;
+    height: number;
+    format: GPUTextureFormat;
+    data: Uint8Array;
+  }>;
+  destroy(): void;
+}
+//#endregion
+//#region src/pipeline/tensor-pipeline.d.ts
+declare class TensorPipeline {
+  readonly source: TensorSource;
+  readonly id: string;
+  private cannyOptions?;
+  private depthNormalsOptions?;
+  private poseSkeletonOptions?;
+  private faceLandmarksOptions?;
+  private segmentationOptions?;
+  private opticalFlowOptions?;
+  private deflickerOptions?;
+  private multiplexer;
+  private cannyPipeline?;
+  private depthNormalsPipeline?;
+  private posePipeline?;
+  private facePipeline?;
+  private segmentationPipeline?;
+  private opticalFlowPipeline?;
+  private deflickerPipeline?;
+  private prevInputTexture?;
+  constructor(source: TensorSource);
+  static from(source: TensorSource): TensorPipeline;
+  canny(options?: CannyOptions): this;
+  depthNormals(options?: DepthNormalsOptions): this;
+  poseSkeleton(options?: PoseSkeletonOptions): this;
+  pose(landmarks: NormalizedLandmarkList, options?: Omit<PoseSkeletonOptions, "landmarks">): this;
+  faceLandmarks(options?: FaceLandmarksOptions): this;
+  face(landmarks: NormalizedLandmarkList, options?: Omit<FaceLandmarksOptions, "landmarks">): this;
+  segmentation(options?: SegmentationOptions): this;
+  opticalFlow(options?: OpticalFlowOptions): this;
+  deflicker(options?: DeflickerOptions): this;
+  getMultiplexer(): ControlNetMultiplexer;
+  execute(device: GPUDevice, overrideSourceTexture?: GPUTexture): Promise<ControlNetConditioningOutputs>;
+  toConfig(): TensorPipelineConfig;
+  toNode(): TensorNode;
+  destroy(): void;
+}
+//#endregion
+//#region src/pipelines/canny-pipeline.d.ts
+declare class CannyComputePipeline {
+  private device;
+  private sobelPipeline;
+  private nmsRgba8Pipeline;
+  private nmsR32fPipeline;
+  private uniformBuffer;
+  private cachedIntermediateTexture?;
+  private cachedOutputTexture?;
+  constructor(device: GPUDevice);
+  execute(inputTexture: GPUTexture, options?: CannyOptions): GPUTexture;
+  destroy(): void;
+}
+//#endregion
+//#region src/pipelines/depth-normals-pipeline.d.ts
+declare class DepthNormalsComputePipeline {
+  private device;
+  private normalRgba16fPipeline;
+  private normalRgba8Pipeline;
+  private uniformBuffer;
+  private cachedOutputTexture?;
+  constructor(device: GPUDevice);
+  execute(depthTexture: GPUTexture, options?: DepthNormalsOptions): GPUTexture;
+  destroy(): void;
+}
+//#endregion
+//#region src/pipelines/face-landmarks-pipeline.d.ts
+
+//#endregion
+//#region src/pipelines/optical-flow-pipeline.d.ts
+declare class OpticalFlowComputePipeline {
+  private device;
+  private directPipeline;
+  private refinePipeline;
+  private directUniformBuffer;
+  private refineUniformBuffer;
+  private bilinearSampler;
+  private cachedCoarseTexture?;
+  private cachedOutputTexture?;
+  constructor(device: GPUDevice);
+  execute(prevTexture: GPUTexture, currTexture: GPUTexture, options?: OpticalFlowOptions, customEncoder?: GPUCommandEncoder): GPUTexture;
+  destroy(): void;
+}
+//#endregion
+//#region src/pipelines/pose-skeleton-pipeline.d.ts
+
+//#endregion
+//#region src/pipelines/temporal-deflicker-pipeline.d.ts
+declare class TemporalDeflickerPipeline {
+  private device;
+  private flowPipeline;
+  private rgba8Pipeline;
+  private rgba16fPipeline;
+  private uniformBuffer;
+  private bilinearSampler;
+  private historyTexture?;
+  private cachedOutputTexture?;
+  constructor(device: GPUDevice);
+  execute(currTexture: GPUTexture, options?: DeflickerOptions, customEncoder?: GPUCommandEncoder): GPUTexture;
+  reset(): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/shaders/canny.wgsl.d.ts
+/**
+ * @file canny.wgsl.ts
+ * High-performance WebGPU Canny Edge Compute Shaders
+ * Pass 1: Sobel gradient magnitude & quantized angle
+ * Pass 2: Non-Maximum Suppression (NMS) & Dual-Threshold Hysteresis
+ */
+//#endregion
+//#region ../vision/dist/index-DwGxgTRf.d.mts
+type VisionModelKey = "rtmdet-ins-t" | "rtmdet-ins-s" | "rtmdet-ins-m" | "rtmo-t" | "rtmo-s" | "rtmo-m" | "selfie-square" | "selfie-landscape";
+/** Which decoder a model's outputs feed (see runner/vision-runner.ts). */
+type VisionModelFamily = "rtmdet-ins" | "rtmo" | "selfie";
+interface VisionModelDescriptor {
+  readonly key: VisionModelKey;
+  readonly family: VisionModelFamily;
+  /** Cache filename (also the path appended to a custom `baseUrl`). */
+  readonly filename: string;
+  /** Pinned download URL (immutable revision). */
+  readonly url: string;
+  /** Exact byte size of the pinned file. */
+  readonly bytes: number;
+  /** Hex SHA-256 of the pinned file. */
+  readonly sha256: string;
+  /** Model input size, `[width, height]` — must match the ONNX graph's input shape. */
+  readonly input: readonly [number, number];
+  /** Upstream project and license, surfaced in docs and errors. */
+  readonly source: string;
+}
+/** COCO 80 class names — index order matches the RTMDet-Ins `labels` output. */
+declare const COCO_CLASSES: readonly ["person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"];
+//#endregion
+//#region src/model/model-store.d.ts
+type ModelDownloadStatus = "pending" | "downloading" | "ready" | "error";
+interface VisionModelStoreOptions {
+  readonly modelsDir?: string;
+  /**
+   * Mirror origin: models are fetched from `<baseUrl>/<filename>` instead of their pinned
+   * Hugging Face URLs. Defaults to `$FRAMEFIELDS_MODELS_BASE_URL` when set.
+   */
+  readonly baseUrl?: string;
+  readonly timeoutMs?: number;
+  /** Extra attempts after a network error, HTTP 429 or 5xx. Default 2. */
+  readonly retries?: number;
+  /** Base backoff between attempts (doubles each retry). Default 1000 ms. */
+  readonly retryDelayMs?: number;
+  /**
+   * Verify byte size + SHA-256 against the registry (default true). Only offline tests
+   * that serve fake bytes should turn this off.
+   */
+  readonly verify?: boolean;
+  /** Injectable fetch — offline unit tests inject a mock. */
+  readonly fetchImpl?: typeof fetch;
+  readonly onProgress?: (key: VisionModelKey, bytesLoaded: number, totalBytes: number) => void;
+}
+/**
+ * Resolves the default model cache directory:
+ * 1. `FRAMEFIELDS_MODELS_DIR`
+ * 2. `~/.cache/framefields/models`
+ */
+
+/**
+ * Lazy model store. The constructor performs ZERO I/O; the only entry that can hit the
+ * network is `ensure(key)`, called by an inference function the first time it runs.
+ * Concurrent callers of the same key share a single in-flight download (promise dedupe),
+ * downloads are written atomically (temp + rename), and verified files on disk are reused
+ * across processes.
+ */
+declare class VisionModelStore {
+  private readonly _modelsDir;
+  private readonly _baseUrl?;
+  private readonly _timeoutMs?;
+  private readonly _retries;
+  private readonly _retryDelayMs;
+  private readonly _verify;
+  private readonly _fetch;
+  private readonly _onProgress?;
+  private _inflight;
+  private _buffers;
+  private _status;
+  constructor(options?: VisionModelStoreOptions);
+  get modelsDir(): string;
+  pathFor(key: VisionModelKey): string;
+  descriptor(key: VisionModelKey): VisionModelDescriptor;
+  /** The URL `ensure(key)` downloads from (mirror when `baseUrl` is set). */
+  urlFor(key: VisionModelKey): string;
+  /** True when a complete cached file exists (exact registry size when verifying). */
+  has(key: VisionModelKey): boolean;
+  /** Drops a cached model (file + memory) so the next `ensure` re-downloads it. */
+  evict(key: VisionModelKey): Promise<void>;
+  status(key: VisionModelKey): ModelDownloadStatus;
+  /** Snapshot of every tracked model's status (empty until anything is fetched). */
+  statuses(): ReadonlyMap<VisionModelKey, ModelDownloadStatus>;
+  /** True when the model is resident in memory (loaded or downloaded this process). */
+  isLoaded(key: VisionModelKey): boolean;
+  /**
+   * THE only download entry point. Returns the model bytes from memory (cached),
+   * loading from disk or fetching from the registry URL as needed.
+   */
+  ensure(key: VisionModelKey): Promise<Uint8Array>;
+  /** Explicit warm-up — fetch multiple models ahead of use (agents, renderers). */
+  preload(keys: readonly VisionModelKey[]): Promise<void>;
+  private load;
+  /** Fetches with retries on transient failures (network errors, HTTP 429/5xx). */
+  private download;
+  private verifyBytes;
+  private readBuffer;
+  /** Drops in-memory buffers (model stays on disk for the next run). */
+  clearMemoryCache(): void;
+}
+//#endregion
+//#region src/runtime/session-provider.d.ts
+/**
+ * Minimal ONNX Runtime surface — isolates the ORT API to exactly two files so the decode
+ * and signals layers never touch it. Node path uses onnxruntime-node (CPU EP); the web
+ * entry can swap in a WebGPU-backed provider with the same interface.
+ */
+/** Model output tensor. Integer outputs (e.g. RTMDet-Ins `labels`) arrive as BigInt64Array. */
+interface VisionTensor {
+  readonly data: Float32Array | BigInt64Array | Int32Array;
+  readonly dims: readonly number[];
+}
+interface VisionTensorInput {
+  readonly name: string;
+  readonly data: Float32Array;
+  readonly dims: readonly number[];
+}
+type VisionTensorOutputs = Readonly<Record<string, VisionTensor>>;
+interface VisionSession {
+  run(input: VisionTensorInput): Promise<VisionTensorOutputs>;
+  release(): void;
+}
+interface SessionProvider {
+  readonly kind: "node" | "webgpu";
+  createSession(modelBytes: Uint8Array): Promise<VisionSession>;
+}
+/**
+ * Sets the provider runners use when none is passed, for hosts that create
+ * runners indirectly (e.g. a browser player rendering vision nodes). `undefined`
+ * restores the default, onnxruntime-node.
+ */
+
+declare namespace types_d_exports {
+  export { InstanceMask, LandmarkCoordinateSignals, ObjectAnchorName, PersonMatte, PinToLandmarkOptions, PinToObjectOptions, PoseKeypoint, PosePerson, PoseResult, SegmentationResult, VisionAnalysisClassSummary, VisionAnalysisReport, VisionAnalysisTrackSummary, VisionImageInput, VisionInputSource, VisionSummary };
+}
+type VisionInputSource = string | {
+  inputHandleId?: string;
+  id?: string;
+  [key: string]: unknown;
+};
+/** RGBA pixel buffer accepted by the runner. */
+interface VisionImageInput {
+  readonly data: Uint8ClampedArray | Uint8Array;
+  readonly width: number;
+  readonly height: number;
+}
+/** Instance segmentation mask aligned to the ORIGINAL source frame. */
+interface InstanceMask {
+  readonly category: string;
+  readonly mask: Uint8Array;
+  readonly width: number;
+  readonly height: number;
+  readonly area: number;
+  readonly coverage: number;
+  /** Index of the detection this mask belongs to (see segmentation result detections). */
+  readonly detectionIndex: number;
+  /** Assigned by the caller (renderer) after temporal tracking — matches TrackedObject.trackId. */
+  readonly trackId?: number;
+}
+interface SegmentationResult {
+  readonly detections: readonly DetectedObject[];
+  readonly masks: readonly InstanceMask[];
+}
+/** Person-vs-background alpha (Selfie Segmenter), aligned to the ORIGINAL source frame. */
+interface PersonMatte {
+  readonly mask: Uint8Array;
+  readonly width: number;
+  readonly height: number;
+  readonly coverage: number;
+}
+interface PoseKeypoint {
+  readonly x: number;
+  readonly y: number;
+  readonly visibility: number;
+}
+interface PosePerson {
+  readonly score: number;
+  readonly boundingBox: ObjectBoundingBox;
+  /** 17 keypoints in COCO-17 order (see COCO17_KEYPOINTS). */
+  readonly keypoints: readonly PoseKeypoint[];
+  readonly trackId?: number;
+}
+interface PoseResult {
+  readonly people: readonly PosePerson[];
+}
+/**
+ * Deterministic, serializable snapshot of one frame's signals.
+ * Built synchronously from the per-frame caches, so it is safe to call inside a frame hook.
+ */
+interface VisionSummary {
+  readonly frame: number;
+  readonly objects: ReadonlyArray<{
+    readonly trackId: number;
+    readonly category: string;
+    readonly score: number;
+    /** Source-space pixel center, `[x, y]`. */
+    readonly center: readonly [number, number];
+    readonly speed: number;
+    readonly active: boolean;
+  }>;
+  readonly classes: readonly string[];
+  /** Per-class instance count for the frame (only non-zero classes present). */
+  readonly masks: Readonly<Record<string, number>>;
+}
+/** Per-track aggregate in an analysis report. */
+interface VisionAnalysisTrackSummary {
+  readonly trackId: number;
+  readonly category: string;
+  /** Inclusive frame range the track was active over, `[start, end]`. */
+  readonly frames: readonly [number, number];
+  readonly speedMeanPxS: number;
+  /** Center path sampled every `pathStride` frames, `[x, y]` pairs. */
+  readonly centerPath: ReadonlyArray<readonly [number, number]>;
+}
+interface VisionAnalysisClassSummary {
+  readonly framesPresent: number;
+  readonly totalFrames: number;
+  readonly maxConfidence: number;
+  readonly tracks: number;
+}
+interface VisionAnalysisReport {
+  readonly source: string;
+  readonly totalFrames: number;
+  readonly fps: number;
+  readonly durationSec: number;
+  readonly tasks: readonly string[];
+  /** What was fetched, and how long it took — surfaced so agents can budget cold starts. */
+  readonly modelDownloads: Readonly<Record<string, {
+    readonly bytes: number;
+    readonly ms: number;
+  }>>;
+  readonly inferenceMs: number;
+  readonly trackCount: number;
+  readonly classes: Readonly<Record<string, VisionAnalysisClassSummary>>;
+  readonly tracks: readonly VisionAnalysisTrackSummary[];
+  readonly masks: Readonly<Record<string, {
+    readonly meanCoverage: number;
+  }>>;
+}
+interface PinToLandmarkOptions {
+  readonly offsetX?: number;
+  readonly offsetY?: number;
+  readonly offsetZ?: number;
+  readonly trackRotation?: boolean;
+  readonly scaleWithPerspective?: boolean;
+}
+interface LandmarkCoordinateSignals {
+  readonly x: ProgrammaticSignal;
+  readonly y: ProgrammaticSignal;
+  readonly z: ProgrammaticSignal;
+  readonly screenX: ProgrammaticSignal;
+  readonly screenY: ProgrammaticSignal;
+}
+type ObjectAnchorName = "center" | "topCenter" | "bottomCenter" | "topLeft" | "topRight" | "centerLeft" | "centerRight" | "bottomLeft" | "bottomRight";
+interface PinToObjectOptions extends PinToLandmarkOptions {
+  readonly anchor?: ObjectAnchorName;
+  readonly matchWidth?: boolean;
+  readonly matchHeight?: boolean;
+  readonly smoothFrames?: number;
+  readonly hideWhenLost?: boolean;
+}
+//#endregion
+//#region src/runner/vision-runner.d.ts
+interface VisionRunnerOptions {
+  /** Model size for detect/segment/pose. Default "s". */
+  readonly variant?: VisionVariant;
+  /** Minimum detection / person score, 0..1. Default 0.3. */
+  readonly confidence?: number;
+  /** COCO class-name filter for detect/segment (all classes when omitted). */
+  readonly classes?: readonly string[];
+  readonly maskThreshold?: number;
+  readonly featherRadius?: number;
+  readonly modelsDir?: string;
+  /** Mirror origin for model downloads (see VisionModelStore). */
+  readonly baseUrl?: string;
+  readonly timeoutMs?: number;
+  /** Session backend. Default: onnxruntime-node (CPU). Browser: `createWebGPUProvider()`. */
+  readonly provider?: SessionProvider;
+  /** Inject a model store (tests, shared caches). Overrides modelsDir/baseUrl/timeoutMs. */
+  readonly store?: VisionModelStore;
+  readonly onProgress?: (key: VisionModelKey, bytesLoaded: number, totalBytes: number) => void;
+}
+/**
+ * Lazy vision runner.
+ *
+ * `create()` performs ZERO I/O: no downloads, no sessions. Each inference method downloads
+ * its model and warms its session on FIRST USE ONLY, then reuses them for the process
+ * lifetime. `detect()` and `segment()` share one RTMDet-Ins forward pass per frame.
+ * Call `close()` to release sessions.
+ */
+declare class VisionRunner {
+  readonly variant: VisionVariant;
+  readonly confidence: number;
+  readonly classes?: readonly string[];
+  readonly maskThreshold: number;
+  readonly featherRadius?: number;
+  private readonly _store;
+  private readonly _provider;
+  private readonly _sessions;
+  private readonly _tensorScratch;
+  /** One RTMDet-Ins pass per frame buffer, shared by detect() and segment(). */
+  private _instancePass?;
+  private constructor();
+  /** Cheap: no downloads, no sessions, no side effects. */
+  static create(options?: VisionRunnerOptions): VisionRunner;
+  get modelsDir(): string;
+  /** Every registry model keyed to its current download state (downloaded → "ready"). */
+  get downloadStatus(): ReadonlyMap<VisionModelKey, ModelDownloadStatus>;
+  /** The model serving `task` (matte depends on frame aspect; defaults to square). */
+  modelKeyFor(task: VisionTask, aspect?: number): VisionModelKey;
+  /**
+   * Explicit warm-up: downloads + sessions for the given tasks, ahead of first use.
+   * `matte` warms both aspect variants (the frame aspect is unknown until inference).
+   */
+  preload(tasks?: readonly VisionTask[]): Promise<void>;
+  /** COCO-80 boxes (sorted by score, source pixels). Masks are not decoded. */
+  detect(image: VisionImageInput): Promise<readonly DetectedObject[]>;
+  /** COCO-80 boxes plus a frame-aligned soft mask per instance. */
+  segment(image: VisionImageInput): Promise<SegmentationResult>;
+  /** COCO-17 keypoints per person (source pixels), highest score first. */
+  pose(image: VisionImageInput): Promise<PoseResult>;
+  /** Person-vs-background alpha for the whole frame (Selfie Segmenter). */
+  matte(image: VisionImageInput): Promise<PersonMatte>;
+  close(): void;
+  private instancePass;
+  private instanceDecodeOptions;
+  private infer;
+  private session;
+}
+//#endregion
+//#region src/analysis/analyze-sequence.d.ts
+/**
+ * One-shot, ffmpeg-free sequence analysis.
+ *
+ * Pure frame-iterable analyzer: it never decodes media itself, so it stays engine-only and
+ * offline-testable. Callers (e.g. the framefields ingestion adapter) supply decoded frames.
+ * Model loading remains lazy — the runner downloads each task's model on the first frame
+ * that actually runs that task, and only the tasks requested here are ever touched.
+ */
+interface AnalyzeSequenceOptions {
+  readonly runner: VisionRunner;
+  /** Label for the report ("clip.mp4" or similar). Defaults to "frames". */
+  readonly source?: string;
+  readonly fps?: number;
+  /** Tasks to run. Defaults to `["detect"]`. Only these models are ever downloaded. */
+  readonly tasks?: readonly VisionTask[];
+  /** Restrict class summaries to these categories (all when omitted). */
+  readonly categories?: readonly string[];
+  /** Tracker box-association IoU. Default 0.25. */
+  readonly iouThreshold?: number;
+  readonly maxMissedFrames?: number;
+  /** Sample the per-track center path every N frames. Default: ~50 points across the clip. */
+  readonly pathStride?: number;
+  /** Also aggregate instance-mask coverage (requires the `segment` task). Default false. */
+  readonly includeMasks?: boolean;
+}
+declare function analyzeSequence(frames: AsyncIterable<VisionImageInput> | Iterable<VisionImageInput>, options: AnalyzeSequenceOptions): Promise<VisionAnalysisReport>;
+//#endregion
+//#region src/decode/preprocess.d.ts
+/**
+ * Image → NCHW float tensor preprocessing, plus the inverse mapping back to source pixels.
+ *
+ * Each model family was exported with its own preprocessing contract:
+ *
+ * | Model       | Resize                       | Pad  | Channels | Values                     |
+ * | ----------- | ---------------------------- | ---- | -------- | -------------------------- |
+ * | RTMDet-Ins  | keep ratio, content top-left | 114  | BGR      | (v − mean) / std (ImageNet) |
+ * | RTMO        | keep ratio, content centered | 114  | BGR      | raw 0..255                 |
+ * | Selfie      | stretch to input             | —    | RGB      | v / 255                    |
+ *
+ * Getting any of these wrong does not crash — it silently degrades accuracy — so the specs
+ * live here and every runner path goes through `imageToTensor`. Input sizes differ per model
+ * (RTMO-t is 416², the rest of RTMO 640²), so they come from the registry, never from here.
+ */
+
+//#endregion
+//#region src/gpu/pose-skeleton-renderer.d.ts
+/**
+ * WebGPU skeleton renderer for pose results.
+ *
+ * Rasterizes the primary person's COCO-17 keypoints into an OpenPose-style
+ * conditioning texture natively in VRAM, using the COCO-17 bone set.
+ */
+declare class PoseSkeletonRenderer {
+  private pipeline;
+  constructor(device: GPUDevice);
+  renderToTexture(keypoints: readonly PoseKeypoint[], options: PoseSkeletonOptions, bones?: readonly [{
+    readonly from: 0;
+    readonly to: 5;
+    readonly color: readonly [0, 1, 1, 1];
+  }, {
+    readonly from: 0;
+    readonly to: 6;
+    readonly color: readonly [0, 1, 1, 1];
+  }, {
+    readonly from: 5;
+    readonly to: 6;
+    readonly color: readonly [1, 0, 0, 1];
+  }, {
+    readonly from: 5;
+    readonly to: 7;
+    readonly color: readonly [1, 0.333, 0, 1];
+  }, {
+    readonly from: 7;
+    readonly to: 9;
+    readonly color: readonly [1, 0.667, 0, 1];
+  }, {
+    readonly from: 6;
+    readonly to: 8;
+    readonly color: readonly [1, 1, 0, 1];
+  }, {
+    readonly from: 8;
+    readonly to: 10;
+    readonly color: readonly [0.667, 1, 0, 1];
+  }, {
+    readonly from: 5;
+    readonly to: 11;
+    readonly color: readonly [0.333, 1, 0, 1];
+  }, {
+    readonly from: 6;
+    readonly to: 12;
+    readonly color: readonly [0, 1, 0, 1];
+  }, {
+    readonly from: 11;
+    readonly to: 12;
+    readonly color: readonly [0, 1, 0.333, 1];
+  }, {
+    readonly from: 11;
+    readonly to: 13;
+    readonly color: readonly [0, 1, 0.667, 1];
+  }, {
+    readonly from: 13;
+    readonly to: 15;
+    readonly color: readonly [0, 1, 1, 1];
+  }, {
+    readonly from: 12;
+    readonly to: 14;
+    readonly color: readonly [0, 0.667, 1, 1];
+  }, {
+    readonly from: 14;
+    readonly to: 16;
+    readonly color: readonly [0, 0.333, 1, 1];
+  }]): GPUTexture;
+  destroy(): void;
+}
+//#endregion
+//#region src/gpu/segmentation-texture-pool.d.ts
+interface SegmentationTextureOptions {
+  readonly width: number;
+  readonly height: number;
+  readonly format?: "r8unorm" | "rgba8unorm";
+  readonly label?: string;
+}
+declare class SegmentationTexturePool {
+  private device;
+  private pool;
+  constructor(device: GPUDevice);
+  getOrCreateTexture(key: string, options: SegmentationTextureOptions): GPUTexture;
+  uploadMask(key: string, maskData: Uint8Array | Float32Array, width: number, height: number): GPUTexture;
+  destroy(): void;
+}
+//#endregion
+//#region src/pose/keypoints.d.ts
+/** COCO-17 keypoint indices (RTMO output order). */
+declare const COCO17_KEYPOINTS: {
+  readonly NOSE: 0;
+  readonly LEFT_EYE: 1;
+  readonly RIGHT_EYE: 2;
+  readonly LEFT_EAR: 3;
+  readonly RIGHT_EAR: 4;
+  readonly LEFT_SHOULDER: 5;
+  readonly RIGHT_SHOULDER: 6;
+  readonly LEFT_ELBOW: 7;
+  readonly RIGHT_ELBOW: 8;
+  readonly LEFT_WRIST: 9;
+  readonly RIGHT_WRIST: 10;
+  readonly LEFT_HIP: 11;
+  readonly RIGHT_HIP: 12;
+  readonly LEFT_KNEE: 13;
+  readonly RIGHT_KNEE: 14;
+  readonly LEFT_ANKLE: 15;
+  readonly RIGHT_ANKLE: 16;
+};
+declare const COCO17_KEYPOINT_NAMES: readonly ["nose", "leftEye", "rightEye", "leftEar", "rightEar", "leftShoulder", "rightShoulder", "leftElbow", "rightElbow", "leftWrist", "rightWrist", "leftHip", "rightHip", "leftKnee", "rightKnee", "leftAnkle", "rightAnkle"];
+/** COCO-17 skeleton bones for the WebGPU skeleton renderer (indices above). */
+declare const COCO17_BONES: readonly [{
+  readonly from: 0;
+  readonly to: 5;
+  readonly color: readonly [0, 1, 1, 1];
+}, {
+  readonly from: 0;
+  readonly to: 6;
+  readonly color: readonly [0, 1, 1, 1];
+}, {
+  readonly from: 5;
+  readonly to: 6;
+  readonly color: readonly [1, 0, 0, 1];
+}, {
+  readonly from: 5;
+  readonly to: 7;
+  readonly color: readonly [1, 0.333, 0, 1];
+}, {
+  readonly from: 7;
+  readonly to: 9;
+  readonly color: readonly [1, 0.667, 0, 1];
+}, {
+  readonly from: 6;
+  readonly to: 8;
+  readonly color: readonly [1, 1, 0, 1];
+}, {
+  readonly from: 8;
+  readonly to: 10;
+  readonly color: readonly [0.667, 1, 0, 1];
+}, {
+  readonly from: 5;
+  readonly to: 11;
+  readonly color: readonly [0.333, 1, 0, 1];
+}, {
+  readonly from: 6;
+  readonly to: 12;
+  readonly color: readonly [0, 1, 0, 1];
+}, {
+  readonly from: 11;
+  readonly to: 12;
+  readonly color: readonly [0, 1, 0.333, 1];
+}, {
+  readonly from: 11;
+  readonly to: 13;
+  readonly color: readonly [0, 1, 0.667, 1];
+}, {
+  readonly from: 13;
+  readonly to: 15;
+  readonly color: readonly [0, 1, 1, 1];
+}, {
+  readonly from: 12;
+  readonly to: 14;
+  readonly color: readonly [0, 0.667, 1, 1];
+}, {
+  readonly from: 14;
+  readonly to: 16;
+  readonly color: readonly [0, 0.333, 1, 1];
+}];
+//#endregion
+//#region src/runner/canonical-baselines.d.ts
+/** Neutral fallbacks so signal evaluators always have a well-formed frame to read. */
+
+//#endregion
+//#region src/signals/vision-bundle.d.ts
+interface VisionBundleOptions {
+  readonly totalFrames?: number;
+  readonly fps?: number;
+  readonly width?: number;
+  readonly height?: number;
+  readonly cameraFov?: number;
+  readonly config?: types_d_exports.VisionConfig;
+}
+/** Named pose landmarks (COCO-17) plus numeric proxy access to any of the 17 keypoints. */
+interface PoseLandmarkSignals {
+  readonly shoulder: LandmarkCoordinateSignals;
+  readonly leftShoulder: LandmarkCoordinateSignals;
+  readonly rightShoulder: LandmarkCoordinateSignals;
+  readonly leftElbow: LandmarkCoordinateSignals;
+  readonly rightElbow: LandmarkCoordinateSignals;
+  readonly leftWrist: LandmarkCoordinateSignals;
+  readonly rightWrist: LandmarkCoordinateSignals;
+  readonly leftHip: LandmarkCoordinateSignals;
+  readonly rightHip: LandmarkCoordinateSignals;
+  readonly leftKnee: LandmarkCoordinateSignals;
+  readonly rightKnee: LandmarkCoordinateSignals;
+  readonly leftAnkle: LandmarkCoordinateSignals;
+  readonly rightAnkle: LandmarkCoordinateSignals;
+  readonly nose: LandmarkCoordinateSignals;
+  readonly leftEye: LandmarkCoordinateSignals;
+  readonly rightEye: LandmarkCoordinateSignals;
+  readonly leftEar: LandmarkCoordinateSignals;
+  readonly rightEar: LandmarkCoordinateSignals;
+  get(keypointIndex: number): LandmarkCoordinateSignals;
+}
+interface TrackPoseSignals extends PoseLandmarkSignals {
+  readonly hasPose: ProgrammaticSignal;
+  readonly wristSpeed: ProgrammaticSignal;
+  readonly handRaised: ProgrammaticSignal;
+  readonly bodyTiltAngle: ProgrammaticSignal;
+}
+interface ObjectBoundingBoxSignals {
+  readonly x: ProgrammaticSignal;
+  readonly y: ProgrammaticSignal;
+  readonly width: ProgrammaticSignal;
+  readonly height: ProgrammaticSignal;
+  readonly screenX: ProgrammaticSignal;
+  readonly screenY: ProgrammaticSignal;
+  readonly screenWidth: ProgrammaticSignal;
+  readonly screenHeight: ProgrammaticSignal;
+  readonly aspectRatio: ProgrammaticSignal;
+  readonly area: ProgrammaticSignal;
+}
+interface ObjectAnchorsSignals {
+  readonly topLeft: LandmarkCoordinateSignals;
+  readonly topCenter: LandmarkCoordinateSignals;
+  readonly topRight: LandmarkCoordinateSignals;
+  readonly centerLeft: LandmarkCoordinateSignals;
+  readonly center: LandmarkCoordinateSignals;
+  readonly centerRight: LandmarkCoordinateSignals;
+  readonly bottomLeft: LandmarkCoordinateSignals;
+  readonly bottomCenter: LandmarkCoordinateSignals;
+  readonly bottomRight: LandmarkCoordinateSignals;
+}
+interface ObjectKinematicsSignals {
+  readonly vx: ProgrammaticSignal;
+  readonly vy: ProgrammaticSignal;
+  readonly speed: ProgrammaticSignal;
+  readonly acceleration: ProgrammaticSignal;
+  readonly headingRad: ProgrammaticSignal;
+  readonly headingDeg: ProgrammaticSignal;
+}
+interface ObjectTrackSignals {
+  readonly trackId: number;
+  readonly category: string;
+  readonly bounds: ObjectBoundingBoxSignals;
+  readonly anchors: ObjectAnchorsSignals;
+  readonly kinematics: ObjectKinematicsSignals;
+  readonly confidence: ProgrammaticSignal;
+  readonly active: ProgrammaticSignal;
+  readonly isCoasting: ProgrammaticSignal;
+  readonly age: ProgrammaticSignal;
+  readonly pose: TrackPoseSignals;
+  readonly center: LandmarkCoordinateSignals;
+  readonly topCenter: LandmarkCoordinateSignals;
+  readonly bottomCenter: LandmarkCoordinateSignals;
+  readonly topLeft: LandmarkCoordinateSignals;
+  readonly bottomLeft: LandmarkCoordinateSignals;
+  readonly [key: string]: unknown;
+}
+interface MaskTrackSignals {
+  readonly trackId: number;
+  readonly category: string;
+  readonly area: ProgrammaticSignal;
+  readonly coverage: ProgrammaticSignal;
+  readonly solidity: ProgrammaticSignal;
+  readonly bboxFill: ProgrammaticSignal;
+  /** Frame-sized {0,255} mask for the current frame (renderer-populated). */
+  data?: Uint8Array;
+  /** GPU-resident silhouette texture (renderer-populated via SegmentationTexturePool). */
+  texture?: GPUTexture;
+}
+interface MaskCollectionSignals {
+  get(trackId: number): MaskTrackSignals;
+  /** Largest instance of the current frame (person preferred when present). */
+  readonly subject: MaskTrackSignals;
+  readonly count: ProgrammaticSignal;
+}
+interface SegmentationSignals {
+  readonly humanSilhouette: MaskTrackSignals;
+  readonly subject: MaskTrackSignals;
+  readonly instanceMasks: MaskCollectionSignals;
+  /** Person-vs-background alpha from the Selfie Segmenter (`enableMatte`). */
+  readonly matte: PersonMatteSignals;
+  readonly stencilTexture?: GPUTexture;
+}
+interface PersonMatteSignals {
+  /** Mean person alpha over the frame, 0..1 (0 when no matte has run). */
+  readonly coverage: ProgrammaticSignal;
+  /** Frame-sized 0..255 alpha for the given frame, if a matte has run. */
+  at(frame: number): PersonMatte | undefined;
+}
+interface ClassSignals {
+  readonly count: ProgrammaticSignal;
+  readonly maxConfidence: ProgrammaticSignal;
+  readonly present: ProgrammaticSignal;
+  readonly primary: ObjectTrackSignals;
+}
+interface ClassCollectionSignals {
+  /** Cached per-class signals (stable identity). */
+  get(name: string): ClassSignals;
+  /** Sorted active category names for the current frame. */
+  readonly names: readonly string[];
+  readonly histogram: {
+    get(ctx?: FrameContext): TensorData;
+    readonly value: TensorData;
+  };
+}
+interface ObjectCollectionSignals {
+  get(trackId: number): ObjectTrackSignals;
+  byCategory(category: string, rank?: number): ObjectTrackSignals;
+  readonly primary: ObjectTrackSignals;
+  readonly count: ProgrammaticSignal;
+  hasCategory(category: string): ProgrammaticSignal;
+  getActiveTracks(frame: number): readonly TrackedObject[];
+  readonly detectedCategories: readonly string[];
+}
+declare class VisionBundle {
+  readonly objects: ObjectCollectionSignals;
+  readonly poseLandmarks: PoseLandmarkSignals;
+  readonly masks: MaskCollectionSignals;
+  readonly segmentation: SegmentationSignals;
+  readonly classes: ClassCollectionSignals;
+  readonly poseLandmarksTensor: {
+    get(ctx?: FrameContext): TensorData;
+    readonly value: TensorData;
+  };
+  readonly objectsTensor: {
+    get(ctx?: FrameContext): TensorData;
+    readonly value: TensorData;
+  };
+  readonly masksTensor: {
+    get(ctx?: FrameContext): TensorData;
+    readonly value: TensorData;
+  };
+  /** Per-class detection histogram [nc] — top-level convenience mirror of `classes.histogram`. */
+  readonly histogramTensor: {
+    get(ctx?: FrameContext): TensorData;
+    readonly value: TensorData;
+  };
+  private _totalFrames;
+  private _fps;
+  private _width;
+  private _height;
+  private _transformer;
+  private _stencilTexture?;
+  private _poseCache;
+  private _objectCache;
+  private _maskCache;
+  private _matteCache;
+  private _poseLmCache;
+  private _trackCache;
+  private _categoryCache;
+  private _classCache;
+  private _maskTrackCache;
+  private _registeredSignals;
+  constructor(options?: VisionBundleOptions);
+  setStencilTexture(texture: GPUTexture): void;
+  get stencilTexture(): GPUTexture | undefined;
+  /**
+   * Reads the most recent result at or before `frame`. Vision results are written one
+   * frame behind the plate (the node renderer reads back the previous frame to infer),
+   * and pinned-signal layout runs before the current frame's inference, so a strict
+   * per-frame lookup would always miss. Walking back a few frames keeps signals live at
+   * a stable one-frame lag instead of snapping to neutral defaults.
+   */
+  private latestAtOrBefore;
+  invalidateSignals(): void;
+  setPoseResult(frame: number, result: PoseResult): void;
+  getPoseResult(frame: number): PoseResult;
+  setObjectResult(frame: number, result: {
+    objects: readonly TrackedObject[];
+    rawDetections?: readonly DetectedObject[];
+  } | readonly TrackedObject[]): void;
+  getObjectResult(frame: number): {
+    objects: readonly TrackedObject[];
+    rawDetections: readonly DetectedObject[];
+  };
+  setMaskResult(frame: number, masks: readonly InstanceMask[]): void;
+  getMaskResult(frame: number): readonly InstanceMask[];
+  setMatteResult(frame: number, matte: PersonMatte): void;
+  getMatteResult(frame: number): PersonMatte | undefined;
+  /**
+   * Serializable snapshot of one frame's object / class / mask signals.
+   * Synchronous — reads only the per-frame caches, never triggers inference.
+   */
+  summary(frame?: number): VisionSummary;
+  /** Primary person's 17 keypoints as a [17, 3] float32 tensor. */
+  getPoseLandmarksTensor(frame: number): TensorData;
+  /** Up to 16 active tracks as [16, 8]: [active, categoryHash, x, y, w, h, vx, vy]. */
+  getObjectsTensor(frame: number, maxObjects?: number): TensorData;
+  /** Per-mask coverage + solidity as [16, 2]. */
+  getMasksTensor(frame: number, maxMasks?: number): TensorData;
+  /** Per-class detection histogram for the frame as [nc] float32 (COCO 80 by default). */
+  getClassHistogramTensor(frame: number, nc?: number): TensorData;
+  private clamp;
+}
+//#endregion
+//#region src/spatial/camera-space-transformer.d.ts
+interface Camera3DSpec {
+  readonly width: number;
+  readonly height: number;
+  readonly fov?: number;
+  readonly cameraDistance?: number;
+}
+interface ProjectedScreenCoordinate {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly scale: number;
+}
+declare class SpatialLandmarkTransformer {
+  private width;
+  private height;
+  private fovRad;
+  private focalDistance;
+  constructor(camera: Camera3DSpec);
+  /**
+   * Projects a normalized landmark [0, 1] into 2D/3D canvas coordinates.
+   */
+  projectNormalizedLandmark(landmark: Landmark3D, offsetZ?: number): ProjectedScreenCoordinate;
+  /**
+   * Projects a metric world landmark [X_w, Y_w, Z_w] in meters into canvas space.
+   */
+  projectWorldLandmark(worldLandmark: Landmark3D, subjectDistanceMeters?: number, scaleMetersToPixels?: number): ProjectedScreenCoordinate;
+}
+//#endregion
+//#region src/spatial/spatial-pin.d.ts
+declare function pinNodeToLandmark<T extends {
+  x?: unknown;
+  y?: unknown;
+  z?: unknown;
+  [key: string]: unknown;
+}>(node: T, target: LandmarkCoordinateSignals | {
+  x: number;
+  y: number;
+  z?: number;
+  screenX?: number;
+  screenY?: number;
+}, options?: PinToLandmarkOptions): T;
+declare function pinNodeToObject<T extends {
+  x?: unknown;
+  y?: unknown;
+  z?: unknown;
+  width?: unknown;
+  height?: unknown;
+  opacity?: unknown;
+  [key: string]: unknown;
+}>(node: T, target: ObjectTrackSignals | LandmarkCoordinateSignals | {
+  x: number;
+  y: number;
+  z?: number;
+  screenX?: number;
+  screenY?: number;
+}, options?: PinToObjectOptions): T;
+//#endregion
+//#region src/tracking/temporal-object-tracker.d.ts
+interface TemporalTrackerOptions {
+  /** Minimum Intersection-over-Union to associate a detection with an existing track. Default: 0.25 */
+  readonly iouThreshold?: number;
+  /** Number of frames a lost track is coasted via velocity extrapolation before deletion. Default: 15 */
+  readonly maxMissedFrames?: number;
+  /** Minimum consecutive hits before a tentative track is confirmed active. Default: 1 */
+  readonly minHits?: number;
+  /** Position smoothing weight [0, 1] where 1.0 is instantaneous and 0.0 is fully damped. Default: 0.75 */
+  readonly positionSmoothing?: number;
+  /** Whether tracks remain marked active during coasting frames. Default: true */
+  readonly activeDuringCoast?: boolean;
+}
+/** Axis-aligned box in any consistent unit (pixels or normalized). */
+
+declare class TemporalObjectTracker {
+  private _nextTrackId;
+  private _tracks;
+  private _iouThreshold;
+  private _maxMissedFrames;
+  private _minHits;
+  private _positionSmoothing;
+  private _activeDuringCoast;
+  constructor(options?: TemporalTrackerOptions);
+  /**
+   * Updates the multi-object tracker with new detections for the current frame.
+   *
+   * @param detections Raw detections found on the current frame
+   * @param frame Current frame index
+   * @param fps Video framerate (used for physical velocity estimation)
+   * @returns Stable, temporal list of TrackedObjects
+   */
+  update(detections: readonly DetectedObject[], _frame: number, fps?: number): TrackedObject[];
+  /**
+   * Tracks objects across a full sequence of frames with gap interpolation,
+   * boundary extrapolation (ensuring frame 0 through end are tracked),
+   * and temporal Gaussian smoothing.
+   *
+   * Guarantees zero flicker, zero drift, and frame-accurate stability across the entire video.
+   */
+  trackSequence(perFrameDetections: readonly (readonly DetectedObject[])[], totalFrames: number, fps?: number): TrackedObject[][];
+  /**
+   * Resets all internal track state.
+   */
+  reset(): void;
+}
+//#endregion
+//#region src/tracking/pose-track-matcher.d.ts
+
+//#endregion
+//#region src/vision-node.d.ts
+/**
+ * Bundle returned by `VisionNode.attach()`: the reactive signals surface plus the lazy lifecycle
+ * helpers (all zero-I/O until `runner()` really needs a model).
+ */
+interface VisionAttachedBundle extends VisionBundle {
+  readonly node: VisionNodeSpec;
+  /** Warm the enabled tasks' models/sessions ahead of first use. */
+  ready(): Promise<VisionRunner>;
+  /** Lazily-created runner (downloads happen on first real inference). */
+  runner(): VisionRunner;
+  /** Release this node's runner/sessions. */
+  close(): void;
+}
+/**
+ * Vision node.
+ *
+ * LAZY BY CONSTRUCTION: creating a VisionNode performs ZERO I/O — no model downloads, no
+ * sessions, no file probes. The first inference call (or an explicit `await vision.ready()`)
+ * downloads the required models.
+ */
+declare class VisionNode {
+  readonly id: string;
+  readonly kind: "vision";
+  readonly source: VisionInputSource;
+  readonly config: VisionConfig;
+  readonly vision: VisionBundle;
+  private _runner?;
+  /** Runner construction options (modelsDir, provider, store, …) — injectable for tests/agents. */
+  private readonly _runnerOptions;
+  constructor(source: VisionInputSource, config?: VisionConfig, bundleOptions?: VisionBundleOptions, runnerOptions?: VisionRunnerOptions);
+  /** Lazily-created runner; downloads happen on its first inference. */
+  runner(): VisionRunner;
+  /** Explicit warm-up — downloads the models for the enabled tasks, ahead of first inference. */
+  ready(): Promise<VisionRunner>;
+  close(): void;
+  static attach(source: VisionInputSource, config?: VisionConfig, bundleOptions?: VisionBundleOptions): VisionAttachedBundle;
+  toNode(): VisionNodeSpec;
+}
+//#endregion
+//#region src/effects/generated/classes.d.ts
+interface TonalShift {
+  /**
+   * Range -100 to 100.
+   * @default 0
+   */
+  cyanRed: number;
+  /**
+   * Range -100 to 100.
+   * @default 0
+   */
+  magentaGreen: number;
+  /**
+   * Range -100 to 100.
+   * @default 0
+   */
+  yellowBlue: number;
+}
+interface BlurBaseProps {
+  /**
+   * Blur Type
+   * @default "Gaussian"
+   */
+  blurType?: "Gaussian" | "Box" | "Median" | "Motion" | "Bilateral" | "Edge-preserving" | "Radial" | "Zoom";
+  /**
+   * The intensity of the blur. 0 = no blur. Can be modulated by a static number or a dynamic signal.
+   * Range 0 to 100. Accepts a signal.
+   * @default 5
+   */
+  strength?: EffectProp<number>;
+  /**
+   * Direction of a Motion blur, in degrees.
+   * Range 0 to 360. Accepts a signal.
+   * @default 0
+   */
+  angle?: EffectProp<number>;
+  /**
+   * Sigma value for color space in Bilateral / Edge-preserving blurs. Can be modulated by a static number or a dynamic signal.
+   * Range 0.01 to 1. Accepts a signal.
+   * @default 0.1
+   */
+  sigmaColor?: EffectProp<number>;
+  /**
+   * The X coordinate of the blur center (0.0 to 1.0). Can be modulated by a static number or a dynamic signal.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.5
+   */
+  centerX?: EffectProp<number>;
+  /**
+   * The Y coordinate of the blur center (0.0 to 1.0). Can be modulated by a static number or a dynamic signal.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.5
+   */
+  centerY?: EffectProp<number>;
+  /**
+   * Blurs only a specific circular area around center point.
+   * Accepts a signal.
+   * @default false
+   */
+  partialBlur?: EffectProp<boolean>;
+  /**
+   * Radius of the partial blur region (0.01 to 1.0). Can be modulated by a static number or a dynamic signal.
+   * Range 0.01 to 1. Accepts a signal.
+   * @default 0.3
+   */
+  radius?: EffectProp<number>;
+  /**
+   * Vertical radius of the partial blur region (0 to 1.0). 0 reuses the horizontal radius.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0
+   */
+  radiusY?: EffectProp<number>;
+  /**
+   * Shape of the partial blur region.
+   * @default "circle"
+   */
+  shape?: "ellipse" | "circle" | "rect";
+}
+/** @internal Extended by `effects/custom/blur.ts`, which exports `Blur`. */
+declare class BlurBase extends Effect<BlurBaseProps> {
+  readonly op = "Blur";
+  blurType: "Gaussian" | "Box" | "Median" | "Motion" | "Bilateral" | "Edge-preserving" | "Radial" | "Zoom";
+  strength: number;
+  angle: number;
+  sigmaColor: number;
+  centerX: number;
+  centerY: number;
+  partialBlur: boolean;
+  radius: number;
+  radiusY: number;
+  shape: "ellipse" | "circle" | "rect";
+  constructor(config?: BlurBaseProps);
+}
+interface ColorBalanceProps {
+  /**
+   * @default {"cyanRed":0,"magentaGreen":0,"yellowBlue":0}
+   */
+  shadows?: Partial<TonalShift>;
+  /**
+   * @default {"cyanRed":0,"magentaGreen":0,"yellowBlue":0}
+   */
+  midtones?: Partial<TonalShift>;
+  /**
+   * @default {"cyanRed":0,"magentaGreen":0,"yellowBlue":0}
+   */
+  highlights?: Partial<TonalShift>;
+  /**
+   * @default true
+   */
+  preserveLuminosity?: boolean;
+}
+declare class ColorBalance extends Effect<ColorBalanceProps> {
+  readonly op = "ColorBalance";
+  shadows: Partial<TonalShift>;
+  midtones: Partial<TonalShift>;
+  highlights: Partial<TonalShift>;
+  preserveLuminosity: boolean;
+  constructor(config?: ColorBalanceProps);
+}
+interface ColorKeyProps {
+  /**
+   * Key Color
+   * @default "#00ff00"
+   */
+  keyColor?: string;
+  /**
+   * How close the color must be to the Key Color to be removed.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.4
+   */
+  similarity?: EffectProp<number>;
+  /**
+   * The softness of the transparency edge.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.1
+   */
+  smoothness?: EffectProp<number>;
+  /**
+   * Amount of key color spill to remove from foreground edges.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.2
+   */
+  spillSuppression?: EffectProp<number>;
+  /**
+   * Color space used to calculate similarity distance.
+   * @default "YUV"
+   */
+  colorSpace?: "YUV" | "RGB";
+  /**
+   * How key color spill is suppressed on foreground edges.
+   * @default "Desaturate"
+   */
+  spillSuppressionType?: "Desaturate" | "Neutralize" | "None";
+}
+declare class ColorKey extends Effect<ColorKeyProps> {
+  readonly op = "ColorKey";
+  keyColor: string;
+  similarity: number;
+  smoothness: number;
+  spillSuppression: number;
+  colorSpace: "YUV" | "RGB";
+  spillSuppressionType: "Desaturate" | "Neutralize" | "None";
+  constructor(config?: ColorKeyProps);
+}
+interface VignetteProps {
+  /**
+   * The intensity of the vignette darkening effect. 0 = no vignette.
+   * Range 0 to 100. Accepts a signal.
+   * @default 50
+   */
+  strength?: EffectProp<number>;
+  /**
+   * The extent/size of the vignette.
+   * Range 0.1 to 2. Accepts a signal.
+   * @default 1
+   */
+  radius?: EffectProp<number>;
+  /**
+   * The softness of the vignette transition edge.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.5
+   */
+  softness?: EffectProp<number>;
+  /**
+   * 0.0 matches the image aspect ratio, 1.0 is a perfect circle.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.5
+   */
+  roundness?: EffectProp<number>;
+  /**
+   * The X coordinate of the vignette center.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.5
+   */
+  centerX?: EffectProp<number>;
+  /**
+   * The Y coordinate of the vignette center.
+   * Range 0 to 1. Accepts a signal.
+   * @default 0.5
+   */
+  centerY?: EffectProp<number>;
+}
+declare class Vignette extends Effect<VignetteProps> {
+  readonly op = "Vignette";
+  strength: number;
+  radius: number;
+  softness: number;
+  roundness: number;
+  centerX: number;
+  centerY: number;
+  constructor(config?: VignetteProps);
+}
+//#endregion
+//#region src/effects/custom/blur.d.ts
+interface BlurProps extends BlurBaseProps {
+  /**
+   * Follow a tracked object. Turns on `partialBlur` and derives the region
+   * (`centerX`, `centerY`, `radius`, `radiusY`, `shape`) and `strength` from
+   * the track. Any of those passed explicitly wins over the track.
+   */
+  track?: ObjectTrackSignals;
+}
+/**
+ * Blur effect. Props, defaults and ranges are generated from `node-blur`'s
+ * schema ({@link BlurBase}); this subclass only adds `track`.
+ */
+declare class Blur extends BlurBase {
+  constructor(config?: BlurProps);
+}
+//#endregion
+//#region src/effects/generated/meta.d.ts
+/** Ranges and allowed values per effect prop, used by `withDefaults()` checks. */
+declare const effectMeta: {
+  readonly Blur: {
+    readonly blurType: {
+      readonly enum: readonly ["Gaussian", "Box", "Median", "Motion", "Bilateral", "Edge-preserving", "Radial", "Zoom"];
+    };
+    readonly strength: {
+      readonly min: 0;
+      readonly max: 100;
+    };
+    readonly angle: {
+      readonly min: 0;
+      readonly max: 360;
+    };
+    readonly sigmaColor: {
+      readonly min: 0.01;
+      readonly max: 1;
+    };
+    readonly centerX: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly centerY: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly partialBlur: {};
+    readonly radius: {
+      readonly min: 0.01;
+      readonly max: 1;
+    };
+    readonly radiusY: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly shape: {
+      readonly enum: readonly ["ellipse", "circle", "rect"];
+    };
+  };
+  readonly ColorBalance: {
+    readonly shadows: {
+      readonly props: {
+        readonly cyanRed: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+        readonly magentaGreen: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+        readonly yellowBlue: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+      };
+    };
+    readonly midtones: {
+      readonly props: {
+        readonly cyanRed: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+        readonly magentaGreen: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+        readonly yellowBlue: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+      };
+    };
+    readonly highlights: {
+      readonly props: {
+        readonly cyanRed: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+        readonly magentaGreen: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+        readonly yellowBlue: {
+          readonly min: -100;
+          readonly max: 100;
+        };
+      };
+    };
+    readonly preserveLuminosity: {};
+  };
+  readonly ColorKey: {
+    readonly keyColor: {};
+    readonly similarity: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly smoothness: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly spillSuppression: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly colorSpace: {
+      readonly enum: readonly ["YUV", "RGB"];
+    };
+    readonly spillSuppressionType: {
+      readonly enum: readonly ["Desaturate", "Neutralize", "None"];
+    };
+  };
+  readonly Vignette: {
+    readonly strength: {
+      readonly min: 0;
+      readonly max: 100;
+    };
+    readonly radius: {
+      readonly min: 0.1;
+      readonly max: 2;
+    };
+    readonly softness: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly roundness: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly centerX: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+    readonly centerY: {
+      readonly min: 0;
+      readonly max: 1;
+    };
+  };
+};
+//#endregion
+//#region src/effects/generated/registry.d.ts
+/** `Effect.<factory>(config)` helpers, one per generated effect class. */
+declare const effectFactories: {
+  readonly blur: (config?: BlurProps) => Blur;
+  readonly colorBalance: (config?: ColorBalanceProps) => ColorBalance;
+  readonly colorKey: (config?: ColorKeyProps) => ColorKey;
+  readonly vignette: (config?: VignetteProps) => Vignette;
+};
+//#endregion
+//#region src/effects/classes.d.ts
+interface LevelChannel {
+  inBlack?: number;
+  inWhite?: number;
+  outBlack?: number;
+  outWhite?: number;
+}
+interface LevelsProps {
+  master?: LevelChannel;
+  red?: LevelChannel;
+  green?: LevelChannel;
+  blue?: LevelChannel;
+}
+declare class Levels extends Effect<LevelsProps> {
+  readonly op = "Levels";
+  master: LevelChannel;
+  red: LevelChannel;
+  green: LevelChannel;
+  blue: LevelChannel;
+  constructor(config?: LevelsProps);
+}
+interface FilmGrainProps {
+  strength?: EffectProp<number>;
+  size?: EffectProp<number>;
+  monochrome?: boolean;
+  animated?: boolean;
+  speed?: EffectProp<number>;
+  shadows?: EffectProp<number>;
+  midtones?: EffectProp<number>;
+  highlights?: EffectProp<number>;
+}
+declare class FilmGrain extends Effect<FilmGrainProps> {
+  readonly op = "FilmGrain";
+  strength: number;
+  size: number;
+  monochrome: boolean;
+  animated: boolean;
+  speed: number;
+  shadows: number;
+  midtones: number;
+  highlights: number;
+  constructor(config?: FilmGrainProps);
+}
+declare class CustomEffect extends Effect<Record<string, unknown>> {
+  readonly op: string;
+  constructor(opName: string, config?: Record<string, unknown>);
+}
+interface AudioSignalExtractorProps {
+  extractionMode?: "rms_envelope" | "transient_beat" | "sub_bass" | "bass" | "mid" | "high" | "spectral_flux";
+  attackMs?: number;
+  releaseMs?: number;
+  sensitivity?: number;
+  noiseFloorDb?: number;
+  dynamicRangeDb?: number;
+  autoRange?: boolean;
+  smoothing?: number;
+  curve?: "linear" | "exponential" | "logarithmic" | "square" | "smoothstep";
+  beatThreshold?: number;
+  beatDecayMs?: number;
+  previewMode?: "waveform" | "envelope" | "beat_markers" | "spectrum";
+  nodeId?: string;
+}
+declare class AudioSignalExtractor extends Effect<AudioSignalExtractorProps> {
+  readonly op = "AudioSignalExtractor";
+  extractionMode: AudioSignalExtractorProps["extractionMode"];
+  attackMs: number;
+  releaseMs: number;
+  sensitivity: number;
+  noiseFloorDb: number;
+  dynamicRangeDb: number;
+  autoRange: boolean;
+  smoothing: number;
+  curve: AudioSignalExtractorProps["curve"];
+  beatThreshold: number;
+  beatDecayMs: number;
+  previewMode: AudioSignalExtractorProps["previewMode"];
+  nodeId: string;
+  constructor(config?: AudioSignalExtractorProps);
+  extract(source: string, options?: Partial<AudioSignalOptions>): Promise<ExtractedAudioSignalsBundle>;
+}
+interface CurvesChannelPoint {
+  x: number;
+  y: number;
+}
+interface CurvesProps {
+  curveType?: "rgb" | "hue-vs-hue" | "hue-vs-sat" | "lum-vs-sat" | "sat-vs-sat";
+  master?: CurvesChannelPoint[];
+  red?: CurvesChannelPoint[];
+  green?: CurvesChannelPoint[];
+  blue?: CurvesChannelPoint[];
+  hueVsHue?: CurvesChannelPoint[];
+  hueVsSat?: CurvesChannelPoint[];
+  lumVsSat?: CurvesChannelPoint[];
+  satVsSat?: CurvesChannelPoint[];
+}
+declare class Curves extends Effect<CurvesProps> {
+  readonly op = "Curves";
+  curveType: CurvesProps["curveType"];
+  master: CurvesChannelPoint[];
+  red: CurvesChannelPoint[];
+  green: CurvesChannelPoint[];
+  blue: CurvesChannelPoint[];
+  hueVsHue: CurvesChannelPoint[];
+  hueVsSat: CurvesChannelPoint[];
+  lumVsSat: CurvesChannelPoint[];
+  satVsSat: CurvesChannelPoint[];
+  constructor(config?: CurvesProps);
+}
+interface SelectiveColorAdjustment {
+  cyan: number;
+  magenta: number;
+  yellow: number;
+  black: number;
+}
+interface SelectiveColorProps {
+  method?: "Relative" | "Absolute";
+  reds?: Partial<SelectiveColorAdjustment>;
+  yellows?: Partial<SelectiveColorAdjustment>;
+  greens?: Partial<SelectiveColorAdjustment>;
+  cyans?: Partial<SelectiveColorAdjustment>;
+  blues?: Partial<SelectiveColorAdjustment>;
+  magentas?: Partial<SelectiveColorAdjustment>;
+  whites?: Partial<SelectiveColorAdjustment>;
+  neutrals?: Partial<SelectiveColorAdjustment>;
+  blacks?: Partial<SelectiveColorAdjustment>;
+}
+declare class SelectiveColor extends Effect<SelectiveColorProps> {
+  readonly op = "SelectiveColor";
+  method: "Relative" | "Absolute";
+  reds: SelectiveColorAdjustment;
+  yellows: SelectiveColorAdjustment;
+  greens: SelectiveColorAdjustment;
+  cyans: SelectiveColorAdjustment;
+  blues: SelectiveColorAdjustment;
+  magentas: SelectiveColorAdjustment;
+  whites: SelectiveColorAdjustment;
+  neutrals: SelectiveColorAdjustment;
+  blacks: SelectiveColorAdjustment;
+  constructor(config?: SelectiveColorProps);
+}
+interface GradientMapStop {
+  position: number;
+  color: string;
+}
+interface GradientMapProps {
+  stops?: GradientMapStop[];
+  smooth?: boolean;
+  dither?: boolean;
+  opacity?: EffectProp<number>;
+}
+declare class GradientMap extends Effect<GradientMapProps> {
+  readonly op = "GradientMap";
+  stops: GradientMapStop[];
+  smooth: boolean;
+  dither: boolean;
+  opacity: number;
+  constructor(config?: GradientMapProps);
+}
+interface ShadowsHighlightsProps {
+  shadowAmount?: EffectProp<number>;
+  shadowTonalWidth?: EffectProp<number>;
+  shadowRadius?: EffectProp<number>;
+  highlightAmount?: EffectProp<number>;
+  highlightTonalWidth?: EffectProp<number>;
+  highlightRadius?: EffectProp<number>;
+  colorCorrection?: EffectProp<number>;
+  midtoneContrast?: EffectProp<number>;
+}
+declare class ShadowsHighlights extends Effect<ShadowsHighlightsProps> {
+  readonly op = "ShadowsHighlights";
+  shadowAmount: number;
+  shadowTonalWidth: number;
+  shadowRadius: number;
+  highlightAmount: number;
+  highlightTonalWidth: number;
+  highlightRadius: number;
+  colorCorrection: number;
+  midtoneContrast: number;
+  constructor(config?: ShadowsHighlightsProps);
+}
+interface ApplyLUTProps {
+  lutUrl?: string;
+  intensity?: EffectProp<number>;
+}
+declare class ApplyLUT extends Effect<ApplyLUTProps> {
+  readonly op = "ApplyLUT";
+  lutUrl: string;
+  intensity: number;
+  constructor(config?: ApplyLUTProps);
+}
+interface UnsharpMaskProps {
+  amount?: EffectProp<number>;
+  radius?: EffectProp<number>;
+  threshold?: EffectProp<number>;
+}
+declare class UnsharpMask extends Effect<UnsharpMaskProps> {
+  readonly op = "UnsharpMask";
+  amount: number;
+  radius: number;
+  threshold: number;
+  constructor(config?: UnsharpMaskProps);
+}
+interface HighPassProps {
+  radius?: EffectProp<number>;
+  contrastBoost?: EffectProp<number>;
+  monochrome?: boolean;
+}
+declare class HighPass extends Effect<HighPassProps> {
+  readonly op = "HighPass";
+  radius: number;
+  contrastBoost: number;
+  monochrome: boolean;
+  constructor(config?: HighPassProps);
+}
+type HalftoneDotShape = "Circle" | "Diamond" | "Line" | "Square";
+type HalftoneMode = "Monochrome" | "CMYK";
+interface HalftoneScreenProps {
+  mode?: HalftoneMode;
+  dotShape?: HalftoneDotShape;
+  frequency?: EffectProp<number>;
+  angle?: EffectProp<number>;
+  contrast?: EffectProp<number>;
+  dotColor?: string;
+  paperColor?: string;
+  smooth?: boolean;
+  invert?: boolean;
+  cyanAngle?: EffectProp<number>;
+  magentaAngle?: EffectProp<number>;
+  yellowAngle?: EffectProp<number>;
+  blackAngle?: EffectProp<number>;
+  opacity?: EffectProp<number>;
+}
+declare class HalftoneScreen extends Effect<HalftoneScreenProps> {
+  readonly op = "HalftoneScreen";
+  mode: HalftoneMode;
+  dotShape: HalftoneDotShape;
+  frequency: number;
+  angle: number;
+  contrast: number;
+  dotColor: string;
+  paperColor: string;
+  smooth: boolean;
+  invert: boolean;
+  cyanAngle: number;
+  magentaAngle: number;
+  yellowAngle: number;
+  blackAngle: number;
+  opacity: number;
+  constructor(config?: HalftoneScreenProps);
+}
+type TileOffsetEdgeMode = "wrap" | "clamp" | "transparent" | "mirror";
+interface TileOffsetProps {
+  offsetX?: EffectProp<number>;
+  offsetY?: EffectProp<number>;
+  wrap?: boolean;
+  edgeMode?: TileOffsetEdgeMode;
+}
+declare class TileOffset extends Effect<TileOffsetProps> {
+  readonly op = "TileOffset";
+  offsetX: number;
+  offsetY: number;
+  wrap: boolean;
+  edgeMode: TileOffsetEdgeMode;
+  constructor(config?: TileOffsetProps);
+}
+interface MotionBlurProps {
+  shutterAngle?: EffectProp<number>;
+  samples?: EffectProp<number>;
+  maxVelocity?: EffectProp<number>;
+  shutterCurve?: "box" | "gaussian" | "triangle";
+  depthAware?: boolean;
+}
+declare class MotionBlur extends Effect<MotionBlurProps> {
+  readonly op = "MotionBlur";
+  shutterAngle: number;
+  samples: number;
+  maxVelocity: number;
+  shutterCurve: "box" | "gaussian" | "triangle";
+  depthAware: boolean;
+  constructor(config?: MotionBlurProps);
+}
+interface SSAOProps {
+  radius?: EffectProp<number>;
+  bias?: EffectProp<number>;
+  intensity?: EffectProp<number>;
+  kernelSamples?: EffectProp<number>;
+  blurRadius?: EffectProp<number>;
+}
+declare class SSAO extends Effect<SSAOProps> {
+  readonly op = "SSAO";
+  radius: number;
+  bias: number;
+  intensity: number;
+  kernelSamples: number;
+  blurRadius: number;
+  constructor(config?: SSAOProps);
+}
+interface PBRGlassProps {
+  ior?: EffectProp<number>;
+  roughness?: EffectProp<number>;
+  transmission?: EffectProp<number>;
+  dispersion?: EffectProp<number>;
+  fresnelPower?: EffectProp<number>;
+  tintColor?: EffectProp<string>;
+}
+declare class PBRGlass extends Effect<PBRGlassProps> {
+  readonly op = "PBRGlass";
+  ior: number;
+  roughness: number;
+  transmission: number;
+  dispersion: number;
+  fresnelPower: number;
+  tintColor: string;
+  constructor(config?: PBRGlassProps);
+}
+interface DepthOfFieldProps {
+  focusDistance?: EffectProp<number>;
+  focalLength?: EffectProp<number>;
+  aperture?: EffectProp<number>;
+  maxBlur?: EffectProp<number>;
+  quality?: "low" | "medium" | "high" | "ultra";
+}
+declare class DepthOfField extends Effect<DepthOfFieldProps> {
+  readonly op = "DepthOfField";
+  focusDistance: number;
+  focalLength: number;
+  aperture: number;
+  maxBlur: number;
+  quality: string;
+  constructor(config?: DepthOfFieldProps);
+}
+interface CropProps {
+  cropType?: "rect" | "path";
+  leftPercentage?: EffectProp<number>;
+  topPercentage?: EffectProp<number>;
+  widthPercentage?: EffectProp<number>;
+  heightPercentage?: EffectProp<number>;
+  roundness?: EffectProp<number>;
+  pathPoints?: {
+    x: number;
+    y: number;
+  }[];
+  mode?: "cropped" | "rest";
+}
+declare class Crop extends Effect<CropProps> {
+  readonly op = "Crop";
+  cropType: "rect" | "path";
+  leftPercentage: number;
+  topPercentage: number;
+  widthPercentage: number;
+  heightPercentage: number;
+  roundness: number;
+  pathPoints?: {
+    x: number;
+    y: number;
+  }[];
+  mode?: "cropped" | "rest";
+  constructor(config?: CropProps);
+}
+interface VisionProps {
+  /** Track COCO-80 objects (RTMDet-Ins boxes). Default true. */
+  enableDetection?: boolean;
+  /** Per-instance masks (RTMDet-Ins). Shares the detection pass. */
+  enableSegmentation?: boolean;
+  /** COCO-17 keypoints per person (RTMO). */
+  enablePose?: boolean;
+  /** Fast person-vs-background alpha (Selfie Segmenter). */
+  enableMatte?: boolean;
+  /** COCO class-name filter (all classes when omitted). */
+  classes?: readonly string[];
+  /** Minimum detection score, 0..1. Default 0.3. */
+  confidence?: number;
+  /** Model size: `t` fastest · `s` default · `m` most accurate. */
+  variant?: "t" | "s" | "m";
+  mode?: "passthrough" | "mask" | "matte" | "crop" | "skeleton" | "boxes" | "tracking";
+  /**
+   * Subject alpha for mask/matte/crop: instance masks (default; any COCO class) or the
+   * selfie matte (fastest, but only reliable when a person fills much of the frame).
+   */
+  matteSource?: "instance" | "selfie";
+  /** Frames a track may go unseen before it is dropped. Default 15. */
+  maxMissedFrames?: number;
+  modelsDir?: string;
+  baseUrl?: string;
+  maskThreshold?: number;
+  featherRadius?: number;
+  /** Grow the subject into connected pixels that stand out from the backdrop. */
+  keyBackground?: boolean;
+  /** Colour-distance threshold for the background key (lower → more growth). Default 70. */
+  backgroundKeyThreshold?: number;
+  visionBundle?: unknown;
+}
+/**
+ * On-device vision: tracks objects, segments instances, estimates pose and mattes people on
+ * the rendered frame, feeding reactive signals. Models download lazily on first use.
+ */
+declare class Vision extends Effect<VisionProps> {
+  readonly op = "Vision";
+  enableDetection?: boolean;
+  enableSegmentation?: boolean;
+  enablePose?: boolean;
+  enableMatte?: boolean;
+  classes?: readonly string[];
+  confidence?: number;
+  variant?: VisionProps["variant"];
+  mode?: VisionProps["mode"];
+  matteSource?: VisionProps["matteSource"];
+  maxMissedFrames?: number;
+  modelsDir?: string;
+  baseUrl?: string;
+  maskThreshold?: number;
+  featherRadius?: number;
+  keyBackground?: boolean;
+  backgroundKeyThreshold?: number;
+  visionBundle?: unknown;
+  constructor(config?: VisionProps);
+}
+interface Relight3DProps {
+  lightType?: "Point" | "Spot" | "Directional" | "Rim";
+  intensity?: EffectProp<number>;
+  lightPosX?: EffectProp<number>;
+  lightPosY?: EffectProp<number>;
+  lightPosZ?: EffectProp<number>;
+  lightRadius?: EffectProp<number>;
+  spotConeAngle?: EffectProp<number>;
+  specularRoughness?: EffectProp<number>;
+  specularStrength?: EffectProp<number>;
+  metallic?: EffectProp<number>;
+  ambientIntensity?: EffectProp<number>;
+  volumetricDensity?: EffectProp<number>;
+  depthScale?: EffectProp<number>;
+  depthInvert?: boolean;
+  lightColor?: string;
+  ambientColor?: string;
+  normalMap?: unknown;
+}
+declare class Relight3D extends Effect<Relight3DProps> {
+  readonly op = "Relight3D";
+  lightType: Relight3DProps["lightType"];
+  intensity: number;
+  lightPosX: number;
+  lightPosY: number;
+  lightPosZ: number;
+  lightRadius: number;
+  spotConeAngle: number;
+  specularRoughness: number;
+  specularStrength: number;
+  metallic: number;
+  ambientIntensity: number;
+  volumetricDensity: number;
+  depthScale: number;
+  depthInvert: boolean;
+  lightColor: string;
+  ambientColor: string;
+  normalMap: unknown;
+  constructor(config?: Relight3DProps);
+}
+interface DeflickerProps {
+  blendWeight?: EffectProp<number>;
+  disocclusionThreshold?: EffectProp<number>;
+  maxMotionPixels?: EffectProp<number>;
+  scale?: number;
+  windowSize?: number;
+}
+declare class TemporalDeflicker extends Effect<DeflickerProps> {
+  readonly op = "TemporalDeflicker";
+  blendWeight: number;
+  disocclusionThreshold: number;
+  maxMotionPixels: number;
+  scale: number;
+  windowSize: number;
+  constructor(config?: DeflickerProps);
+}
+interface ModulateProps {
+  hue?: EffectProp<number>;
+  brightness?: EffectProp<number>;
+  contrast?: EffectProp<number>;
+  exposure?: EffectProp<number>;
+  saturation?: EffectProp<number>;
+  sepia?: EffectProp<number>;
+}
+declare class Modulate extends Effect<ModulateProps> {
+  readonly op = "Modulate";
+  hue: number;
+  brightness: number;
+  contrast: number;
+  exposure: number;
+  saturation: number;
+  sepia: number;
+  constructor(config?: ModulateProps);
+}
+//#endregion
+export { Blur as $, _default$6 as $t, MotionBlur as A, TemporalObjectTracker as At, SelectiveColorProps as B, DepthNormalsComputePipeline as Bt, HighPass as C, _default$29 as Cn, PinToObjectOptions as Ct, LevelsProps as D, SegmentationResult as Dt, Levels as E, PoseSkeletonRenderer as Et, Relight3DProps as F, analyzeSequence as Ft, TileOffsetEdgeMode as G, TensorViewExport as Gt, ShadowsHighlightsProps as H, TemporalDeflickerPipeline as Ht, SSAO as I, pinNodeToLandmark as It, UnsharpMaskProps as J, _default$1 as Jt, TileOffsetProps as K, EffectProp as Kt, SSAOProps as L, pinNodeToObject as Lt, PBRGlass as M, VisionBundle as Mt, PBRGlassProps as N, VisionNode as Nt, Modulate as O, SegmentationTexturePool as Ot, Relight3D as P, VisionRunner as Pt, effectMeta as Q, _default$5 as Qt, SelectiveColor as R, CannyComputePipeline as Rt, HalftoneScreenProps as S, _default$28 as Sn, PinToLandmarkOptions as St, LevelChannel as T, PoseResult as Tt, TemporalDeflicker as U, TensorPipeline as Ut, ShadowsHighlights as V, OpticalFlowComputePipeline as Vt, TileOffset as W, TensorSource as Wt, VisionProps as X, _default$3 as Xt, Vision as Y, _default$2 as Yt, effectFactories as Z, _default$4 as Zt, GradientMapProps as _, _default$24 as _n, ObjectBoundingBoxSignals as _t, Crop as a, _default$12 as an, TonalShift as at, HalftoneMode as b, _default$26 as bn, ObjectTrackSignals as bt, CurvesChannelPoint as c, _default$15 as cn, COCO17_BONES as ct, DeflickerProps as d, _default$18 as dn, COCO_CLASSES as dt, _default$7 as en, BlurProps as et, DepthOfField as f, _default$19 as fn, InstanceMask as ft, GradientMap as g, _default$23 as gn, ObjectAnchorsSignals as gt, FilmGrainProps as h, _default$22 as hn, ObjectAnchorName as ht, AudioSignalExtractorProps as i, _default$11 as in, ColorKeyProps as it, MotionBlurProps as j, VisionAnalysisReport as jt, ModulateProps as k, SpatialLandmarkTransformer as kt, CurvesProps as l, _default$16 as ln, COCO17_KEYPOINTS as lt, FilmGrain as m, _default$21 as mn, MaskTrackSignals as mt, ApplyLUTProps as n, _default$9 as nn, ColorBalanceProps as nt, CropProps as o, _default$13 as on, Vignette as ot, DepthOfFieldProps as p, _default$20 as pn, LandmarkCoordinateSignals as pt, UnsharpMask as q, _default as qt, AudioSignalExtractor as r, _default$10 as rn, ColorKey as rt, Curves as s, _default$14 as sn, VignetteProps as st, ApplyLUT as t, _default$8 as tn, ColorBalance as tt, CustomEffect as u, _default$17 as un, COCO17_KEYPOINT_NAMES as ut, GradientMapStop as v, rendererNode as vn, ObjectCollectionSignals as vt, HighPassProps as w, PoseLandmarkSignals as wt, HalftoneScreen as x, _default$27 as xn, PersonMatte as xt, HalftoneDotShape as y, _default$25 as yn, ObjectKinematicsSignals as yt, SelectiveColorAdjustment as z, ControlNetMultiplexer as zt };
+//# sourceMappingURL=index-B0BNPEoH.d.mts.map