@vosjs/render-core 0.1.0

package/dist/index.js

@@ -0,0 +1,938 @@
+// src/chunkPlanner.ts
+var DEFAULT_MIN_FRAMES_PER_CHUNK = 24;
+function planChunks(totalFrames, fps, policy) {
+  if (!Number.isInteger(totalFrames) || totalFrames <= 0) {
+    throw new Error(
+      `planChunks: totalFrames must be a positive integer, got ${totalFrames}`
+    );
+  }
+  if (!(fps > 0)) {
+    throw new Error(`planChunks: fps must be positive, got ${fps}`);
+  }
+  const minFrames = policy.minFramesPerChunk ?? DEFAULT_MIN_FRAMES_PER_CHUNK;
+  const chunkCount = Math.max(
+    1,
+    Math.min(
+      Math.floor(policy.maxParallel),
+      Math.floor(totalFrames / minFrames)
+    )
+  );
+  const base = Math.floor(totalFrames / chunkCount);
+  const remainder = totalFrames % chunkCount;
+  const chunks = [];
+  let startFrame = 0;
+  for (let index = 0; index < chunkCount; index++) {
+    const frameCount = base + (index < remainder ? 1 : 0);
+    const endFrame = startFrame + frameCount;
+    chunks.push({
+      index,
+      startFrame,
+      endFrame,
+      frameCount,
+      startTime: startFrame / fps,
+      duration: frameCount / fps
+    });
+    startFrame = endFrame;
+  }
+  return chunks;
+}
+
+// src/concat.ts
+import {
+  ALL_FORMATS,
+  BufferSource,
+  BufferTarget,
+  EncodedAudioPacketSource,
+  EncodedPacketSink,
+  EncodedVideoPacketSource,
+  Input,
+  Mp4OutputFormat,
+  Output,
+  WebMOutputFormat
+} from "mediabunny";
+async function openVideoTrack(data, chunkIndex) {
+  const input = new Input({
+    formats: ALL_FORMATS,
+    source: new BufferSource(data)
+  });
+  const track = await input.getPrimaryVideoTrack();
+  if (!track) throw new Error(`Chunk ${chunkIndex} has no video track`);
+  return { input, track };
+}
+async function muxEncodedExport(options) {
+  const output = new Output({
+    format: options.format === "mp4" ? new Mp4OutputFormat() : new WebMOutputFormat(),
+    target: new BufferTarget()
+  });
+  let audioTrack = null;
+  if (options.audio) {
+    const input = new Input({
+      formats: ALL_FORMATS,
+      source: new BufferSource(options.audio)
+    });
+    const track = await input.getPrimaryAudioTrack();
+    if (!track || !track.codec) {
+      throw new Error("Audio part has no readable audio track");
+    }
+    const decoderConfig2 = await track.getDecoderConfig();
+    if (!decoderConfig2) throw new Error("Audio part has no decoder config");
+    const source = new EncodedAudioPacketSource(track.codec);
+    output.addAudioTrack(source);
+    audioTrack = { source, sink: new EncodedPacketSink(track), decoderConfig: decoderConfig2 };
+  }
+  let videoSource = null;
+  let codec = null;
+  let decoderConfig = null;
+  let started = false;
+  let offset = 0;
+  let packetCount = 0;
+  let index = 0;
+  for await (const chunk of options.video) {
+    const i = index++;
+    const { track } = await openVideoTrack(chunk.data, i);
+    if (i === 0) {
+      codec = track.codec;
+      if (!codec) throw new Error("Chunk 0 video codec could not be determined");
+      decoderConfig = await track.getDecoderConfig();
+      if (!decoderConfig) throw new Error("Chunk 0 has no decoder config");
+      videoSource = new EncodedVideoPacketSource(codec);
+      output.addVideoTrack(
+        videoSource,
+        options.frameRate ? { frameRate: options.frameRate } : void 0
+      );
+      await output.start();
+      started = true;
+      if (audioTrack) {
+        let firstAudio = true;
+        for await (const packet of audioTrack.sink.packets()) {
+          await audioTrack.source.add(
+            packet,
+            firstAudio ? { decoderConfig: audioTrack.decoderConfig } : void 0
+          );
+          firstAudio = false;
+        }
+        audioTrack.source.close();
+      }
+    } else if (track.codec !== codec) {
+      throw new Error(
+        `Chunk ${i} codec ${String(track.codec)} != chunk 0 codec ${String(codec)} \u2014 chunks must share one encoder config`
+      );
+    }
+    const sink = new EncodedPacketSink(track);
+    let firstOfChunk = true;
+    for await (const packet of sink.packets()) {
+      if (firstOfChunk && packet.type !== "key") {
+        throw new Error(
+          `Chunk ${i} does not start on a keyframe \u2014 was it encoded as an independent chunk?`
+        );
+      }
+      const shifted = packet.clone({
+        timestamp: packet.timestamp + offset
+      });
+      await videoSource.add(
+        shifted,
+        firstOfChunk && i === 0 && decoderConfig ? { decoderConfig } : void 0
+      );
+      firstOfChunk = false;
+      packetCount++;
+    }
+    offset += chunk.duration;
+  }
+  if (!started || !videoSource || !codec) {
+    throw new Error("muxEncodedExport: no video parts");
+  }
+  await output.finalize();
+  const bytes = output.target.buffer;
+  if (!bytes) throw new Error("Concat produced no output buffer");
+  return { bytes: new Uint8Array(bytes), packetCount, codec };
+}
+async function concatEncodedVideo(chunks, options) {
+  if (chunks.length === 0) throw new Error("concatEncodedVideo: no chunks");
+  return muxEncodedExport({ ...options, video: chunks });
+}
+async function countVideoPackets(data) {
+  const { track } = await openVideoTrack(data, 0);
+  const sink = new EncodedPacketSink(track);
+  let count = 0;
+  for await (const packet of sink.packets()) {
+    void packet;
+    count++;
+  }
+  return count;
+}
+
+// src/finalizePage.ts
+var MEDIABUNNY_URL = "https://esm.sh/mediabunny@1.27.3?target=es2022";
+function buildFinalizeConcatPage(options) {
+  if (options.parts.length === 0) {
+    throw new Error("buildFinalizeConcatPage: no parts");
+  }
+  if (options.audio && options.audioPart) {
+    throw new Error(
+      "buildFinalizeConcatPage: audio and audioPart are mutually exclusive"
+    );
+  }
+  const contentType = options.format === "mp4" ? "video/mp4" : "video/webm";
+  const config = JSON.stringify({
+    parts: options.parts,
+    format: options.format,
+    frameRate: options.frameRate,
+    uploadUrl: options.uploadUrl,
+    contentType,
+    audioData: options.audio ? options.audio.data : null,
+    audioDuration: options.audio ? options.audio.duration : 0,
+    audioPartUrl: options.audioPart ? options.audioPart.url : null
+  });
+  const audioProducerBlock = options.audio ? options.audio.producerCode : "";
+  return `<!doctype html>
+<html>
+<head><meta charset="utf-8"><title>vos finalize</title></head>
+<body>
+<script type="module">
+const CONFIG = ${config};
+${audioProducerBlock}
+
+// Stage marker: the supervising worker polls this every tick and reports the
+// last stage seen when the page dies without a result \u2014 the only way to
+// localize a page death on a fleet with no devtools (a diagnosis aid).
+// Each stage carries the V8 heap sample when available, so a death
+// names its memory peak too. Heap only covers JS objects (ArrayBuffers are
+// external), so treat it as a floor, not the whole bill. The stage NAME must
+// stay the first space-delimited token \u2014 renderPolicy's finalizeDeathStage
+// parses it out of the error message.
+const stage = (s) => {
+  const m = performance.memory;
+  window.__finalizeStage = m ? s + ' heap=' + Math.round(m.usedJSHeapSize / 1048576) + 'MB' : s;
+};
+stage('boot');
+
+;(async () => {
+  stage('import-mediabunny');
+  const MB = await import(${JSON.stringify(MEDIABUNNY_URL)});
+
+  // Audio first: a producer failure aborts before any concat work.
+  let audioBuffer = null;
+  if (window.__vosAudioProducer__ && CONFIG.audioData != null) {
+    stage('audio-produce');
+    audioBuffer = await window.__vosAudioProducer__({
+      data: CONFIG.audioData,
+      duration: CONFIG.audioDuration,
+      sampleRate: 48000,
+    });
+  }
+
+  // Pre-encoded audio part: stream-copy, no production memory bill.
+  let audioPartTrack = null;
+  let audioPartConfig = null;
+  if (CONFIG.audioPartUrl) {
+    stage('audio-part-open');
+    const abytes = await (await fetch(CONFIG.audioPartUrl)).arrayBuffer();
+    const ainput = new MB.Input({ formats: MB.ALL_FORMATS, source: new MB.BufferSource(abytes) });
+    audioPartTrack = await ainput.getPrimaryAudioTrack();
+    if (!audioPartTrack || !audioPartTrack.codec) {
+      throw new Error('Audio part has no readable audio track');
+    }
+    audioPartConfig = await audioPartTrack.getDecoderConfig();
+    if (!audioPartConfig) throw new Error('Audio part has no decoder config');
+  }
+
+  const openTrack = async (bytes, index) => {
+    const input = new MB.Input({ formats: MB.ALL_FORMATS, source: new MB.BufferSource(bytes) });
+    const track = await input.getPrimaryVideoTrack();
+    if (!track) throw new Error('Chunk ' + index + ' has no video track');
+    return track;
+  };
+
+  stage('fetch-part-0');
+  const first = await (await fetch(CONFIG.parts[0].url)).arrayBuffer();
+  stage('open-part-0');
+  const firstTrack = await openTrack(first, 0);
+  const codec = firstTrack.codec;
+  if (!codec) throw new Error('Chunk 0 video codec could not be determined');
+  const decoderConfig = await firstTrack.getDecoderConfig();
+  if (!decoderConfig) throw new Error('Chunk 0 has no decoder config');
+
+  const output = new MB.Output({
+    format: CONFIG.format === 'mp4' ? new MB.Mp4OutputFormat() : new MB.WebMOutputFormat(),
+    target: new MB.BufferTarget(),
+  });
+  const videoSource = new MB.EncodedVideoPacketSource(codec);
+  output.addVideoTrack(videoSource, { frameRate: CONFIG.frameRate });
+
+  let audioSource = null;
+  let audioPacketSource = null;
+  if (audioPartTrack) {
+    audioPacketSource = new MB.EncodedAudioPacketSource(audioPartTrack.codec);
+    output.addAudioTrack(audioPacketSource);
+  } else if (audioBuffer) {
+    // AAC first for mp4 (compatibility), Opus fallback \u2014 AAC encode is
+    // unavailable on some fleets (probe: aacEncode false on Linux).
+    const preferred = CONFIG.format === 'mp4' ? 'aac' : 'opus';
+    const audioCodec =
+      preferred === 'aac' && !(await MB.canEncodeAudio('aac')) ? 'opus' : preferred;
+    audioSource = new MB.AudioBufferSource({ codec: audioCodec, bitrate: MB.QUALITY_HIGH });
+    output.addAudioTrack(audioSource);
+  }
+
+  await output.start();
+
+  if (audioPacketSource && audioPartTrack) {
+    stage('audio-part-copy');
+    const asink = new MB.EncodedPacketSink(audioPartTrack);
+    let firstAudio = true;
+    for await (const packet of asink.packets()) {
+      await audioPacketSource.add(
+        packet,
+        firstAudio ? { decoderConfig: audioPartConfig } : undefined,
+      );
+      firstAudio = false;
+    }
+    audioPacketSource.close();
+  } else if (audioSource && audioBuffer) {
+    await audioSource.add(audioBuffer);
+    audioSource.close();
+  }
+
+  // Mirrors render-core concat.ts: plan-derived offsets, keyframe-per-chunk
+  // guard, decode-order packet walk.
+  let offset = 0;
+  let packetCount = 0;
+  for (let i = 0; i < CONFIG.parts.length; i++) {
+    stage('concat-part-' + i);
+    const bytes = i === 0 ? first : await (await fetch(CONFIG.parts[i].url)).arrayBuffer();
+    const track = i === 0 ? firstTrack : await openTrack(bytes, i);
+    if (track.codec !== codec) {
+      throw new Error('Chunk ' + i + ' codec ' + track.codec + ' != chunk 0 codec ' + codec);
+    }
+    const sink = new MB.EncodedPacketSink(track);
+    let firstOfChunk = true;
+    for await (const packet of sink.packets()) {
+      if (firstOfChunk && packet.type !== 'key') {
+        throw new Error('Chunk ' + i + ' does not start on a keyframe');
+      }
+      const shifted = packet.clone({ timestamp: packet.timestamp + offset });
+      await videoSource.add(shifted, firstOfChunk && i === 0 ? { decoderConfig } : undefined);
+      firstOfChunk = false;
+      packetCount++;
+    }
+    offset += CONFIG.parts[i].duration;
+  }
+
+  stage('finalize-output');
+  await output.finalize();
+  const buffer = output.target.buffer;
+  if (!buffer) throw new Error('Concat produced no output buffer');
+
+  stage('upload');
+  const res = await fetch(CONFIG.uploadUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': CONFIG.contentType },
+    body: buffer,
+  });
+  if (!res.ok) throw new Error('Upload failed: HTTP ' + res.status);
+
+  window.__renderComplete = {
+    success: true,
+    uploaded: true,
+    size: buffer.byteLength,
+    packetCount,
+  };
+})().catch((e) => {
+  window.__renderComplete = { success: false, error: String((e && e.stack) || e) };
+});
+</script>
+</body>
+</html>`;
+}
+
+// src/audioProducer.ts
+var CORE_AUDIO_CDN_URL = "https://esm.sh/@vosjs/core@0.23.1/audio?target=es2022";
+var STUDIO_ENTRY_ID = "vosso.studio";
+function studioEntryData(stack) {
+  if (stack == null || typeof stack !== "object") return null;
+  const asData = (value) => value && typeof value === "object" ? value : null;
+  if (Array.isArray(stack)) {
+    for (const entry of stack) {
+      if (entry && typeof entry === "object" && entry.id === STUDIO_ENTRY_ID) {
+        return asData(entry.data);
+      }
+    }
+    return null;
+  }
+  return asData(stack[STUDIO_ENTRY_ID]);
+}
+function audioProducerCode(options = {}) {
+  const coreAudioUrl = options.coreAudioUrl ?? CORE_AUDIO_CDN_URL;
+  const bakedPlan = options.plan ? `window.__vosAudioPlan__ = ${JSON.stringify(options.plan)};` : "";
+  return `
+${bakedPlan}
+window.__vosAudioProducer__ = async ({ data, plan, duration, sampleRate }) => {
+  const rate = sampleRate || 48000;
+  const audioPlan = plan === undefined ? window.__vosAudioPlan__ : plan;
+  const CORE_AUDIO_URL = ${JSON.stringify(coreAudioUrl)};
+
+  const decodeAudio = async (url) => {
+    try {
+      const buf = await (await fetch(url)).arrayBuffer();
+      const ac = new AudioContext();
+      try {
+        return await ac.decodeAudioData(buf);
+      } finally {
+        void ac.close();
+      }
+    } catch (e) {
+      console.warn('[audio-producer] source not decodable:', e);
+      return null;
+    }
+  };
+
+  // Cut mic audio to the kept source segments; rated segments resample
+  // piecewise with linear interpolation (tape-style pitch shift).
+  const spliceAudio = (buf, segments) => {
+    const sr = buf.sampleRate;
+    const pieces = segments.map((s) => {
+      const start = Math.max(0, Math.min(Math.round(s.in * sr), buf.length));
+      const end = Math.max(start, Math.min(Math.round(s.out * sr), buf.length));
+      const r = s.rate !== undefined && s.rate > 0 ? s.rate : 1;
+      return { start, end, rate: r, outLen: Math.round((end - start) / r) };
+    });
+    const total = pieces.reduce((sum, p) => sum + p.outLen, 0);
+    if (total <= 0) return buf;
+    if (pieces.length === 1 && pieces[0].start === 0 && pieces[0].rate === 1 && total === buf.length) {
+      return buf;
+    }
+    const out = new AudioBuffer({ length: total, numberOfChannels: buf.numberOfChannels, sampleRate: sr });
+    for (let ch = 0; ch < buf.numberOfChannels; ch++) {
+      const src = buf.getChannelData(ch);
+      const dst = out.getChannelData(ch);
+      let offset = 0;
+      for (const p of pieces) {
+        if (p.rate === 1) {
+          dst.set(src.subarray(p.start, p.end), offset);
+        } else {
+          const last = buf.length - 1;
+          for (let i = 0; i < p.outLen; i++) {
+            const pos = p.start + i * p.rate;
+            const j = Math.min(Math.floor(pos), last);
+            const a = src[j];
+            const b = src[Math.min(j + 1, last)];
+            dst[offset + i] = a + (b - a) * (pos - j);
+          }
+        }
+        offset += p.outLen;
+      }
+    }
+    return out;
+  };
+
+  const videoSrc = typeof data?.videoSrc === 'string' ? data.videoSrc : null;
+  const segments = Array.isArray(data?.segments) ? data.segments : [];
+  const tracks = audioPlan && Array.isArray(audioPlan.tracks) ? audioPlan.tracks : [];
+  const micGain = typeof data?.micGain === 'number' ? data.micGain : 1;
+  const sysGain = typeof data?.sysGain === 'number' ? data.sysGain : 1;
+  const micSrc = typeof data?.micSrc === 'string' ? data.micSrc : null;
+  // Voice: the mic sidecar (AT split), else the legacy track on the recording.
+  // System: the recording's own track, only when the take is split.
+  const voiceSrc = micSrc ?? (data?.hasAudio && videoSrc ? videoSrc : null);
+  const sysSrc = micSrc && data?.hasAudio && videoSrc ? videoSrc : null;
+
+  // Recording tracks load through a pluggable seam: a host page may
+  // install window.__vosStreamSplice__(url, segments, maxSeconds) \u2014 the
+  // audio mix page does, backed by mediabunny streaming decode of ONLY the
+  // needed source spans, capped at the output duration \u2014 and the producer
+  // prefers it, falling back to the whole-file decodeAudioData path on any
+  // failure. Standalone pages (single-flight capture) have no seam and
+  // behave exactly as before.
+  const loadRecordingTrack = async (url) => {
+    const streamSplice = window.__vosStreamSplice__;
+    if (streamSplice) {
+      try {
+        const buf = await streamSplice(url, segments, duration);
+        if (buf) return buf;
+      } catch (e) {
+        console.warn('[audio-producer] stream splice failed, falling back:', e);
+      }
+    }
+    const raw = await decodeAudio(url);
+    return raw && segments.length ? spliceAudio(raw, segments) : raw;
+  };
+
+  let mic = voiceSrc ? await loadRecordingTrack(voiceSrc) : null;
+  let sys = sysSrc ? await loadRecordingTrack(sysSrc) : null;
+
+  // The clips: decode each distinct plan source to plain PCM, then render
+  // the plan with the engine's mixer (one buffer, every clip at its
+  // interpolated position and gain, the duck curve already folded in).
+  const clipPcm = new Map();
+  for (const src of new Set(tracks.map((t) => t.src))) {
+    const buf = await decodeAudio(src);
+    if (!buf) continue;
+    const channels = [];
+    for (let c = 0; c < buf.numberOfChannels; c++) channels.push(buf.getChannelData(c));
+    clipPcm.set(src, { sampleRate: buf.sampleRate, length: buf.length, channels });
+  }
+  if (!mic && !sys && clipPcm.size === 0) return null;
+  // Voice-only at unity gain: skip the offline pass \u2014 but ONLY when the
+  // buffer fits the requested output duration. A spliced take can run longer
+  // than a duration-capped render asks for (Render API maxDuration), and
+  // returning it whole used to mux extra seconds of audio onto the video
+  // Overlong falls through to the offline render, whose
+  // length IS the duration by construction.
+  if (
+    clipPcm.size === 0 && mic && !sys && micGain === 1 &&
+    mic.length <= Math.ceil(duration * mic.sampleRate)
+  ) return mic;
+
+  const off = new OfflineAudioContext(2, Math.max(1, Math.ceil(duration * rate)), rate);
+  if (mic) {
+    const src = off.createBufferSource();
+    src.buffer = mic;
+    const gain = off.createGain();
+    gain.gain.value = micGain;
+    src.connect(gain);
+    gain.connect(off.destination);
+    src.start(0);
+  }
+  if (sys) {
+    const src = off.createBufferSource();
+    src.buffer = sys;
+    const gain = off.createGain();
+    gain.gain.value = sysGain;
+    src.connect(gain);
+    gain.connect(off.destination);
+    src.start(0);
+  }
+  if (clipPcm.size > 0) {
+    const { mixAudio } = await import(CORE_AUDIO_URL);
+    const pcm = mixAudio(audioPlan, clipPcm, { sampleRate: rate, channels: 2 });
+    const buf = off.createBuffer(pcm.channels.length, pcm.length, pcm.sampleRate);
+    for (let c = 0; c < pcm.channels.length; c++) buf.copyToChannel(pcm.channels[c], c);
+    const src = off.createBufferSource();
+    src.buffer = buf;
+    src.connect(off.destination);
+    src.start(0);
+  }
+  return off.startRendering();
+};
+`;
+}
+function dataHasAudio(data, stack, plan) {
+  const d = data != null && typeof data === "object" ? data : null;
+  const hasVoice = !!d && (typeof d.micSrc === "string" || !!d.hasAudio && typeof d.videoSrc === "string");
+  const entryAudio = studioEntryData(stack)?.audio;
+  const hasClips = !!plan && plan.tracks.length > 0 || Array.isArray(entryAudio) && entryAudio.length > 0;
+  return hasVoice || hasClips;
+}
+
+// src/audioMixPage.ts
+var MEDIABUNNY_URL2 = "https://esm.sh/mediabunny@1.27.3?target=es2022";
+function buildAudioMixPage(options) {
+  const config = JSON.stringify({
+    data: options.data,
+    plan: options.plan ?? null,
+    duration: options.duration,
+    uploadUrl: options.uploadUrl
+  });
+  return `<!doctype html>
+<html>
+<head><meta charset="utf-8"><title>vos audio mix</title></head>
+<body>
+<script type="module">
+const CONFIG = ${config};
+
+// Same stage contract as the finalize page: worker polls __finalizeStage,
+// reports the last stage on a silent death. Stage NAME stays the first
+// space-delimited token (renderPolicy.finalizeDeathStage parses it).
+const stage = (s) => {
+  const m = performance.memory;
+  window.__finalizeStage = m ? s + ' heap=' + Math.round(m.usedJSHeapSize / 1048576) + 'MB' : s;
+};
+stage('boot');
+
+;(async () => {
+  stage('import-mediabunny');
+  const MB = await import(${JSON.stringify(MEDIABUNNY_URL2)});
+
+  // Streaming splice seam consumed by the audio producer below: decode ONLY
+  // the source spans the segments keep, capped at maxSeconds of output.
+  // Mirrors spliceAudio's piece math (copy at rate 1, linear resample
+  // otherwise); the producer's whole-file path remains the authoritative
+  // fallback, so a divergence here degrades to slower, never to wrong.
+  window.__vosStreamSplice__ = async (url, segments, maxSeconds) => {
+    const input = new MB.Input({ formats: MB.ALL_FORMATS, source: new MB.UrlSource(url) });
+    try {
+      const track = await input.getPrimaryAudioTrack();
+      if (!track) return null;
+      if (!(await track.canDecode())) return null;
+      const sr = track.sampleRate;
+      const ch = Math.min(2, Math.max(1, track.numberOfChannels || 2));
+      const srcDur = await input.computeDuration();
+
+      const spans = Array.isArray(segments) && segments.length
+        ? segments
+        : [{ in: 0, out: srcDur }];
+      const pieces = [];
+      let outTotal = 0;
+      for (const s of spans) {
+        const start = Math.max(0, Math.min(s.in, srcDur));
+        const end = Math.max(start, Math.min(s.out, srcDur));
+        const rate = s.rate !== undefined && s.rate > 0 ? s.rate : 1;
+        let outLen = (end - start) / rate;
+        if (outTotal + outLen > maxSeconds) outLen = maxSeconds - outTotal;
+        if (outLen <= 0) break;
+        pieces.push({ in: start, out: start + outLen * rate, rate, outLen });
+        outTotal += outLen;
+        if (outTotal >= maxSeconds) break;
+      }
+      if (pieces.length === 0) return null;
+
+      const totalFrames = Math.max(1, Math.round(outTotal * sr));
+      const out = new AudioBuffer({ length: totalFrames, numberOfChannels: ch, sampleRate: sr });
+      const sink = new MB.AudioBufferSink(track);
+      let outOffset = 0;
+      for (let pi = 0; pi < pieces.length; pi++) {
+        const p = pieces[pi];
+        stage('voice-piece-' + pi);
+        // Materialize ONE piece's source span (bounded), then splice from it.
+        const pieceFrames = Math.max(1, Math.round((p.out - p.in) * sr));
+        const temp = [];
+        for (let c = 0; c < ch; c++) temp.push(new Float32Array(pieceFrames));
+        for await (const wrapped of sink.buffers(p.in, p.out)) {
+          const b = wrapped.buffer;
+          const at = Math.round((wrapped.timestamp - p.in) * sr);
+          for (let c = 0; c < ch; c++) {
+            const src = b.getChannelData(Math.min(c, b.numberOfChannels - 1));
+            let from = 0, to = at, n = src.length;
+            if (to < 0) { from = -to; to = 0; n -= from; }
+            n = Math.min(n, pieceFrames - to);
+            if (n > 0) temp[c].set(src.subarray(from, from + n), to);
+          }
+        }
+        const outFrames = Math.min(Math.round(p.outLen * sr), totalFrames - outOffset);
+        for (let c = 0; c < ch; c++) {
+          const dst = out.getChannelData(c);
+          const src = temp[c];
+          if (p.rate === 1) {
+            dst.set(src.subarray(0, Math.min(outFrames, src.length)), outOffset);
+          } else {
+            const last = src.length - 1;
+            for (let i = 0; i < outFrames; i++) {
+              const pos = i * p.rate;
+              const j = Math.min(Math.floor(pos), last);
+              const a = src[j];
+              const b2 = src[Math.min(j + 1, last)];
+              dst[outOffset + i] = a + (b2 - a) * (pos - j);
+            }
+          }
+        }
+        outOffset += outFrames;
+      }
+      return out;
+    } finally {
+      input.dispose();
+    }
+  };
+
+  ${audioProducerCode()}
+
+  stage('mix');
+  let mixed = await window.__vosAudioProducer__({
+    data: CONFIG.data,
+    plan: CONFIG.plan,
+    duration: CONFIG.duration,
+    sampleRate: 48000,
+  });
+  if (!mixed) {
+    // Every declared source failed to decode (fetch denied, undecodable
+    // bytes). Reporting "no buffer" here used to route finalize onto the
+    // browser concat fallback \u2014 whose in-page producer faces the SAME
+    // failures and whose page-memory concat is the known OOM death (job
+    // cdf6e026 died twice at concat-part-10 after this very branch). Land a
+    // duration-true SILENT track instead so the worker mux still runs: the
+    // audible outcome matches the client exporter's documented fail-open
+    // (a source that won't decode loses its sound, never the export).
+    console.warn('[audio-mix] no source decoded; landing a silent track');
+    mixed = new AudioBuffer({
+      length: Math.max(1, Math.ceil(CONFIG.duration * 48000)),
+      numberOfChannels: 2,
+      sampleRate: 48000,
+    });
+  }
+
+  stage('encode');
+  // Opus always: the fleet is Linux Chrome, which has no AAC encoder, and
+  // the worker mux stream-copies whatever codec arrives here.
+  const output = new MB.Output({ format: new MB.WebMOutputFormat(), target: new MB.BufferTarget() });
+  const source = new MB.AudioBufferSource({ codec: 'opus', bitrate: MB.QUALITY_HIGH });
+  output.addAudioTrack(source);
+  await output.start();
+  await source.add(mixed);
+  source.close();
+  await output.finalize();
+  const buffer = output.target.buffer;
+  if (!buffer) throw new Error('Audio encode produced no output buffer');
+
+  stage('upload');
+  const res = await fetch(CONFIG.uploadUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'audio/webm' },
+    body: buffer,
+  });
+  if (!res.ok) throw new Error('Upload failed: HTTP ' + res.status);
+
+  window.__renderComplete = { success: true, uploaded: true, size: buffer.byteLength };
+})().catch((e) => {
+  window.__renderComplete = { success: false, error: String((e && e.stack) || e) };
+});
+</script>
+</body>
+</html>`;
+}
+
+// src/imageDiffPage.ts
+function buildImageDiffPage(options) {
+  const config = JSON.stringify({
+    candidate: options.candidateUrl,
+    golden: options.goldenUrl
+  }).replace(/</g, "\\u003c");
+  return `<!doctype html>
+<html>
+<head><meta charset="utf-8"><title>vos golden diff</title></head>
+<body>
+<script type="module">
+const CONFIG = ${config};
+
+const load = (src) =>
+  new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => reject(new Error('image failed to load'));
+    img.src = src;
+  });
+
+;(async () => {
+  const [candidate, golden] = await Promise.all([
+    load(CONFIG.candidate),
+    load(CONFIG.golden),
+  ]);
+  if (candidate.width !== golden.width || candidate.height !== golden.height) {
+    throw new Error(
+      'size mismatch: candidate ' + candidate.width + 'x' + candidate.height +
+      ' vs golden ' + golden.width + 'x' + golden.height,
+    );
+  }
+  const draw = (img) => {
+    const canvas = document.createElement('canvas');
+    canvas.width = img.width;
+    canvas.height = img.height;
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height).data;
+  };
+  const a = draw(candidate);
+  const b = draw(golden);
+  let sum = 0;
+  let n = 0;
+  for (let i = 0; i < a.length; i += 4) {
+    for (let c = 0; c < 3; c++) {
+      const d = a[i + c] - b[i + c];
+      sum += d * d;
+      n++;
+    }
+  }
+  const rms = Math.sqrt(sum / n);
+  window.__renderComplete = {
+    success: true,
+    rms,
+    width: candidate.width,
+    height: candidate.height,
+  };
+})().catch((e) => {
+  window.__renderComplete = { success: false, error: String((e && e.message) || e) };
+});
+</script>
+</body>
+</html>`;
+}
+
+// src/digestPage.ts
+function buildDigestPage(options) {
+  const config = JSON.stringify(options).replace(/</g, "\\u003c");
+  return `<!doctype html>
+<html>
+<head><meta charset="utf-8"><title>vos digest</title><link rel="icon" href="data:,">
+<style>html,body{margin:0;background:#000}video{position:absolute;left:-99999px}</style>
+</head>
+<body>
+<script type="module">
+const cfg = ${config}
+const raf = () => new Promise((r) => requestAnimationFrame(r))
+const done = (v) => { window.__renderComplete = v }
+try {
+  // One page per job: the whole recording comes down once, then every seek
+  // is local (a network-backed paused <video> gets suspended within seconds).
+  const blob = await (await fetch(cfg.videoUrl)).blob()
+  const v = document.createElement('video')
+  v.muted = true
+  v.preload = 'auto'
+  v.src = URL.createObjectURL(blob)
+  document.body.appendChild(v)
+  await new Promise((res, rej) => {
+    v.addEventListener('loadeddata', () => res(), { once: true })
+    v.addEventListener('error', () => rej(new Error('video failed to load')), { once: true })
+  })
+  const settle = async () => {
+    const t0 = performance.now()
+    let last = ''
+    while (performance.now() - t0 < 4000) {
+      await raf()
+      if (!v.seeking && v.readyState >= 2) {
+        const now = v.currentTime.toFixed(3)
+        if (now === last) return
+        last = now
+      } else last = ''
+    }
+  }
+  const seek = async (t) => {
+    const target = Math.max(0, Math.min(t, Math.max(0, (v.duration || t) - 0.02)))
+    if (Math.abs(v.currentTime - target) > 0.0005 || v.readyState < 2) {
+      await new Promise((res) => {
+        const on = () => { v.removeEventListener('seeked', on); res() }
+        v.addEventListener('seeked', on)
+        v.currentTime = target
+      })
+    }
+    await settle()
+  }
+  const W = v.videoWidth
+  const H = v.videoHeight
+  const region = {
+    x: Math.max(0, Math.min(cfg.region.x, W)),
+    y: Math.max(0, Math.min(cfg.region.y, H)),
+    w: Math.max(1, Math.min(cfg.region.w, W - cfg.region.x)),
+    h: Math.max(1, Math.min(cfg.region.h, H - cfg.region.y)),
+  }
+
+  // Pass 1: motion bins, one per source second.
+  const bw = 64, bh = 36
+  const bc = document.createElement('canvas')
+  bc.width = bw; bc.height = bh
+  const bctx = bc.getContext('2d', { willReadFrequently: true })
+  let prev = null
+  const bins = []
+  const n = Math.max(1, Math.ceil(cfg.durationS))
+  for (let i = 0; i < n; i++) {
+    await seek(Math.min(cfg.durationS, i + 0.5))
+    bctx.drawImage(v, 0, 0, bw, bh)
+    const d = bctx.getImageData(0, 0, bw, bh).data
+    const luma = new Uint8ClampedArray(bw * bh)
+    for (let p = 0; p < luma.length; p++) {
+      const o = p * 4
+      luma[p] = (d[o] * 299 + d[o + 1] * 587 + d[o + 2] * 114) / 1000
+    }
+    if (!prev) bins.push(0)
+    else {
+      let changed = 0
+      for (let p = 0; p < luma.length; p++) if (Math.abs(luma[p] - prev[p]) > cfg.motionDelta) changed++
+      bins.push(Math.round((changed / luma.length) * 1000) / 1000)
+    }
+    prev = luma
+    window.__renderProgress = 0.4 * ((i + 1) / n)
+  }
+  const scenes = []
+  for (let i = 1; i < bins.length; i++) {
+    if (bins[i] >= cfg.scene.motion && bins[i - 1] <= cfg.scene.quiet) scenes.push(i)
+  }
+
+  // Pass 2: frames, crops, the sheet \u2014 each PUT as its own part.
+  const sizes = {}
+  const toPng = (c) => new Promise((res, rej) => c.toBlob((b) => (b ? res(b) : rej(new Error('toBlob failed'))), 'image/png'))
+  const put = async (name, body, type) => {
+    const r = await fetch(cfg.uploadUrl + '&part=digest-' + name, { method: 'PUT', headers: { 'content-type': type }, body })
+    if (!r.ok) throw new Error('upload of ' + name + ' failed: ' + r.status)
+  }
+  const save = async (name, c) => {
+    await put(name, await toPng(c), 'image/png')
+    sizes[name] = { width: c.width, height: c.height }
+  }
+  const fit = (w, h, max) => {
+    const s = Math.min(1, max / Math.max(w, h))
+    return { w: Math.max(1, Math.round(w * s)), h: Math.max(1, Math.round(h * s)) }
+  }
+  const draw = (src, sx, sy, sw, sh, max) => {
+    const c = document.createElement('canvas')
+    const f = fit(sw, sh, max)
+    c.width = f.w; c.height = f.h
+    c.getContext('2d').drawImage(src, sx, sy, sw, sh, 0, 0, f.w, f.h)
+    return c
+  }
+  const tiles = []
+  const shots = cfg.shots.map((s) => ({ ...s, scene: false }))
+  for (const s of scenes) shots.push({ name: 'scene-' + s, t: Math.min(cfg.durationS, s + 0.04), box: null, label: 'scene ' + s + 's', scene: true })
+  shots.sort((a, b) => a.t - b.t)
+  for (let i = 0; i < shots.length; i++) {
+    const s = shots[i]
+    await seek(s.t)
+    const full = draw(v, region.x, region.y, region.w, region.h, cfg.fullMax)
+    await save(s.name + '.full.png', full)
+    let tileSrc = full
+    if (s.box) {
+      const b = s.box
+      const crop = draw(v, b.x, b.y, b.w, b.h, cfg.cropMax)
+      await save(s.name + '.crop.png', crop)
+      tileSrc = crop
+    }
+    const tw = 240
+    const th = Math.max(1, Math.round((tw * tileSrc.height) / tileSrc.width))
+    const tile = document.createElement('canvas')
+    tile.width = tw; tile.height = th
+    tile.getContext('2d').drawImage(tileSrc, 0, 0, tw, th)
+    tiles.push({ label: s.label, c: tile })
+    window.__renderProgress = 0.4 + 0.55 * ((i + 1) / shots.length)
+  }
+  if (tiles.length) {
+    const cols = Math.min(6, tiles.length)
+    const tw = 240
+    const th = Math.max(...tiles.map((t) => t.c.height))
+    const rows = Math.ceil(tiles.length / cols)
+    const sheet = document.createElement('canvas')
+    sheet.width = cols * (tw + 8) + 8
+    sheet.height = rows * (th + 26) + 8
+    const ctx = sheet.getContext('2d')
+    ctx.fillStyle = '#111'
+    ctx.fillRect(0, 0, sheet.width, sheet.height)
+    ctx.font = '12px ui-monospace, Menlo, monospace'
+    tiles.forEach((t, i) => {
+      const x = 8 + (i % cols) * (tw + 8)
+      const y = 8 + Math.floor(i / cols) * (th + 26)
+      ctx.drawImage(t.c, x, y)
+      ctx.fillStyle = '#eee'
+      ctx.fillText(t.label, x, y + th + 16)
+    })
+    await save('sheet.png', sheet)
+  }
+  await put('manifest.json', new Blob([JSON.stringify({ width: W, height: H, bins, scenes, sizes })], { type: 'application/json' }), 'application/json')
+  done({ success: true, uploaded: true, bins: bins.length, shots: shots.length })
+} catch (e) {
+  done({ success: false, error: String((e && e.stack) || e) })
+}
+</script>
+</body>
+</html>`;
+}
+export {
+  CORE_AUDIO_CDN_URL,
+  DEFAULT_MIN_FRAMES_PER_CHUNK,
+  audioProducerCode,
+  buildAudioMixPage,
+  buildDigestPage,
+  buildFinalizeConcatPage,
+  buildImageDiffPage,
+  concatEncodedVideo,
+  countVideoPackets,
+  dataHasAudio,
+  muxEncodedExport,
+  planChunks,
+  studioEntryData
+};
+//# sourceMappingURL=index.js.map