@pneuma-craft/video 0.4.0

package/dist/index.cjs

@@ -0,0 +1,1339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createAudioScheduler: () => createAudioScheduler,
+  createCanvas2DCompositor: () => createCanvas2DCompositor,
+  createCompositor: () => createCompositor,
+  createExportEngine: () => createExportEngine,
+  createFrameRenderer: () => createFrameRenderer,
+  createGPUCompositor: () => createGPUCompositor,
+  createMasterClock: () => createMasterClock,
+  createMediaDecoder: () => createMediaDecoder,
+  createOfflineAudioRenderer: () => createOfflineAudioRenderer,
+  createPlaybackEngine: () => createPlaybackEngine
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/media-decoder.ts
+var import_mediabunny = require("mediabunny");
+async function decodeImageFitted(blob, width, height) {
+  const raw = await createImageBitmap(blob);
+  try {
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d", { alpha: true });
+    if (!ctx) throw new Error("Failed to get 2d context for image resize");
+    const scale = Math.min(width / raw.width, height / raw.height);
+    const drawW = raw.width * scale;
+    const drawH = raw.height * scale;
+    const dx = (width - drawW) / 2;
+    const dy = (height - drawH) / 2;
+    ctx.drawImage(raw, 0, 0, raw.width, raw.height, dx, dy, drawW, drawH);
+    return await createImageBitmap(canvas);
+  } finally {
+    raw.close();
+  }
+}
+function createMediaDecoder(resolver, audioContext) {
+  const cache = /* @__PURE__ */ new Map();
+  const initPromises = /* @__PURE__ */ new Map();
+  async function getOrCreateAsset(assetId) {
+    const existing = cache.get(assetId);
+    if (existing) return existing;
+    const pending = initPromises.get(assetId);
+    if (pending) return pending;
+    const promise = (async () => {
+      const blob = await resolver.fetchBlob(assetId);
+      const input = new import_mediabunny.Input({ source: new import_mediabunny.BlobSource(blob), formats: import_mediabunny.ALL_FORMATS });
+      const asset = { input, blob, videoSink: null, imageBitmap: null, audioBuffer: null, mediaInfo: null };
+      cache.set(assetId, asset);
+      initPromises.delete(assetId);
+      return asset;
+    })();
+    promise.catch(() => {
+      initPromises.delete(assetId);
+    });
+    initPromises.set(assetId, promise);
+    return promise;
+  }
+  return {
+    async decodeVideoFrame(assetId, time, width, height) {
+      const asset = await getOrCreateAsset(assetId);
+      if (asset.imageBitmap) return asset.imageBitmap;
+      if (!asset.videoSink) {
+        let videoTrack = null;
+        try {
+          videoTrack = await asset.input.getPrimaryVideoTrack();
+        } catch {
+        }
+        if (!videoTrack) {
+          try {
+            asset.imageBitmap = await decodeImageFitted(asset.blob, width, height);
+            return asset.imageBitmap;
+          } catch (err) {
+            throw new Error(
+              `Asset ${assetId} has no video track and is not a decodable image: ${err.message}`
+            );
+          }
+        }
+        asset.videoSink = new import_mediabunny.CanvasSink(videoTrack, {
+          width,
+          height,
+          fit: "contain",
+          poolSize: 5,
+          // Preserve source alpha — required for transparent videos (e.g. WebM
+          // with VP8/VP9 alpha, HEVC/AV1 with alpha). With `alpha: false`
+          // (mediabunny default) CanvasSink flattens transparent pixels to a
+          // black background, breaking compositing of alpha videos.
+          alpha: true
+        });
+      }
+      const result = await asset.videoSink.getCanvas(time);
+      if (!result) throw new Error(`Failed to decode frame at ${time}s for asset ${assetId}`);
+      return result.canvas;
+    },
+    async decodeAudio(assetId) {
+      const asset = await getOrCreateAsset(assetId);
+      if (asset.audioBuffer) return asset.audioBuffer;
+      try {
+        const arrayBuffer = await asset.blob.arrayBuffer();
+        const buffer = await audioContext.decodeAudioData(arrayBuffer.slice(0));
+        asset.audioBuffer = buffer;
+        return buffer;
+      } catch {
+      }
+      const audioTrack = await asset.input.getPrimaryAudioTrack();
+      if (!audioTrack) throw new Error(`No audio track in asset ${assetId}`);
+      const sink = new import_mediabunny.AudioBufferSink(audioTrack);
+      const chunks = [];
+      let totalFrames = 0;
+      let sampleRate = 0;
+      let numberOfChannels = 0;
+      for await (const wrapped of sink.buffers()) {
+        const buf = wrapped.buffer;
+        chunks.push(buf);
+        totalFrames += buf.length;
+        if (!sampleRate) sampleRate = buf.sampleRate;
+        if (!numberOfChannels) numberOfChannels = buf.numberOfChannels;
+      }
+      if (chunks.length === 0 || totalFrames === 0) {
+        throw new Error(`Failed to decode audio for asset ${assetId}`);
+      }
+      const merged = audioContext.createBuffer(numberOfChannels, totalFrames, sampleRate);
+      let offset = 0;
+      for (const chunk of chunks) {
+        for (let ch = 0; ch < numberOfChannels; ch++) {
+          const src = chunk.getChannelData(Math.min(ch, chunk.numberOfChannels - 1));
+          merged.copyToChannel(src, ch, offset);
+        }
+        offset += chunk.length;
+      }
+      asset.audioBuffer = merged;
+      return merged;
+    },
+    async getMediaInfo(assetId) {
+      const asset = await getOrCreateAsset(assetId);
+      if (asset.mediaInfo) return asset.mediaInfo;
+      const videoTrack = await asset.input.getPrimaryVideoTrack();
+      const audioTrack = await asset.input.getPrimaryAudioTrack();
+      const duration = await asset.input.computeDuration();
+      let fps = 0;
+      if (videoTrack) {
+        const stats = await videoTrack.computePacketStats(100);
+        fps = stats.averagePacketRate;
+      }
+      const info = {
+        duration,
+        width: videoTrack?.displayWidth ?? 0,
+        height: videoTrack?.displayHeight ?? 0,
+        fps,
+        hasVideo: videoTrack !== null,
+        hasAudio: audioTrack !== null,
+        videoCodec: videoTrack?.codec ?? null,
+        audioCodec: audioTrack?.codec ?? null,
+        sampleRate: audioTrack?.sampleRate ?? 0,
+        channels: audioTrack?.numberOfChannels ?? 0
+      };
+      asset.mediaInfo = info;
+      return info;
+    },
+    destroy() {
+      for (const asset of cache.values()) {
+        asset.input.dispose();
+        asset.imageBitmap?.close();
+      }
+      cache.clear();
+      initPromises.clear();
+    }
+  };
+}
+
+// src/canvas2d-compositor.ts
+function createCanvas2DCompositor(width, height) {
+  let canvas = new OffscreenCanvas(width, height);
+  let ctx = canvas.getContext("2d", { alpha: true });
+  let currentWidth = width;
+  let currentHeight = height;
+  return {
+    async composite(layers) {
+      ctx.clearRect(0, 0, currentWidth, currentHeight);
+      const sorted = [...layers].sort((a, b) => a.zIndex - b.zIndex);
+      for (const layer of sorted) {
+        if (layer.opacity <= 0) continue;
+        ctx.globalAlpha = layer.opacity;
+        ctx.drawImage(layer.source, 0, 0, currentWidth, currentHeight);
+      }
+      ctx.globalAlpha = 1;
+      return createImageBitmap(canvas);
+    },
+    resize(w, h) {
+      currentWidth = w;
+      currentHeight = h;
+      canvas = new OffscreenCanvas(w, h);
+      ctx = canvas.getContext("2d", { alpha: true });
+    },
+    destroy() {
+    }
+  };
+}
+
+// src/gpu-compositor.ts
+var VERTEX_SHADER = (
+  /* wgsl */
+  `
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) texCoord: vec2f,
+};
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  // Full-screen quad: 6 vertices, 2 triangles
+  var positions = array<vec2f, 6>(
+    vec2f(-1.0, -1.0),
+    vec2f( 1.0, -1.0),
+    vec2f(-1.0,  1.0),
+    vec2f(-1.0,  1.0),
+    vec2f( 1.0, -1.0),
+    vec2f( 1.0,  1.0),
+  );
+
+  var texCoords = array<vec2f, 6>(
+    vec2f(0.0, 1.0),
+    vec2f(1.0, 1.0),
+    vec2f(0.0, 0.0),
+    vec2f(0.0, 0.0),
+    vec2f(1.0, 1.0),
+    vec2f(1.0, 0.0),
+  );
+
+  var output: VertexOutput;
+  output.position = vec4f(positions[vertexIndex], 0.0, 1.0);
+  output.texCoord = texCoords[vertexIndex];
+  return output;
+}
+`
+);
+var FRAGMENT_SHADER = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var texSampler: sampler;
+@group(0) @binding(1) var texSource: texture_2d<f32>;
+@group(0) @binding(2) var<uniform> opacity: f32;
+
+@fragment
+fn main(@location(0) texCoord: vec2f) -> @location(0) vec4f {
+  var color = textureSample(texSource, texSampler, texCoord);
+  // Multiply alpha by uniform opacity
+  color.a = color.a * opacity;
+  // Premultiply RGB by the new alpha
+  color = vec4f(color.rgb * color.a, color.a);
+  return color;
+}
+`
+);
+async function createGPUCompositor(width, height) {
+  if (!navigator.gpu) {
+    throw new Error("WebGPU not available");
+  }
+  const adapter = await navigator.gpu.requestAdapter();
+  if (!adapter) {
+    throw new Error("Failed to get WebGPU adapter");
+  }
+  const device = await adapter.requestDevice();
+  const sampler = device.createSampler({
+    magFilter: "linear",
+    minFilter: "linear"
+  });
+  const opacityBuffer = device.createBuffer({
+    size: 16,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const bindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      { binding: 0, visibility: GPUShaderStage.FRAGMENT, sampler: {} },
+      { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: {} },
+      { binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } }
+    ]
+  });
+  const pipelineLayout = device.createPipelineLayout({
+    bindGroupLayouts: [bindGroupLayout]
+  });
+  const vertexModule = device.createShaderModule({ code: VERTEX_SHADER });
+  const fragmentModule = device.createShaderModule({ code: FRAGMENT_SHADER });
+  const pipeline = device.createRenderPipeline({
+    layout: pipelineLayout,
+    vertex: {
+      module: vertexModule,
+      entryPoint: "main"
+    },
+    fragment: {
+      module: fragmentModule,
+      entryPoint: "main",
+      targets: [{
+        format: "rgba8unorm",
+        blend: {
+          color: {
+            srcFactor: "one",
+            dstFactor: "one-minus-src-alpha",
+            operation: "add"
+          },
+          alpha: {
+            srcFactor: "one",
+            dstFactor: "one-minus-src-alpha",
+            operation: "add"
+          }
+        }
+      }]
+    },
+    primitive: {
+      topology: "triangle-list"
+    }
+  });
+  let currentWidth = width;
+  let currentHeight = height;
+  let outputTexture = createOutputTexture(device, width, height);
+  function createOutputTexture(dev, w, h) {
+    return dev.createTexture({
+      size: { width: w, height: h },
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING
+    });
+  }
+  return {
+    async composite(layers) {
+      const sorted = [...layers].filter((l) => l.opacity > 0).sort((a, b) => a.zIndex - b.zIndex);
+      const encoder = device.createCommandEncoder();
+      const outputView = outputTexture.createView();
+      const layerTextures = [];
+      if (sorted.length === 0) {
+        const pass = encoder.beginRenderPass({
+          colorAttachments: [{
+            view: outputView,
+            loadOp: "clear",
+            storeOp: "store",
+            clearValue: { r: 0, g: 0, b: 0, a: 0 }
+          }]
+        });
+        pass.end();
+      } else {
+        for (let i = 0; i < sorted.length; i++) {
+          const layer = sorted[i];
+          const layerTexture = device.createTexture({
+            size: { width: currentWidth, height: currentHeight },
+            format: "rgba8unorm",
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+          });
+          layerTextures.push(layerTexture);
+          device.queue.copyExternalImageToTexture(
+            { source: layer.source },
+            { texture: layerTexture },
+            { width: currentWidth, height: currentHeight }
+          );
+          const opacityData = new Float32Array([layer.opacity]);
+          device.queue.writeBuffer(opacityBuffer, 0, opacityData);
+          const bindGroup = device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [
+              { binding: 0, resource: sampler },
+              { binding: 1, resource: layerTexture.createView() },
+              { binding: 2, resource: { buffer: opacityBuffer } }
+            ]
+          });
+          const loadOp = i === 0 ? "clear" : "load";
+          const pass = encoder.beginRenderPass({
+            colorAttachments: [{
+              view: outputView,
+              loadOp,
+              storeOp: "store",
+              ...loadOp === "clear" ? { clearValue: { r: 0, g: 0, b: 0, a: 0 } } : {}
+            }]
+          });
+          pass.setPipeline(pipeline);
+          pass.setBindGroup(0, bindGroup);
+          pass.draw(6);
+          pass.end();
+        }
+      }
+      const bytesPerRow = Math.ceil(currentWidth * 4 / 256) * 256;
+      const bufferSize = bytesPerRow * currentHeight;
+      const stagingBuffer = device.createBuffer({
+        size: bufferSize,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      });
+      encoder.copyTextureToBuffer(
+        { texture: outputTexture },
+        { buffer: stagingBuffer, bytesPerRow },
+        { width: currentWidth, height: currentHeight }
+      );
+      device.queue.submit([encoder.finish()]);
+      for (const tex of layerTextures) {
+        tex.destroy();
+      }
+      await stagingBuffer.mapAsync(GPUMapMode.READ);
+      const rawData = stagingBuffer.getMappedRange();
+      const pixelData = new Uint8ClampedArray(currentWidth * currentHeight * 4);
+      const src = new Uint8Array(rawData);
+      for (let row = 0; row < currentHeight; row++) {
+        const srcOffset = row * bytesPerRow;
+        const dstOffset = row * currentWidth * 4;
+        pixelData.set(src.subarray(srcOffset, srcOffset + currentWidth * 4), dstOffset);
+      }
+      stagingBuffer.unmap();
+      stagingBuffer.destroy();
+      for (let i = 0; i < pixelData.length; i += 4) {
+        const a = pixelData[i + 3];
+        if (a > 0 && a < 255) {
+          const inv = 255 / a;
+          pixelData[i] = Math.min(255, Math.round(pixelData[i] * inv));
+          pixelData[i + 1] = Math.min(255, Math.round(pixelData[i + 1] * inv));
+          pixelData[i + 2] = Math.min(255, Math.round(pixelData[i + 2] * inv));
+        }
+      }
+      const readbackCanvas = new OffscreenCanvas(currentWidth, currentHeight);
+      const ctx = readbackCanvas.getContext("2d", { alpha: true });
+      const imageData = new ImageData(pixelData, currentWidth, currentHeight);
+      ctx.putImageData(imageData, 0, 0);
+      return createImageBitmap(readbackCanvas);
+    },
+    resize(w, h) {
+      outputTexture.destroy();
+      currentWidth = w;
+      currentHeight = h;
+      outputTexture = createOutputTexture(device, w, h);
+    },
+    destroy() {
+      outputTexture.destroy();
+      opacityBuffer.destroy();
+      device.destroy();
+    }
+  };
+}
+
+// src/compositor.ts
+async function createCompositor(width, height, type = "auto") {
+  if (type === "canvas2d") {
+    return createCanvas2DCompositor(width, height);
+  }
+  if (type === "gpu" || type === "auto") {
+    if (typeof navigator !== "undefined" && navigator.gpu) {
+      try {
+        return await createGPUCompositor(width, height);
+      } catch {
+        if (type === "gpu") {
+          throw new Error("WebGPU compositor requested but initialization failed");
+        }
+      }
+    } else if (type === "gpu") {
+      throw new Error("WebGPU not available");
+    }
+  }
+  return createCanvas2DCompositor(width, height);
+}
+
+// src/frame-renderer.ts
+var import_timeline = require("@pneuma-craft/timeline");
+function createFrameRenderer(decoder, compositor, width, height, subtitleRenderer) {
+  return {
+    async renderFrame(composition, time) {
+      const resolved = (0, import_timeline.resolveFrame)(composition, time);
+      const videoClips = resolved.clips.filter((rc) => rc.track.type === "video");
+      const subtitleClips = subtitleRenderer ? resolved.clips.filter((rc) => rc.track.type === "subtitle") : [];
+      const layers = [];
+      for (let i = 0; i < videoClips.length; i++) {
+        const rc = videoClips[i];
+        const source = await decoder.decodeVideoFrame(
+          rc.clip.assetId,
+          rc.localTime,
+          width,
+          height
+        );
+        layers.push({
+          source,
+          opacity: 1,
+          zIndex: i
+        });
+      }
+      if (subtitleRenderer && subtitleClips.length > 0) {
+        const baseZ = videoClips.length;
+        for (let i = 0; i < subtitleClips.length; i++) {
+          const rc = subtitleClips[i];
+          const rendered = await subtitleRenderer({
+            clip: rc.clip,
+            localTime: rc.localTime,
+            width,
+            height
+          });
+          if (rendered) {
+            layers.push({
+              source: rendered,
+              opacity: 1,
+              zIndex: baseZ + i
+            });
+          }
+        }
+      }
+      const image = await compositor.composite(layers);
+      return { image, time, width, height };
+    },
+    destroy() {
+      decoder.destroy();
+      compositor.destroy();
+    }
+  };
+}
+
+// src/master-clock.ts
+function createMasterClock(options) {
+  const audioContext = options.audioContext;
+  let state = "stopped";
+  let _duration = options.duration ?? 0;
+  let _playbackRate = 1;
+  let _loop = null;
+  let startAudioContextTime = 0;
+  let startTimelineTime = 0;
+  let pausedAt = 0;
+  let _driftMs = 0;
+  const timeUpdateListeners = /* @__PURE__ */ new Set();
+  const stateChangeListeners = /* @__PURE__ */ new Set();
+  function computeCurrentTime() {
+    if (state !== "playing") return pausedAt;
+    const elapsed = (audioContext.currentTime - startAudioContextTime) * _playbackRate;
+    let time = startTimelineTime + elapsed;
+    if (_loop && _loop.end > _loop.start && time >= _loop.end) {
+      const loopDuration = _loop.end - _loop.start;
+      time = _loop.start + (time - _loop.start) % loopDuration;
+    }
+    return Math.max(0, Math.min(time, _duration || Infinity));
+  }
+  function notifyTimeUpdate(time) {
+    for (const cb of timeUpdateListeners) {
+      try {
+        cb(time);
+      } catch (e) {
+        console.error("[MasterClock] listener error:", e);
+      }
+    }
+  }
+  function notifyStateChange(newState) {
+    for (const cb of stateChangeListeners) {
+      try {
+        cb(newState);
+      } catch (e) {
+        console.error("[MasterClock] listener error:", e);
+      }
+    }
+  }
+  function setState(newState) {
+    if (state === newState) return;
+    state = newState;
+    notifyStateChange(newState);
+  }
+  const clock = {
+    get currentTime() {
+      return computeCurrentTime();
+    },
+    get state() {
+      return state;
+    },
+    get driftMs() {
+      return _driftMs;
+    },
+    get playbackRate() {
+      return _playbackRate;
+    },
+    set playbackRate(rate) {
+      const clamped = Math.max(0.1, Math.min(rate, 16));
+      if (state === "playing") {
+        const current = computeCurrentTime();
+        startTimelineTime = current;
+        startAudioContextTime = audioContext.currentTime;
+      }
+      _playbackRate = clamped;
+    },
+    get duration() {
+      return _duration;
+    },
+    set duration(d) {
+      _duration = Math.max(0, d);
+    },
+    get loop() {
+      return _loop;
+    },
+    set loop(l) {
+      _loop = l;
+    },
+    play() {
+      if (state === "playing") return;
+      startTimelineTime = pausedAt;
+      startAudioContextTime = audioContext.currentTime;
+      setState("playing");
+      if (audioContext.state === "suspended") {
+        audioContext.resume();
+      }
+    },
+    pause() {
+      if (state !== "playing") return;
+      pausedAt = computeCurrentTime();
+      setState("paused");
+    },
+    seek(time) {
+      const clamped = Math.max(0, Math.min(time, _duration));
+      if (state === "playing") {
+        startTimelineTime = clamped;
+        startAudioContextTime = audioContext.currentTime;
+      } else {
+        pausedAt = clamped;
+      }
+      notifyTimeUpdate(clamped);
+    },
+    reportVideoTime(videoTime) {
+      const audioTime = computeCurrentTime();
+      _driftMs = (audioTime - videoTime) * 1e3;
+    },
+    onTimeUpdate(cb) {
+      timeUpdateListeners.add(cb);
+      return () => {
+        timeUpdateListeners.delete(cb);
+      };
+    },
+    onStateChange(cb) {
+      stateChangeListeners.add(cb);
+      return () => {
+        stateChangeListeners.delete(cb);
+      };
+    },
+    destroy() {
+      if (state === "playing") {
+        pausedAt = computeCurrentTime();
+      }
+      state = "stopped";
+      timeUpdateListeners.clear();
+      stateChangeListeners.clear();
+      _driftMs = 0;
+    }
+  };
+  return clock;
+}
+
+// src/audio-scheduler.ts
+function createAudioScheduler(options) {
+  const { audioContext } = options;
+  const clipBuffers = /* @__PURE__ */ new Map();
+  const trackGains = /* @__PURE__ */ new Map();
+  const trackVolumes = /* @__PURE__ */ new Map();
+  const trackMutedStates = /* @__PURE__ */ new Map();
+  let activeSources = [];
+  let schedulerIntervalId = null;
+  let scheduledClipIds = /* @__PURE__ */ new Set();
+  let currentComposition = null;
+  let _playbackRate = 1;
+  let _isPlaying = false;
+  let _prevTimelineTime = 0;
+  let _getCurrentTime = null;
+  const LOOK_AHEAD = 0.2;
+  const masterGain = audioContext.createGain();
+  masterGain.gain.value = 1;
+  masterGain.connect(audioContext.destination);
+  function getOrCreateTrackGain(track) {
+    let node = trackGains.get(track.id);
+    if (!node) {
+      node = audioContext.createGain();
+      const vol = trackVolumes.get(track.id) ?? track.volume ?? 1;
+      const muted = trackMutedStates.get(track.id) ?? track.muted;
+      node.gain.value = muted ? 0 : vol;
+      trackVolumes.set(track.id, vol);
+      node.connect(masterGain);
+      trackGains.set(track.id, node);
+    }
+    return node;
+  }
+  function clearSchedulerTick() {
+    if (schedulerIntervalId !== null) {
+      clearInterval(schedulerIntervalId);
+      schedulerIntervalId = null;
+    }
+  }
+  function stopAllSources() {
+    for (const { source } of activeSources) {
+      try {
+        source.stop();
+      } catch {
+      }
+      source.disconnect();
+    }
+    activeSources = [];
+  }
+  function isClipActiveAt(clip, fromTime) {
+    return clip.startTime <= fromTime && fromTime < clip.startTime + clip.duration;
+  }
+  function scheduleClip(clip, track, fromTime) {
+    const buffer = clipBuffers.get(clip.id);
+    if (!buffer) return;
+    const trackGain = getOrCreateTrackGain(track);
+    const clipGain = audioContext.createGain();
+    const clipVolume = clip.volume ?? 1;
+    clipGain.gain.value = clipVolume;
+    const source = audioContext.createBufferSource();
+    source.buffer = buffer;
+    source.playbackRate.value = _playbackRate;
+    source.connect(clipGain);
+    clipGain.connect(trackGain);
+    const now = audioContext.currentTime;
+    let contextStartTime;
+    let sourceOffset;
+    let remainingDuration;
+    if (clip.startTime > fromTime) {
+      const timeUntilClipStart = (clip.startTime - fromTime) / _playbackRate;
+      contextStartTime = now + timeUntilClipStart;
+      sourceOffset = clip.inPoint;
+      remainingDuration = clip.duration;
+    } else {
+      contextStartTime = 0;
+      const elapsed = fromTime - clip.startTime;
+      sourceOffset = clip.inPoint + elapsed;
+      remainingDuration = clip.duration - elapsed;
+    }
+    if (clip.fadeIn !== void 0 && clip.fadeIn > 0) {
+      const realFadeIn = clip.fadeIn / _playbackRate;
+      if (clip.startTime > fromTime) {
+        clipGain.gain.setValueAtTime(0, contextStartTime);
+        clipGain.gain.linearRampToValueAtTime(clipVolume, contextStartTime + realFadeIn);
+      } else {
+        const fadeInEnd = clip.startTime + clip.fadeIn;
+        if (fromTime < fadeInEnd) {
+          const fadeElapsed = fromTime - clip.startTime;
+          const currentLevel = fadeElapsed > 0 ? fadeElapsed / clip.fadeIn * clipVolume : 0;
+          const fadeRemaining = (clip.fadeIn - fadeElapsed) / _playbackRate;
+          clipGain.gain.setValueAtTime(currentLevel, now);
+          clipGain.gain.linearRampToValueAtTime(clipVolume, now + fadeRemaining);
+        }
+      }
+    }
+    if (clip.fadeOut !== void 0 && clip.fadeOut > 0) {
+      const realFadeOut = clip.fadeOut / _playbackRate;
+      const realDuration = clip.duration / _playbackRate;
+      if (clip.startTime > fromTime) {
+        const fadeOutStart = contextStartTime + realDuration - realFadeOut;
+        clipGain.gain.setValueAtTime(clipVolume, fadeOutStart);
+        clipGain.gain.linearRampToValueAtTime(0, contextStartTime + realDuration);
+      } else {
+        const fadeOutStart = clip.startTime + clip.duration - clip.fadeOut;
+        const fadeOutContextTime = now + Math.max(0, (fadeOutStart - fromTime) / _playbackRate);
+        clipGain.gain.setValueAtTime(clipVolume, fadeOutContextTime);
+        clipGain.gain.linearRampToValueAtTime(0, fadeOutContextTime + realFadeOut);
+      }
+    }
+    source.start(contextStartTime, sourceOffset, remainingDuration);
+    activeSources.push({ source, clipGain });
+  }
+  function isClipInLookAhead(clip, currentTime, lookAhead) {
+    const clipEnd = clip.startTime + clip.duration;
+    return clip.startTime > currentTime && clip.startTime <= currentTime + lookAhead && clipEnd > currentTime;
+  }
+  function scheduleComposition(fromTime, composition) {
+    for (const track of composition.tracks) {
+      if (track.type !== "audio" && track.type !== "video") continue;
+      if (track.muted) continue;
+      for (const clip of track.clips) {
+        if (!isClipActiveAt(clip, fromTime)) continue;
+        if (scheduledClipIds.has(clip.id)) continue;
+        scheduledClipIds.add(clip.id);
+        scheduleClip(clip, track, fromTime);
+      }
+    }
+  }
+  function startSchedulerTick(fromTime, composition) {
+    clearSchedulerTick();
+    currentComposition = composition;
+    const tickStartContextTime = audioContext.currentTime;
+    const tickStartFromTime = fromTime;
+    schedulerIntervalId = setInterval(() => {
+      if (!currentComposition) return;
+      let currentTimelineTime;
+      if (_getCurrentTime) {
+        currentTimelineTime = _getCurrentTime();
+      } else {
+        const elapsed = (audioContext.currentTime - tickStartContextTime) * _playbackRate;
+        currentTimelineTime = tickStartFromTime + elapsed;
+      }
+      if (currentTimelineTime < _prevTimelineTime) {
+        scheduledClipIds.clear();
+        stopAllSources();
+      }
+      _prevTimelineTime = currentTimelineTime;
+      for (const track of currentComposition.tracks) {
+        if (track.type !== "audio") continue;
+        if (track.muted) continue;
+        for (const clip of track.clips) {
+          if (scheduledClipIds.has(clip.id)) continue;
+          if (isClipInLookAhead(clip, currentTimelineTime, LOOK_AHEAD) || isClipActiveAt(clip, currentTimelineTime)) {
+            scheduledClipIds.add(clip.id);
+            scheduleClip(clip, track, currentTimelineTime);
+          }
+        }
+      }
+    }, 100);
+  }
+  const scheduler = {
+    get audioContext() {
+      return audioContext;
+    },
+    loadClip(clipId, audioBuffer) {
+      clipBuffers.set(clipId, audioBuffer);
+    },
+    play(fromTime, composition, getCurrentTime) {
+      stopAllSources();
+      clearSchedulerTick();
+      scheduledClipIds = /* @__PURE__ */ new Set();
+      _prevTimelineTime = fromTime;
+      _getCurrentTime = getCurrentTime ?? null;
+      _isPlaying = true;
+      currentComposition = composition;
+      scheduleComposition(fromTime, composition);
+      startSchedulerTick(fromTime, composition);
+    },
+    pause() {
+      clearSchedulerTick();
+      stopAllSources();
+      scheduledClipIds = /* @__PURE__ */ new Set();
+      _isPlaying = false;
+    },
+    seek(time, composition) {
+      clearSchedulerTick();
+      stopAllSources();
+      scheduledClipIds = /* @__PURE__ */ new Set();
+      _prevTimelineTime = time;
+      scheduleComposition(time, composition);
+      startSchedulerTick(time, composition);
+    },
+    setPlaybackRate(rate) {
+      _playbackRate = rate;
+      if (_isPlaying && currentComposition && _getCurrentTime) {
+        stopAllSources();
+        scheduledClipIds = /* @__PURE__ */ new Set();
+        const currentTime = _getCurrentTime();
+        scheduleComposition(currentTime, currentComposition);
+        clearSchedulerTick();
+        startSchedulerTick(currentTime, currentComposition);
+      } else {
+        for (const scheduled of activeSources) {
+          scheduled.source.playbackRate.value = rate;
+        }
+      }
+    },
+    setTrackVolume(trackId, volume) {
+      trackVolumes.set(trackId, volume);
+      const node = trackGains.get(trackId);
+      if (node) {
+        const isMuted = trackMutedStates.get(trackId) ?? false;
+        if (!isMuted) {
+          node.gain.setValueAtTime(volume, audioContext.currentTime);
+        }
+      }
+    },
+    setTrackMute(trackId, muted) {
+      trackMutedStates.set(trackId, muted);
+      const node = trackGains.get(trackId);
+      if (node) {
+        if (muted) {
+          node.gain.value = 0;
+        } else {
+          const vol = trackVolumes.get(trackId) ?? 1;
+          node.gain.value = vol;
+        }
+      }
+    },
+    destroy() {
+      clearSchedulerTick();
+      stopAllSources();
+      scheduledClipIds = /* @__PURE__ */ new Set();
+      currentComposition = null;
+      _isPlaying = false;
+      for (const node of trackGains.values()) {
+        node.disconnect();
+      }
+      trackGains.clear();
+      trackVolumes.clear();
+      trackMutedStates.clear();
+      clipBuffers.clear();
+      masterGain.disconnect();
+    }
+  };
+  return scheduler;
+}
+
+// src/playback-engine.ts
+var DEFAULT_DECODE_TIMEOUT_MS = 1e3;
+var DEBUG_LOOP = typeof globalThis !== "undefined" && globalThis.__PNEUMA_CRAFT_PLAYBACK_DEBUG__ === true;
+function createPlaybackEngine(options) {
+  const compositorType = options?.compositorType ?? "canvas2d";
+  const decodeTimeoutMs = options?.decodeTimeoutMs ?? DEFAULT_DECODE_TIMEOUT_MS;
+  const subtitleRenderer = options?.subtitleRenderer;
+  let _state = "idle";
+  let _playbackRate = 1;
+  let _loop = null;
+  let _decoder = null;
+  let _compositor = null;
+  let _frameRenderer = null;
+  let _clock = null;
+  let _audioScheduler = null;
+  let _audioContext = null;
+  let _composition = null;
+  let _rafId = null;
+  let _frameInFlight = false;
+  let _seekId = 0;
+  const stateChangeListeners = /* @__PURE__ */ new Set();
+  const timeUpdateListeners = /* @__PURE__ */ new Set();
+  const frameRenderedListeners = /* @__PURE__ */ new Set();
+  function setState(newState) {
+    if (_state === newState) return;
+    _state = newState;
+    for (const cb of stateChangeListeners) {
+      try {
+        cb(newState);
+      } catch (e) {
+        console.error("[PlaybackEngine] listener error:", e);
+      }
+    }
+  }
+  function emitTimeUpdate(time) {
+    for (const cb of timeUpdateListeners) {
+      try {
+        cb(time);
+      } catch (e) {
+        console.error("[PlaybackEngine] listener error:", e);
+      }
+    }
+  }
+  function emitFrameRendered(frame) {
+    for (const cb of frameRenderedListeners) {
+      try {
+        cb(frame);
+      } catch (e) {
+        console.error("[PlaybackEngine] listener error:", e);
+      }
+    }
+  }
+  function destroySubsystems() {
+    if (_rafId !== null) {
+      cancelAnimationFrame(_rafId);
+      _rafId = null;
+    }
+    _frameInFlight = false;
+    _frameRenderer?.destroy();
+    _clock?.destroy();
+    _audioScheduler?.destroy();
+    _audioContext?.close();
+    _decoder = null;
+    _compositor = null;
+    _frameRenderer = null;
+    _clock = null;
+    _audioScheduler = null;
+    _audioContext = null;
+    _composition = null;
+  }
+  function startRafLoop() {
+    if (_rafId !== null) return;
+    let lastLoggedState = null;
+    const logStateChange = (state, time, extra) => {
+      if (!DEBUG_LOOP) return;
+      if (lastLoggedState === state) return;
+      lastLoggedState = state;
+      console.log(`[engine] ${state} @ t=${time.toFixed(3)}${extra ? " " + extra : ""}`);
+    };
+    const loop = () => {
+      _rafId = null;
+      if (_state !== "playing" || !_clock || !_frameRenderer || !_composition) return;
+      const time = _clock.currentTime;
+      emitTimeUpdate(time);
+      if (!_clock.loop && time >= _composition.duration) {
+        engine.pause();
+        return;
+      }
+      _rafId = requestAnimationFrame(loop);
+      if (_frameInFlight) {
+        logStateChange("skip-inflight", time);
+        return;
+      }
+      logStateChange("render", time);
+      _frameInFlight = true;
+      const clockRef = _clock;
+      const compositionRef = _composition;
+      let timedOut = false;
+      const timeoutId = setTimeout(() => {
+        timedOut = true;
+        _frameInFlight = false;
+        console.warn(
+          `[PlaybackEngine] decode timeout at t=${time.toFixed(3)}s (>${decodeTimeoutMs}ms) \u2014 skipping frame`
+        );
+      }, decodeTimeoutMs);
+      _frameRenderer.renderFrame(compositionRef, time).then((frame) => {
+        clearTimeout(timeoutId);
+        if (timedOut) return;
+        _frameInFlight = false;
+        if (_state !== "playing" || _clock !== clockRef) return;
+        clockRef.reportVideoTime(time);
+        emitFrameRendered(frame);
+      }).catch((err) => {
+        clearTimeout(timeoutId);
+        if (timedOut) return;
+        _frameInFlight = false;
+        console.error("[PlaybackEngine] render error:", err);
+      });
+    };
+    _rafId = requestAnimationFrame(loop);
+  }
+  function stopRafLoop() {
+    if (_rafId !== null) {
+      cancelAnimationFrame(_rafId);
+      _rafId = null;
+    }
+    _frameInFlight = false;
+  }
+  const engine = {
+    get state() {
+      return _state;
+    },
+    get currentTime() {
+      return _clock?.currentTime ?? 0;
+    },
+    get playbackRate() {
+      return _clock?.playbackRate ?? _playbackRate;
+    },
+    set playbackRate(rate) {
+      _playbackRate = rate;
+      if (_clock) {
+        _clock.playbackRate = rate;
+      }
+      if (_audioScheduler) {
+        _audioScheduler.setPlaybackRate(rate);
+      }
+    },
+    get loop() {
+      return _clock?.loop ?? _loop;
+    },
+    set loop(l) {
+      _loop = l;
+      if (_clock) {
+        _clock.loop = l;
+      }
+    },
+    async load(composition, resolver) {
+      _seekId++;
+      if (_state !== "idle") {
+        destroySubsystems();
+      }
+      setState("loading");
+      try {
+        _audioContext = new AudioContext();
+        _decoder = createMediaDecoder(resolver, _audioContext);
+        _compositor = await createCompositor(
+          composition.settings.width,
+          composition.settings.height,
+          compositorType
+        );
+        _frameRenderer = createFrameRenderer(
+          _decoder,
+          _compositor,
+          composition.settings.width,
+          composition.settings.height,
+          subtitleRenderer
+        );
+        _clock = createMasterClock({
+          audioContext: _audioContext,
+          duration: composition.duration,
+          frameRate: composition.settings.fps
+        });
+        _audioScheduler = createAudioScheduler({ audioContext: _audioContext });
+        _clock.playbackRate = _playbackRate;
+        _clock.loop = _loop;
+        _composition = composition;
+        const mediaClips = composition.tracks.filter((track) => track.type === "audio" || track.type === "video").flatMap((track) => track.clips);
+        for (const clip of mediaClips) {
+          try {
+            const audioBuffer = await _decoder.decodeAudio(clip.assetId);
+            _audioScheduler.loadClip(clip.id, audioBuffer);
+          } catch {
+          }
+        }
+        setState("ready");
+      } catch (err) {
+        destroySubsystems();
+        setState("idle");
+        throw err;
+      }
+    },
+    play() {
+      if (!_clock || !_audioScheduler || !_composition) {
+        throw new Error("Cannot play: no composition loaded. Call load() first.");
+      }
+      if (_state === "playing") return;
+      if (_audioContext && _audioContext.state === "suspended") {
+        _audioContext.resume().catch((err) => {
+          console.warn("[PlaybackEngine] AudioContext resume failed:", err);
+        });
+      }
+      _clock.play();
+      _audioScheduler.setPlaybackRate(_playbackRate);
+      const clockRef = _clock;
+      _audioScheduler.play(_clock.currentTime, _composition, () => clockRef.currentTime);
+      setState("playing");
+      startRafLoop();
+    },
+    pause() {
+      if (_state !== "playing") return;
+      stopRafLoop();
+      _clock?.pause();
+      _audioScheduler?.pause();
+      setState("paused");
+    },
+    seek(time) {
+      if (!_clock || !_audioScheduler || !_composition) {
+        throw new Error("Cannot seek: no composition loaded. Call load() first.");
+      }
+      _clock.seek(time);
+      const clampedTime = _clock.currentTime;
+      if (_state === "playing") {
+        _audioScheduler.setPlaybackRate(_playbackRate);
+        _audioScheduler.seek(clampedTime, _composition);
+      }
+      if (_state !== "playing" && _frameRenderer) {
+        const thisSeekId = ++_seekId;
+        _frameRenderer.renderFrame(_composition, clampedTime).then((frame) => {
+          if (thisSeekId !== _seekId) return;
+          emitFrameRendered(frame);
+          emitTimeUpdate(clampedTime);
+        }).catch((err) => {
+          console.error("[PlaybackEngine] seek render error:", err);
+        });
+      }
+    },
+    onStateChange(cb) {
+      stateChangeListeners.add(cb);
+      return () => {
+        stateChangeListeners.delete(cb);
+      };
+    },
+    onTimeUpdate(cb) {
+      timeUpdateListeners.add(cb);
+      return () => {
+        timeUpdateListeners.delete(cb);
+      };
+    },
+    onFrameRendered(cb) {
+      frameRenderedListeners.add(cb);
+      return () => {
+        frameRenderedListeners.delete(cb);
+      };
+    },
+    destroy() {
+      stopRafLoop();
+      destroySubsystems();
+      stateChangeListeners.clear();
+      timeUpdateListeners.clear();
+      frameRenderedListeners.clear();
+      _playbackRate = 1;
+      _loop = null;
+      _state = "idle";
+    }
+  };
+  return engine;
+}
+
+// src/offline-audio-renderer.ts
+function createOfflineAudioRenderer() {
+  return {
+    async render(composition, _resolver, decodeAudio) {
+      const sampleRate = composition.settings.sampleRate ?? 48e3;
+      const channels = 2;
+      const duration = composition.duration;
+      const length = Math.ceil(duration * sampleRate);
+      const offlineCtx = new OfflineAudioContext(channels, length, sampleRate);
+      const audioClips = [];
+      for (const track of composition.tracks) {
+        if (track.type !== "audio" && track.type !== "video") continue;
+        if (track.muted) continue;
+        for (const clip of track.clips) {
+          audioClips.push({ clip, track });
+        }
+      }
+      for (const { clip, track } of audioClips) {
+        let buffer;
+        try {
+          buffer = await decodeAudio(clip.assetId);
+        } catch {
+          continue;
+        }
+        const source = offlineCtx.createBufferSource();
+        source.buffer = buffer;
+        const clipGain = offlineCtx.createGain();
+        const clipVolume = clip.volume ?? 1;
+        clipGain.gain.value = clipVolume;
+        const trackGain = offlineCtx.createGain();
+        trackGain.gain.value = track.volume;
+        source.connect(clipGain);
+        clipGain.connect(trackGain);
+        trackGain.connect(offlineCtx.destination);
+        const fadeIn = clip.fadeIn;
+        const fadeOut = clip.fadeOut;
+        if (fadeIn && fadeIn > 0) {
+          clipGain.gain.setValueAtTime(0, clip.startTime);
+          clipGain.gain.linearRampToValueAtTime(clipVolume, clip.startTime + fadeIn);
+        }
+        if (fadeOut && fadeOut > 0) {
+          const fadeOutStart = clip.startTime + clip.duration - fadeOut;
+          clipGain.gain.setValueAtTime(clipVolume, fadeOutStart);
+          clipGain.gain.linearRampToValueAtTime(0, clip.startTime + clip.duration);
+        }
+        source.start(clip.startTime, clip.inPoint, clip.duration);
+      }
+      return offlineCtx.startRendering();
+    }
+  };
+}
+
+// src/export-engine.ts
+var import_mediabunny2 = require("mediabunny");
+function createExportEngine(options) {
+  const subtitleRenderer = options?.subtitleRenderer;
+  const progressListeners = /* @__PURE__ */ new Set();
+  let abortController = null;
+  function notifyProgress(progress) {
+    for (const cb of progressListeners) {
+      try {
+        cb(progress);
+      } catch (e) {
+        console.error("[ExportEngine]", e);
+      }
+    }
+  }
+  return {
+    async export(composition, options2, resolver) {
+      abortController = new AbortController();
+      const signal = abortController.signal;
+      const fps = options2.fps ?? composition.settings.fps;
+      const width = options2.width ?? composition.settings.width;
+      const height = options2.height ?? composition.settings.height;
+      const totalFrames = Math.ceil(composition.duration * fps);
+      const decoderAudioCtx = new OfflineAudioContext(1, 1, composition.settings.sampleRate || 48e3);
+      const decoder = createMediaDecoder(resolver, decoderAudioCtx);
+      const compositor = await createCompositor(width, height, "canvas2d");
+      const renderer = createFrameRenderer(decoder, compositor, width, height, subtitleRenderer);
+      try {
+        const format = options2.format === "webm" ? new import_mediabunny2.WebMOutputFormat() : new import_mediabunny2.Mp4OutputFormat({ fastStart: "in-memory" });
+        const target = new import_mediabunny2.BufferTarget();
+        const output = new import_mediabunny2.Output({ format, target });
+        const renderCanvas = new OffscreenCanvas(width, height);
+        const videoSource = new import_mediabunny2.CanvasSource(renderCanvas, {
+          codec: options2.videoCodec,
+          bitrate: options2.videoBitrate
+        });
+        const audioSource = new import_mediabunny2.AudioBufferSource({
+          codec: options2.audioCodec,
+          bitrate: options2.audioBitrate
+        });
+        output.addVideoTrack(videoSource);
+        output.addAudioTrack(audioSource);
+        await output.start();
+        const renderCtx = renderCanvas.getContext("2d");
+        for (let frame = 0; frame < totalFrames; frame++) {
+          if (signal.aborted) throw new Error("Export aborted");
+          const time = frame / fps;
+          const rendered = await renderer.renderFrame(composition, time);
+          renderCtx.clearRect(0, 0, width, height);
+          renderCtx.drawImage(rendered.image, 0, 0, width, height);
+          rendered.image.close();
+          await videoSource.add(time, 1 / fps);
+          if ((frame + 1) % 5 === 0 || frame === totalFrames - 1) {
+            notifyProgress((frame + 1) / totalFrames);
+          }
+          if ((frame + 1) % 5 === 0) {
+            await new Promise((r) => setTimeout(r, 0));
+          }
+        }
+        videoSource.close();
+        if (signal.aborted) throw new Error("Export aborted");
+        const offlineRenderer = createOfflineAudioRenderer();
+        const audioBuffer = await offlineRenderer.render(
+          composition,
+          resolver,
+          (assetId) => decoder.decodeAudio(assetId)
+        );
+        if (signal.aborted) throw new Error("Export aborted");
+        await audioSource.add(audioBuffer);
+        audioSource.close();
+        if (signal.aborted) throw new Error("Export aborted");
+        await output.finalize();
+        const buffer = target.buffer;
+        if (!buffer) throw new Error("Export produced no output");
+        const mimeType = options2.format === "webm" ? "video/webm" : "video/mp4";
+        return new Blob([buffer], { type: mimeType });
+      } finally {
+        renderer.destroy();
+        abortController = null;
+      }
+    },
+    onProgress(cb) {
+      progressListeners.add(cb);
+      return () => {
+        progressListeners.delete(cb);
+      };
+    },
+    abort() {
+      abortController?.abort();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAudioScheduler,
+  createCanvas2DCompositor,
+  createCompositor,
+  createExportEngine,
+  createFrameRenderer,
+  createGPUCompositor,
+  createMasterClock,
+  createMediaDecoder,
+  createOfflineAudioRenderer,
+  createPlaybackEngine
+});
+//# sourceMappingURL=index.cjs.map