framefields 2.12.0 → 2.13.1

package/dist/{index-gOVtTm-P.d.mts → index-DQ1U3HC3.d.mts}

@@ -1,4 +1,5 @@
-import { ur as VirtualMediaData } from "./index-COYNQ_mf.mjs";
+import { ur as VirtualMediaData } from "./index-a6JrbAK0.mjs";
+import { t as AudioMix } from "./index-BFTtXosj.mjs";
 import { VideoSampleSource } from "mediabunny";
 import pino from "pino";
 import { VideoFrame } from "@napi-rs/webcodecs";
@@ -238,13 +239,20 @@ declare class HeadlessWebGPURenderer {
    * Mixes the composition's full audio timeline (clips, effects, synthesized
    * tracks) to stereo PCM, exactly as `renderVideo` muxes it.
    */
+  /**
+   * Mixes the timeline's audio. `window` mixes only that stretch (the same
+   * samples as that part of a full mix); `master: false` skips the master
+   * stage, for callers that master with the whole film's `peak` later.
+   */
   renderAudio(virtualMedia: VirtualMediaData, options?: {
     fps?: number;
     sampleRate?: number;
-  }): Promise<{
-    channels: Float32Array[];
-    sampleRate: number;
-  }>;
+    window?: {
+      startSec: number;
+      endSec: number;
+    };
+    master?: boolean;
+  }): Promise<AudioMix>;
   renderLut(virtualMedia: VirtualMediaData, frame?: number, fps?: number): Promise<Buffer>;
   private resolveMediaDuration;
   renderVideo(virtualMedia: VirtualMediaData, options?: {
@@ -481,4 +489,4 @@ type FrameGridRenderable = {
 declare function renderFrameGrid(target: FrameGridRenderable, options?: FrameGridOptions): Promise<Buffer>;
 //#endregion
 export { formatQaReport as C, stitchChunks as D, resetRenderCaches as E, VideoQaStats as S, renderSemaphore as T, RenderProgress as _, renderFrameGrid as a, VideoQaOptions as b, ChunkPlan as c, FrameRange as d, HeadlessMediaRenderer as f, QaSegment as g, QaIssue as h, computeGridLayout as i, ChunkPlanOptions as l, PlannedChunk as m, FrameGridRenderable as n, resolveSamplePoints as o, HeadlessWebGPURenderer as p, FrameSamplePoint as r, AudioQaStats as s, FrameGridOptions as t, FrameCostSample as u, StitchOptions as v, planChunks as w, VideoQaReport as x, StitchResult as y };
-//# sourceMappingURL=index-gOVtTm-P.d.mts.map
+//# sourceMappingURL=index-DQ1U3HC3.d.mts.map

package/dist/index-DQ1U3HC3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DQ1U3HC3.d.mts","names":["pino","DestinationStream","VideoColorPrimaries","VideoFrame","VideoMatrixCoefficients","VideoTransferCharacteristics","AudioMix","RenderDiagnostic","VirtualMediaData","VideoSampleSource","preloadFonts","GPUDevice","Promise","FrameCostSample","ChunkPlanOptions","PlannedChunk","ChunkPlan","planChunks","StagingSlotStatus","VideoColorSpaceConfig","DmaStagingRingOptions","GPUTextureFormat","StagingSlotInfo","DmaStagingRing","GPUCommandEncoder","GPUTexture","Uint8Array","findNodesDir","discoverAndRegisterNodeRenderers","RenderPhase","RenderProgress","VideoQaOptions","QaSegment","QaIssue","VideoQaStats","AudioQaStats","VideoQaReport","FrameInspector","analyzeAudio","Float32Array","integratedLoudness","buildQaReport","formatQaReport","RenderSemaphore","renderSemaphore","FrameRange","HeadlessWebGPURenderer","Buffer","AbortSignal","HeadlessMediaRenderer","resetRenderCaches","resolveLogFormat","Record","textLogStream","rendererLogger","Logger","NODE_KINDS","NodeKind","NodeRendererExports","NodeManifest","NodeManifestError","Error","parseNodeManifest","loadNodeManifests","StitchOptions","StitchResult","stitchChunks","ZeroCopyWebCodecsPipelineOptions","WebCodecsPipelineStats","ZeroCopyWebCodecsPipeline"],"sources":["../../renderer/dist/index.d.mts","../src/renderer/framegrid.ts"],"sourcesContent":["import pino, { DestinationStream } from \"pino\";\nimport { VideoColorPrimaries, VideoFrame, VideoMatrixCoefficients, VideoTransferCharacteristics } from \"@napi-rs/webcodecs\";\nimport { AudioMix } from \"@framefields/compositions\";\nimport { RenderDiagnostic, VirtualMediaData } from \"@framefields/core\";\nimport { VideoSampleSource } from \"mediabunny\";\n\n//#region src/asset-preloader.d.ts\n/**\n * Preloads only the fonts (and emoji) a VirtualMediaData tree's text uses, so\n * typography renders correctly on Node.js without loading its media. Shared\n * with the browser preview; emoji need a font set with\n * `FontManager.registerEmojiFont()`.\n */\ndeclare function preloadFonts(media: VirtualMediaData, device?: GPUDevice | null): Promise<void>;\n//#endregion\n//#region src/chunk-plan.d.ts\n/**\n * Plans a render split across workers: how many chunks, and where each one\n * starts and ends. Pure arithmetic over measured frame costs, so it runs\n * anywhere (a worker's probe job, a coordinator, a local script).\n *\n * Every chunk pays a fixed cost before its first frame (worker start, fetch,\n * install, composition build). `workers: \"auto\"` adds workers only while each\n * chunk still spends at least `efficiency` of its time rendering, so a short\n * film stays on one worker and a long one spreads out until `maxWorkers`.\n * Chunks are cut at equal render cost, not equal frame counts, so a heavy\n * stretch (3D, vision) gets shorter chunks.\n */\n/** A measured render time for one frame. */\ninterface FrameCostSample {\n  frame: number;\n  ms: number;\n}\ninterface ChunkPlanOptions {\n  /** Frames in the composition. */\n  totalFrames: number;\n  /** Measured frame times; between samples the cost is interpolated linearly. */\n  samples: readonly FrameCostSample[];\n  /** A worker count, or `\"auto\"` to pick one from the cost. Default 1. */\n  workers?: number | \"auto\";\n  /** Upper bound for `\"auto\"` (and for a number). Default 10. */\n  maxWorkers?: number;\n  /** Fixed cost each chunk pays before rendering, in seconds. Default 90 (a cold start). */\n  overheadSec?: number;\n  /**\n   * `\"auto\"` only: the smallest share of a chunk's time spent rendering,\n   * between 0 and 1. Default 0.85: each chunk renders at least\n   * `overheadSec × 0.85 / 0.15` (about 5.7× the overhead).\n   */\n  efficiency?: number;\n  /** No chunk is shorter than this many frames. Default 60. */\n  minChunkFrames?: number;\n}\ninterface PlannedChunk {\n  /** First frame (inclusive). */\n  start: number;\n  /** Last frame (exclusive). */\n  end: number;\n  /** Estimated render time of its frames, in seconds. */\n  workSec: number;\n}\ninterface ChunkPlan {\n  workers: number;\n  /** Estimated render time of the whole composition on one worker, without overhead. */\n  workSec: number;\n  /** Estimated wall time with this plan: overhead plus the longest chunk. */\n  etaSec: number;\n  chunks: PlannedChunk[];\n}\ndeclare function planChunks(options: ChunkPlanOptions): ChunkPlan;\n//#endregion\n//#region src/dma-staging-ring.d.ts\ntype StagingSlotStatus = \"idle\" | \"rendering\" | \"mapping\" | \"mapped\";\ninterface VideoColorSpaceConfig {\n  readonly primaries?: VideoColorPrimaries;\n  readonly transfer?: VideoTransferCharacteristics;\n  readonly matrix?: VideoMatrixCoefficients;\n  readonly fullRange?: boolean;\n}\ninterface DmaStagingRingOptions {\n  readonly width: number;\n  readonly height: number;\n  readonly capacity?: number;\n  readonly format?: GPUTextureFormat;\n}\ninterface StagingSlotInfo {\n  readonly index: number;\n  readonly status: StagingSlotStatus;\n  readonly inFlightFrame: number | null;\n}\n/**\n * Pipelined Asynchronous DMA Staging Ring for WebGPU.\n *\n * Implements double-buffered (or N-buffered) GPU staging buffers to overlap\n * GPU render passes with asynchronous DMA host transfers and WebCodecs hardware encoding.\n * Eliminates GPU stalls by allowing Frame i+1 to execute on the GPU while Frame i\n * is asynchronously mapped and consumed by the hardware video encoder.\n */\ndeclare class DmaStagingRing {\n  readonly width: number;\n  readonly height: number;\n  readonly capacity: number;\n  readonly bytesPerRow: number;\n  readonly unpaddedBytesPerRow: number;\n  readonly bufferSize: number;\n  readonly format: GPUTextureFormat;\n  readonly device: GPUDevice;\n  private readonly slots;\n  private isDestroyed;\n  constructor(device: GPUDevice, options: DmaStagingRingOptions);\n  /**\n   * Prepares the staging buffer slot for writing by ensuring any prior mapping\n   * from a previous cycle has been completed and unmapped.\n   */\n  prepareSlot(frameIndex: number): Promise<void>;\n  /**\n   * Records a GPU-to-buffer DMA copy command into the provided command encoder.\n   */\n  stageTexture(encoder: GPUCommandEncoder, texture: GPUTexture, frameIndex: number): void;\n  /**\n   * Initiates asynchronous DMA mapping on the slot for the specified frame.\n   * Must be called immediately after submitting the command encoder to the device queue.\n   */\n  scheduleMap(frameIndex: number): Promise<void>;\n  /**\n   * Awaits asynchronous mapping and extracts pixels into a tightly packed Uint8Array.\n   * The slot remains in the \"mapped\" state until releaseFrame() is called.\n   */\n  readFramePixels(frameIndex: number): Promise<Uint8Array>;\n  /**\n   * Awaits asynchronous mapping, extracts pixels, and immediately unmaps the staging buffer,\n   * returning the slot to \"idle\" state so it can be reused immediately.\n   */\n  readAndReleaseFrame(frameIndex: number): Promise<Uint8Array>;\n  /**\n   * Directly reads the mapped staging buffer into a WebCodecs VideoFrame,\n   * bypassing redundant intermediate JS allocations when row pitches align,\n   * and immediately unmaps the buffer.\n   */\n  readFrameToVideoFrame(frameIndex: number, timestampUs: number, colorSpace?: VideoColorSpaceConfig, /** Sees the tightly packed RGBA pixels while they are mapped; must not keep them. */\n  inspect?: (rgba: Uint8Array) => void): Promise<VideoFrame>;\n  /**\n   * Unmaps the staging buffer for the specified frame and marks the slot idle.\n   */\n  releaseFrame(frameIndex: number): void;\n  /**\n   * Returns current status info for each slot in the ring.\n   */\n  getSlotInfos(): readonly StagingSlotInfo[];\n  /**\n   * Destroys all staging buffers and releases resources.\n   */\n  destroy(): void;\n  private checkDestroyed;\n}\n//#endregion\n//#region src/dynamic-node-discovery.d.ts\n/** Locates the workspace `nodes/` directory by climbing up from this file. */\ndeclare function findNodesDir(startDir?: string): string | null;\n/**\n * Registers the built-in node renderers, then any extra nodes found in the\n * directory named by `FRAMEFIELDS_NODES_DIR` (local node development). A node in\n * that directory overrides the built-in renderer for the same op.\n */\ndeclare function discoverAndRegisterNodeRenderers(): Promise<void>;\n//#endregion\n//#region src/render-reporter.d.ts\n/**\n * Stages of `renderVideo`, in order. Audio-only renders skip \"render\";\n * \"convert\" runs only for GIF output.\n */\ntype RenderPhase = \"prepare\" | \"render\" | \"audio\" | \"audio-encode\" | \"mux\" | \"convert\" | \"done\";\n/** Progress reported by `renderVideo({ onProgress })`. */\ninterface RenderProgress {\n  /**\n   * \"prepare\" loads fonts and warms the pipeline, \"render\" draws and encodes\n   * frames, \"audio\" mixes the soundtrack, \"audio-encode\" encodes it, \"mux\"\n   * writes the container, \"convert\" makes the GIF, \"done\" is the last event.\n   */\n  phase: RenderPhase;\n  /** Frames finished so far (1-based); `totalFrames` once frames are done. */\n  frame: number;\n  totalFrames: number;\n  /** Time since the render started. */\n  elapsedMs: number;\n  /** Share of the current phase done (0–1), when it can be measured. */\n  phaseProgress?: number;\n  /** Frames per second so far (\"render\" only). */\n  fps?: number;\n  /** Estimated seconds until the frames are done (\"render\" only). */\n  etaSec?: number;\n  /** What the phase is working on, e.g. \"3/7 sources: music.mp3\". */\n  detail?: string;\n}\n//#endregion\n//#region src/video-qa.d.ts\n/**\n * Quality checks run on a video while it renders: frames are measured as\n * they are read back for the encoder and audio as it is mixed, so the report\n * describes exactly what was encoded without decoding the file again.\n */\ninterface VideoQaOptions {\n  /** Luma (0-1) at or below which a pixel counts as black. Default 0.1. */\n  readonly blackPixelThreshold?: number;\n  /** Share of black pixels that makes a frame black. Default 0.98. */\n  readonly blackFrameRatio?: number;\n  /** Shortest run of black frames reported. Default 0.5 s. */\n  readonly minBlackSec?: number;\n  /** Shortest run of unchanging frames reported. Default 2 s. */\n  readonly minFrozenSec?: number;\n  /** Level (dBFS, 100 ms windows) below which audio counts as silent. Default -60. */\n  readonly silenceDbfs?: number;\n  /** Shortest silent stretch reported. Default 2 s. */\n  readonly minSilenceSec?: number;\n  /** Integrated loudness to hit, e.g. -14 for most streaming platforms. Unchecked when unset. */\n  readonly targetLufs?: number;\n  /** Allowed distance from `targetLufs`, in LU. Default 1. */\n  readonly lufsTolerance?: number;\n}\ninterface QaSegment {\n  readonly startSec: number;\n  readonly endSec: number;\n}\ninterface QaIssue {\n  readonly severity: \"error\" | \"warning\" | \"info\";\n  /** Stable machine-readable kind, e.g. \"black_frames\", \"audio_clipping\" */\n  readonly code: string;\n  readonly message: string;\n  readonly startSec?: number;\n  readonly endSec?: number;\n  readonly layerId?: string;\n}\ninterface VideoQaStats {\n  readonly expectedFrames: number;\n  readonly encodedFrames: number;\n  readonly fps: number;\n  readonly width: number;\n  readonly height: number;\n  /** Average luma over the whole video, 0-1 */\n  readonly meanLuma: number;\n  readonly blackSegments: readonly QaSegment[];\n  readonly frozenSegments: readonly QaSegment[];\n}\ninterface AudioQaStats {\n  readonly sampleRate: number;\n  readonly channels: number;\n  readonly durationSec: number;\n  /** Highest sample, dBFS (sample peak, not true peak) */\n  readonly peakDbfs: number;\n  /** Mean level over the whole track, dBFS */\n  readonly rmsDbfs: number;\n  /** ITU-R BS.1770 integrated loudness; null when the track is silent */\n  readonly integratedLufs: number | null;\n  /** Samples at or beyond full scale */\n  readonly clippedSamples: number;\n  readonly silentSegments: readonly QaSegment[];\n}\ninterface VideoQaReport {\n  /** No errors or warnings (info issues do not fail a render) */\n  readonly passed: boolean;\n  readonly video?: VideoQaStats;\n  readonly audio?: AudioQaStats;\n  readonly issues: readonly QaIssue[];\n}\n/** Measures frames handed to it in order, as RGBA bytes. */\ndeclare class FrameInspector {\n  private readonly blackLuma;\n  private readonly blackRatio;\n  private readonly black;\n  private readonly sameAsPrevious;\n  private lumaSum;\n  private previous;\n  constructor(options?: VideoQaOptions);\n  get frameCount(): number;\n  inspect(rgba: Uint8Array, width: number, height: number): void;\n  stats(expectedFrames: number, encodedFrames: number, fps: number, width: number, height: number, options?: VideoQaOptions): VideoQaStats;\n}\n/** Measures a mixed audio track (one Float32Array per channel). */\ndeclare function analyzeAudio(channels: readonly Float32Array[], sampleRate: number, options?: VideoQaOptions): AudioQaStats;\n/**\n * ITU-R BS.1770-4 integrated loudness (LUFS): K-weighted mean square in\n * 400 ms blocks with 75% overlap, gated at -70 LUFS and then at 10 LU below\n * the mean of what passed. Channels weigh 1 (stereo and mono layouts).\n */\ndeclare function integratedLoudness(channels: readonly Float32Array[], sampleRate: number): number | null;\n/** Turn measurements and document diagnostics into a report with issues. */\ndeclare function buildQaReport(parts: {\n  video?: VideoQaStats;\n  audio?: AudioQaStats;\n  diagnostics?: readonly RenderDiagnostic[];\n  options?: VideoQaOptions;\n}): VideoQaReport;\n/** A short human- and agent-readable summary of a report. */\ndeclare function formatQaReport(report: VideoQaReport): string;\n//#endregion\n//#region src/headless-webgpu-renderer.d.ts\ndeclare class RenderSemaphore {\n  private _running;\n  private readonly _max;\n  private readonly _queue;\n  constructor(max: number);\n  acquire(timeoutMs?: number): Promise<void>;\n  release(): void;\n  get stats(): {\n    active: number;\n    queued: number;\n    max: number;\n  };\n}\ndeclare const renderSemaphore: RenderSemaphore;\n/** Composition frames `start` (inclusive) to `end` (exclusive). */\ninterface FrameRange {\n  start: number;\n  end: number;\n}\ndeclare class HeadlessWebGPURenderer {\n  private static isInitialized;\n  private static initPromise;\n  private static initFailureCount;\n  private static readonly MAX_INIT_FAILURES;\n  private static nextRetryAt;\n  static initialize(): Promise<void>;\n  renderImage(virtualMedia: VirtualMediaData, frame?: number, fps?: number, options?: {\n    renderId?: string;\n    /** \"rgba\" skips PNG encoding and returns width*height*4 raw pixels. */\n    format?: \"png\" | \"rgba\";\n  }): Promise<Buffer>;\n  /**\n   * Renders a single frame to a PNG buffer at a specified timestamp in milliseconds or frame index.\n   */\n  renderFrame(source: VirtualMediaData | {\n    toVirtualMedia(): VirtualMediaData;\n  }, options?: {\n    atMs?: number;\n    frame?: number;\n    fps?: number;\n    /** Reuse compiled state across calls; see `renderImage`. */\n    renderId?: string;\n    /** \"rgba\" returns raw width*height*4 pixels instead of a PNG. */\n    format?: \"png\" | \"rgba\";\n  }): Promise<Buffer>;\n  /**\n   * Measures what frames cost to render across the timeline, for planning a\n   * split render (`planChunks`). At `samples` evenly spaced points (default\n   * 12) it renders three consecutive frames and times the last two, so\n   * effects that carry state (trails, particles) are caught up and their\n   * replay is not counted. Encoding is not included.\n   */\n  probeRender(source: VirtualMediaData | {\n    toVirtualMedia(): VirtualMediaData;\n  }, options?: {\n    samples?: number;\n    signal?: AbortSignal;\n    /** Called after each sample point with how many are done. */\n    onSample?: (done: number, total: number) => void;\n  }): Promise<{\n    totalFrames: number;\n    fps: number;\n    durationMs: number;\n    samples: FrameCostSample[];\n  }>;\n  /**\n   * Mixes the composition's full audio timeline (clips, effects, synthesized\n   * tracks) to stereo PCM, exactly as `renderVideo` muxes it.\n   */\n  /**\n   * Mixes the timeline's audio. `window` mixes only that stretch (the same\n   * samples as that part of a full mix); `master: false` skips the master\n   * stage, for callers that master with the whole film's `peak` later.\n   */\n  renderAudio(virtualMedia: VirtualMediaData, options?: {\n    fps?: number;\n    sampleRate?: number;\n    window?: {\n      startSec: number;\n      endSec: number;\n    };\n    master?: boolean;\n  }): Promise<AudioMix>;\n  renderLut(virtualMedia: VirtualMediaData, frame?: number, fps?: number): Promise<Buffer>;\n  private resolveMediaDuration;\n  renderVideo(virtualMedia: VirtualMediaData, options?: {\n    codec?: string;\n    audioCodec?: string;\n    quality?: string;\n    concurrency?: number;\n    /**\n     * Depth of the DMA staging ring (default 2, clamped 2–8). A deeper\n     * ring overlaps more encoder latency at the cost of VRAM\n     * (~8.3MB/slot at 1080p RGBA). Also settable via\n     * `FRAMEFIELDS_RING_CAPACITY`.\n     */\n    ringCapacity?: number;\n    /**\n     * Measure the output while it renders (black and frozen frames,\n     * dropped frames, loudness, clipping, silence, document warnings)\n     * and return the findings as `qa`. `true` uses default thresholds.\n     */\n    qa?: boolean | VideoQaOptions;\n    /**\n     * Aborts the render between frames; the promise rejects with\n     * `signal.reason` and the partial output is deleted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Called as the render moves through its phases: \"prepare\", each\n     * frame (\"render\"), \"audio\" (mixing, per clip), \"audio-encode\",\n     * \"mux\", \"convert\" (GIF only) and \"done\".\n     */\n    onProgress?: (progress: RenderProgress) => void;\n    /**\n     * Renders only composition frames `start` (inclusive) to `end`\n     * (exclusive), as one chunk of a render split across workers. The\n     * chunk's timestamps start at 0 and its first frame is a keyframe,\n     * so `stitchChunks` joins chunks without re-encoding. Effects that\n     * carry state between frames rebuild it before `start`.\n     */\n    frames?: FrameRange;\n    /**\n     * `false` writes no audio track, as for chunks: the timeline's audio\n     * is exported once with `codec: \"aac\"` and added by `stitchChunks`.\n     */\n    audio?: boolean;\n  }): Promise<{\n    filePath: string;\n    cleanup: () => Promise<void>;\n    qa?: VideoQaReport;\n  }>;\n}\ndeclare const HeadlessMediaRenderer: typeof HeadlessWebGPURenderer;\ntype HeadlessMediaRenderer = HeadlessWebGPURenderer;\n//#endregion\n//#region src/job-reset.d.ts\n/**\n * Drops every cache keyed by a file path or URL: media inputs and decoders,\n * textures, LUTs, fonts and downloaded font files. A long-lived worker calls this between jobs,\n * because the next checkout may hold different bytes at the same path. The\n * GPU device and compiled pipelines stay warm.\n */\ndeclare function resetRenderCaches(): void;\n//#endregion\n//#region src/logger.d.ts\n/**\n * \"json\" (pino lines, for log collectors) or \"text\" (one short line each, for\n * people and agents reading a terminal). `FRAMEFIELDS_LOG_FORMAT` picks one;\n * otherwise production is JSON and everything else text.\n */\ndeclare function resolveLogFormat(vars?: Record<string, string | undefined> | undefined): \"json\" | \"text\";\n/**\n * Turns pino's JSON lines into `[framefields] Rendered 40% (…)`: the message\n * without its `[Component]` prefix, the level only for warnings and errors,\n * and an error's message (its stack reaches the caller with the throw).\n */\ndeclare function textLogStream(write?: (line: string) => void): DestinationStream;\ndeclare const rendererLogger: pino.Logger<never, boolean>;\n//#endregion\n//#region src/node-manifest.d.ts\n/**\n * The `framefields` block of a node package's `package.json`.\n *\n * This is the single declaration of a node's op: renderer discovery, the\n * effects generator (`scripts/generate-effects.ts`) and the skill catalog all\n * read it from here. There is deliberately no fallback that derives an op from\n * the package name. See `spec/sync-node.md` §5.1.\n */\ndeclare const NODE_KINDS: readonly [\"effect\", \"audio\", \"source\", \"signal\", \"utility\"];\ntype NodeKind = (typeof NODE_KINDS)[number];\ninterface NodeRendererExports {\n  development?: string;\n  import?: string;\n  default?: string;\n}\ninterface NodeManifest {\n  /** Directory name under `nodes/`, e.g. `node-apply-lut`. */\n  dir: string;\n  /** Absolute path of the node package. */\n  path: string;\n  /** npm package name, e.g. `@framefields/node-lut`. */\n  packageName: string;\n  /** Canonical op literal used in the operation AST and the renderer registry. */\n  type: string;\n  kind: NodeKind;\n  /** Legacy ops that resolve to the same renderer. */\n  aliases: readonly string[];\n  /** Named zod schema export of `src/shared/config.ts`. */\n  schema?: string;\n  /** Authoring class name. Defaults to `type`. */\n  className?: string;\n  /** Key on `Effect.*`. Defaults to `className` with a lower-cased first letter. */\n  factory?: string;\n  /** A hand-written subclass exists under `effects/custom/`. */\n  custom: boolean;\n  /** `false` when the package opts out of discovery. */\n  enabled: boolean;\n  rendererExports?: NodeRendererExports;\n}\ndeclare class NodeManifestError extends Error {\n  readonly problems: readonly string[];\n  constructor(problems: readonly string[]);\n}\n/**\n * Validates one parsed `package.json`. Returns the manifest, or the list of\n * problems that make it unusable. Never throws.\n */\ndeclare function parseNodeManifest(pkg: unknown, dir: string, nodePath?: string): {\n  manifest?: NodeManifest;\n  problems: string[];\n};\n/**\n * Reads every `nodes/node-*` package and returns its manifest, sorted by\n * directory name. Throws a single {@link NodeManifestError} listing every\n * problem: a missing or malformed block, or an op/alias claimed twice.\n */\ndeclare function loadNodeManifests(nodesDir: string): NodeManifest[];\n//#endregion\n//#region src/stitch.d.ts\ninterface StitchOptions {\n  /** Chunk files in timeline order, each a `renderVideo({ frames, audio: false })` output. */\n  chunks: readonly string[];\n  /**\n   * An audio-only render of the whole timeline (`renderVideo({ codec: \"aac\" })`,\n   * or `\"opus\"` for WebM chunks), copied in as the audio track.\n   */\n  audio?: string;\n  outputPath: string;\n  /** Stops between packets; the promise rejects and no file is left behind. */\n  signal?: AbortSignal;\n}\ninterface StitchResult {\n  filePath: string;\n  /** Video frames written, across all chunks. */\n  frames: number;\n  /** End of the video track, in seconds. */\n  durationSec: number;\n}\ndeclare function stitchChunks(options: StitchOptions): Promise<StitchResult>;\n//#endregion\n//#region src/zero-copy-webcodecs-pipeline.d.ts\ninterface ZeroCopyWebCodecsPipelineOptions {\n  readonly width: number;\n  readonly height: number;\n  readonly fps: number;\n  readonly videoSource: VideoSampleSource;\n  readonly ringCapacity?: number;\n  readonly colorSpace?: VideoColorSpaceConfig;\n  readonly directCanvasSource?: unknown;\n  /**\n   * Called with each frame's RGBA pixels, in frame order, just before it is\n   * encoded (staging-ring path only). The buffer is reused: read, don't keep.\n   */\n  readonly onFrame?: (rgba: Uint8Array, frameIndex: number) => void;\n}\ninterface WebCodecsPipelineStats {\n  readonly totalFramesEnqueued: number;\n  readonly totalFramesEncoded: number;\n  readonly averageGpuSubmitTimeMs: number;\n  readonly averageEncodeTimeMs: number;\n  readonly averageCycleTimeMs: number;\n  readonly maxCycleTimeMs: number;\n  readonly minCycleTimeMs: number;\n  readonly throughputFps: number;\n  readonly ringCapacity: number;\n  readonly isDirectZeroCopy: boolean;\n}\n/**\n * High-performance hardware video encoding pipeline integrating WebGPU textures with WebCodecs.\n *\n * Provides:\n * 1. Direct hardware acceleration when running with WebCodecs / OffscreenCanvas.\n * 2. Pipelined asynchronous double-buffered DMA staging ring for headless Node.js (Dawn native),\n *    allowing GPU Frame i+1 rendering to overlap concurrently with Frame i hardware encoding.\n */\ndeclare class ZeroCopyWebCodecsPipeline {\n  readonly width: number;\n  readonly height: number;\n  readonly fps: number;\n  readonly ringCapacity: number;\n  private readonly device;\n  private readonly videoSource;\n  private readonly stagingRing;\n  private readonly colorSpace?;\n  private readonly directCanvasSource?;\n  private readonly onFrame?;\n  private readonly inFlightFrames;\n  private readonly cycleStartTimes;\n  private totalFramesEnqueued;\n  private totalFramesEncoded;\n  private totalGpuSubmitTimeMs;\n  private totalEncodeTimeMs;\n  private totalCycleTimeMs;\n  private maxCycleTimeMs;\n  private minCycleTimeMs;\n  private pipelineStartTime;\n  constructor(device: GPUDevice, options: ZeroCopyWebCodecsPipelineOptions);\n  /**\n   * Returns true if direct zero-copy from an OffscreenCanvas or texture is active.\n   */\n  canDirectZeroCopy(): boolean;\n  /**\n   * Enqueues a rendered GPU texture frame into the pipeline.\n   *\n   * Uses double-buffered DMA staging: if the staging ring has reached capacity,\n   * the oldest in-flight frame is asynchronously consumed and added to the video encoder\n   * before staging the new frame, guaranteeing constant bounded VRAM usage and zero GPU stalls.\n   */\n  enqueueFrame(frameIndex: number, targetTexture: GPUTexture, encoder: GPUCommandEncoder): Promise<void>;\n  /**\n   * Drains all remaining in-flight frames in the pipeline, ensuring every enqueued\n   * frame has been encoded and added to the video sample source.\n   */\n  drain(): Promise<void>;\n  /**\n   * Returns runtime throughput, latency, and pipeline statistics.\n   */\n  getStats(): WebCodecsPipelineStats;\n  /**\n   * Destroys the pipeline and releases all staging buffers.\n   */\n  destroy(): void;\n  private consumeAndEncode;\n}\n//#endregion\nexport { AudioQaStats, ChunkPlan, ChunkPlanOptions, DmaStagingRing, DmaStagingRingOptions, FrameCostSample, FrameInspector, FrameRange, HeadlessMediaRenderer, HeadlessWebGPURenderer, NODE_KINDS, NodeKind, NodeManifest, NodeManifestError, NodeRendererExports, PlannedChunk, QaIssue, QaSegment, type RenderPhase, type RenderProgress, StagingSlotInfo, StagingSlotStatus, StitchOptions, StitchResult, VideoColorSpaceConfig, VideoQaOptions, VideoQaReport, VideoQaStats, WebCodecsPipelineStats, ZeroCopyWebCodecsPipeline, ZeroCopyWebCodecsPipelineOptions, analyzeAudio, buildQaReport, discoverAndRegisterNodeRenderers, findNodesDir, formatQaReport, integratedLoudness, loadNodeManifests, parseNodeManifest, planChunks, preloadFonts, renderSemaphore, rendererLogger, resetRenderCaches, resolveLogFormat, stitchChunks, textLogStream };\n//# sourceMappingURL=index.d.mts.map"],"mappings":";;;;;;;;AAmLoB;AAsBI;AAkBL;AAIF;AAkB4B;AAcA;;;;;AAoC5B;AAEoC;AAQf;AAQQ;AAE1B;UA1RVa,eAAAA,CAoSaD;EACKJ,KAAAA,EAAAA,MAAAA;EAIduC,EAAAA,EAAAA,MAAAA;;UArSJjC,gBAAAA,CAySYN;EACAA;EASRuC,WAAAA,EAAAA,MAAAA;EAARnC;EAQgBJ,OAAAA,EAAAA,SAvTFK,eAuTEL,EAAAA;EACAA;EAGTwC,OAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAOAnC;EAJPD,UAAAA,CAAAA,EAAAA,MAAAA;EAesBJ;EAQdF,WAAAA,CAAAA,EAAAA,MAAAA;EAARM;;;;;EAoBamB,UAAAA,CAAAA,EAAAA,MAAAA;EAKNiB;EAMelB,cAAAA,CAAAA,EAAAA,MAAAA;;UApWlBf,YAAAA,CAoXSH;EACVwB;EAHHxB,KAAAA,EAAAA,MAAAA;EAAO;EAAA,GAMCqC,EAAAA,MAAAA;EAAoD;EACf,OASlCC,EAAAA,MAAAA;AA0EiD;AAa5C,UAjdZlC,SAAAA,CAmdY;EAAA,OAOLkD,EAAAA,MAAAA;EAAsBF;EAAwBC,OAAAA,EAAAA,MAAAA;EAARrD;EAAO,MAAA,EAAA,MAAA;UApdpDG;;iBAEOE,UAAAA,UAAoBH,mBAAmBE;AC3DxD;AAMA;;;;;;;;KD2JKa,WAAAA;;UAEKC,cAAAA;;;;;;SAMDD;;;;;;;;;;;;;;;;;;;;;;UAsBCE,cAAAA;;;;;;;;;;;;;;;;;;UAkBAC,SAAAA;;;;UAIAC,OAAAA;;;;;;;;;UASAC,YAAAA;;;;;;;;mCAQyBF;oCACCA;;UAE1BG,YAAAA;;;;;;;;;;;;oCAY0BH;;UAE1BI,aAAAA;;;mBAGSF;mBACAC;4BACSF;;;;;iBA+BXS,cAAAA,SAAuBN;;;cAG1BO,eAAAA;;;;;+BAKiB/B;;;;;;;;cAQjBgC,iBAAiBD;;UAErBE,UAAAA;;;;cAIIC,sBAAAA;;;;;;uBAMSlC;4BACKJ;;;;MAItBI,QAAQmC;;;;sBAIQvC;sBACAA;;;;;;;;;MAShBI,QAAQmC;;;;;;;;sBAQQvC;sBACAA;;;aAGTwC;;;MAGPpC;;;;aAIOC;;;;;;;;;;;4BAWeL;;;;;;;;MAQtBI,QAAQN;0BACYE,iDAAiDI,QAAQmC;;4BAEvDvC;;;;;;;;;;;;;;;;;mBAiBTuB;;;;;aAKNiB;;;;;;4BAMelB;;;;;;;;aAQfe;;;;;;MAMPjC;;mBAEaA;SACVwB;;;cAGKa,8BAA8BH;KACvCG,qBAAAA,GAAwBH;;;;;;;;;iBASZI,iBAAAA,CAAAA;;;;;;;;;;;UA6EPc,aAAAA;;;;;;;;;;WAUChB;;UAEDiB,YAAAA;;;;;;;iBAOOC,YAAAA,UAAsBF,gBAAgBpD,QAAQqD;;;;;UC7gB9C,gBAAA;;;;;ADmBPpD,UCbO,gBAAA,CDaQ;EAIfC;AAIyB;AAgBb;EAgBLG,UAAAA,CAAAA,EAAU,MAAA;EAsGtBY;AAAW;AAQI;EAwCVG,QAAAA,CAAAA,EAAAA,MAAS;EAITC;AAAO;AAkB4B;EAgBnCG,UAAAA,CAAAA,EAAAA,MAAa;EAGJF;;;EAEgB,MAAA,CAAA,EAAA,MAAA,EAAA;EA+BlBQ;AAAoC;AAQf;EAU5BG,OAAAA,CAAAA,EAAAA,MAAU;EAINC;;;EAWAC,KAAAA,CAAAA,EAAAA,MAAAA;EAARnC;;;EAcQmC,MAAAA,CAAAA,EAAAA,MAAAA;EAARnC;;;EAYOoC,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAOAnC;;;;EAmBPD,GAAAA,CAAAA,EAAAA,MAAAA;EACoBJ;;;EAEEA,OAAAA,CAAAA,EAAAA,MAAAA;EAiBTuB;;;;EA2BAnB,SAAAA,CAAAA,EAAAA,MAAAA;EACVwB;;;EAGKa,UAAAA,CAAAA,EAAAA,MAAAA;EACTA;AAA8C;AAmFe;EAexDgB,GAAAA,CAAAA,EAAAA,MAAAA;EAOOC;;;EAAsCtD,OAAAA,CAAAA,EAAAA,MAAAA;EAAO;;;;EC7gB7C;AAMjB;AA+KA;EA4DgB,UAAA,CAAA,EAAA,OAAiB;EAiFrB;;;EAOC,UAAA,CAAA,EAAA,OAAA;EAAR;;AAWL;EACS,UAAA,CAAA,EAAA,MAAA;EACC;;;EACA,UAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;aA5NE;;;iBA0DI,mBAAA,UACN;WAGI;;;;;;iBAwDE,iBAAA,mDAGN;;;;;;;;;;;KA8EE,mBAAA;oBACO;;;;;eAKN;MACR,QAAQ;;;;;;;;;;iBAWS,eAAA,SACb,+BACC,mBACP,QAAQ"}

package/dist/{index-COYNQ_mf.d.mts → index-a6JrbAK0.d.mts}

@@ -2399,4 +2399,4 @@ declare function findSourceAsset(vm: VirtualMediaData): FileData | null;
 //#endregion
 //#endregion
 export { FrameSignal as $, TransitionSchema as $n, isFrameIndex as $r, NormalRelightingOptions as $t, DataTypeVal as A, sampleColorStops as Ai, SignalMathData as An, deserializeSignalData as Ar, MediaTimeRemapInputSchema as At, EmojiPresentation as B, stampResult as Bi, TEXT_LAYER_DEFAULTS as Bn, generateId as Br, NodeId as Bt, DATA_TYPE_EXTENSIONS as C, resolveBoolean as Ci, SignalChannelMeta as Cn, computeVideoCropRenderProps as Cr, MediaSignalRecorder as Ct, DataForType as D, resolveParam as Di, SignalDataSchema as Dn, createVirtualMedia as Dr, MediaSourceSchema as Dt, DEFAULT_MEDIA_DIMENSION as E, resolveNumber as Ei, SignalData as En, createOutputItemSchema as Er, MediaSourceRange as Et, DetectedObject as F, seconds as Fi, SineSignalOptions as Fn, fps as Fr, Milliseconds as Ft, FaceLandmarksOptions as G, TensorPipelineConfig as Gn, getMediaType as Gr, NodeProcessorContext as Gt, ExportResultSchema as H, timeSignal as Hi, TensorDimensions as Hn, getFileDataMetadata as Hr, NodeMetadata as Ht, Effect as I, serializeSignalData as Ii, SingleOutputGeneric as In, frame as Ir, ModerationError as It, FileData as J, TextSpanMark as Jn, handleId as Jr, NodeResultSchema as Jt, FileAsset as K, TextOperationSchema as Kn, getRenderFingerprint as Kr, NodeProcessorParams as Kt, EffectConfig as L, signal as Li, SingleOutputGenericSchema as Ln, frameArraySignal as Lr, ModerationUnrefundableError as Lt, DeflickerOptions as M, sampleMediaSignal as Mi, SignalStats as Mn, extractSvgDimensions as Mr, MediaTimeSignalRemap as Mt, Degrees as N, sampledMediaSourceRange as Ni, SignalStatsSchema as Nn, findSourceAsset as Nr, MediaTimeSignalRemapSchema as Nt, DataType as O, resolveString as Oi, SignalGateData as On, dataTypeColors as Or, MediaTimeRemap as Ot, DepthNormalsOptions as P, sampledMediaSourceTime as Pi, SignalValue as Pn, formatHex as Pr, MeshAudioDeformConfig as Pt, FrameIndex as Q, TrackedObject as Qn, isEqual as Qr, NodeVisualConfigSchema as Qt, EffectConfigValue as R, signalBuilder as Ri, SourceOperationSchema as Rn, frameCount as Rr, MultiOutputGeneric as Rt, ControlNetConditioningOutputs as S, reportRenderDiagnostic as Si, SignalBuilderConfig as Sn, compositionFrameContext as Sr, MediaService as St, DEFAULT_FPS as T, resolveMediaMimeType as Ti, SignalContext as Tn, cosineSignal as Tr, MediaSourceInput as Tt, ExtendedLayer as U, updateClockSignals as Ui, TensorFormat as Un, getFingerprint as Ur, NodeMetadataSchema as Ut, ExportResult as V, takeRenderDiagnostics as Vi, TensorData as Vn, getActiveMediaMetadata as Vr, NodeInputConnection as Vt, ExtendedLayerSchema as W, validateMediaTimeRemap as Wi, TensorNode as Wn, getLeafMediaType as Wr, NodeOperation as Wt, Fps as X, TimelineTransform as Xn, hasOnlySingleSource as Xr, NodeValidationFn as Xt, FileDataSchema as Y, TimelineSegmentSchema as Yn, handleLabel as Yr, NodeRunFunction as Yt, FrameContext as Z, TimelineTransformSchema as Zn, isCssGradient as Zr, NodeVisualConfig as Zt, ColorStopLike as _, pixels as _i, Rgba as _n, XYPosition as _r, MIME_TYPES as _t, AudioExtractorSignalData as a, mediaSourceIsHold as ai, OutputItem as an, VideoLayerTypeSchema as ar, Gradient as at, ConfigSchemaRegistry as b, radians as bi, SegmentationOptions as bn, assertNever as br, MediaOperation as bt, BaseMediaOperationPropsSchema as c, mediaSourceTime as ci, ParsedGradientStop as cn, VideoTextPropsSchema as cr, HandleLabel as ct, Brand as d, nodeId as di, ProgrammaticSignal as dn, VirtualMediaDataSchema as dr, JsonArray as dt, isNormalized as ei, Normalized as en, TransitionType as er, GPUTextureBinding as et, CAPTION_LAYER_DEFAULTS as f, normalizeColorStops as fi, ProgrammaticSignalOptions as fn, VisionConfig as fr, JsonObject as ft, Color as g, parseCssGradient as gi, ResolvedMediaTimeRemap as gn, WritableSignal as gr, MAX_GRADIENT_STOPS as gt, CannyOptions as h, parseCssColor as hi, RenderDiagnostic as hn, VisionVariant as hr, Landmark3D as ht, AnyOutputUnionSchema as i, limitGradientStops as ii, Output as in, VideoLayerType as ir, GlobalCompositeOperation as it, DataTypes as j, sampleFrameMediaSignal as ji, SignalMathDataSchema as jn, emojiPresentation as jr, MediaTimeRemapSchema as jt, DataTypeEnum as k, rgbToOklab as ki, SignalGateDataSchema as kn, degrees as kr, MediaTimeRemapInput as kt, BaseVideoLayerProps as l, mixColors as li, Pixels as ln, VideoTimingPropsSchema as lr, HandleType as lt, COMPOSITOR_DEFAULTS as m, oklabToRgb as mi, Radians as mn, VisionTask as mr, JsonValueSchema as mt, AnimationTypeSchema as n, isValueSignal as ni, ObjectBoundingBox as nn, VideoAnimation as nr, GeneratorSignalData as nt, AudioExtractorSignalDataSchema as o, mediaSourceRange as oi, OutputItemSchema as on, VideoSpatialPropsSchema as or, GradientType as ot, COMPOSITE_OPERATIONS as p, normalized as pi, RadialExtent as pn, VisionNodeSpec as pr, JsonValue as pt, FileAssetSchema as q, TextSpan as qn, gradientStopsToOklab as qr, NodeResult as qt, AnyOutputUnion as r, isVirtualMediaData as ri, OpticalFlowOptions as rn, VideoAnimationSchema as rr, GeneratorSignalDataSchema as rt, BaseMediaOperationProps as s, mediaSourceRate as si, ParsedGradient as sn, VideoStylePropsSchema as sr, HandleId as st, AnimationType as t, isSignal as ti, NormalizedLandmarkList as tn, TransitionTypeSchema as tr, GateSignalOptions as tt, BaseVideoLayerPropsSchema as u, ms as ui, PoseSkeletonOptions as un, VirtualMediaData as ur, HandleTypeVal as ut, ConfigHandle as v, programmaticSignal as vi, SampledMediaSignal as vn, appendOperation as vr, MediaMetadata as vt, DEFAULT_DURATION_MS as w, resolveFrameRequest as wi, SignalChannelMetaSchema as wn, computed as wr, MediaSourceDescriptor as wt, ConnectedInput as x, registerSignalDependency as xi, Signal as xn, checkNodeResultCache as xr, MediaOperationSchema as xt, ConfigHandleSchema as y, progressSignal as yi, Seconds as yn, assertFps as yr, MediaMetadataSchema as yt, EffectDomain as z, sineSignal as zi, StorageService as zn, frameSignal as zr, MultiOutputGenericSchema as zt };
-//# sourceMappingURL=index-COYNQ_mf.d.mts.map
+//# sourceMappingURL=index-a6JrbAK0.d.mts.map