@catlabtech/webcvt-transcode 0.2.0

package/dist/index.js

@@ -0,0 +1,1554 @@
+import { defaultRegistry, WebcvtError } from '@catlabtech/webcvt-core';
+import { probeVideoCodec, WebCodecsNotSupportedError, WebCodecsAudioDecoder, probeAudioDecoder, probeAudioCodec, probeVideoDecoder, WebCodecsVideoEncoder, WebCodecsVideoDecoder, WebCodecsAudioEncoder } from '@catlabtech/webcvt-codec-webcodecs';
+import { parseAdts, buildAudioSpecificConfig } from '@catlabtech/webcvt-container-aac';
+import { parseFlac, encodeBlockHeader, BLOCK_TYPE_STREAMINFO, STREAMINFO_SIZE, encodeStreamInfo } from '@catlabtech/webcvt-container-flac';
+import { parseMp3 } from '@catlabtech/webcvt-container-mp3';
+import { buildOpusHead, buildOpusTags, serializeOgg, parseOgg } from '@catlabtech/webcvt-container-ogg';
+import { parseWav, serializeWav } from '@catlabtech/webcvt-container-wav';
+import { serializeMkv, parseMkv, iterateVideoChunks as iterateVideoChunks$1, iterateAudioChunks as iterateAudioChunks$1 } from '@catlabtech/webcvt-container-mkv';
+import { parseMp4, findVideoTrack, iterateVideoSamples, findAudioTrack, deriveCodecString, iterateAudioSamplesAuto } from '@catlabtech/webcvt-container-mp4';
+import { serializeWebm, parseWebm, iterateVideoChunks, iterateAudioChunks } from '@catlabtech/webcvt-container-webm';
+
+// src/backend.ts
+var TranscodeUnsupportedError = class extends WebcvtError {
+  constructor(from, to) {
+    super(
+      "TRANSCODE_UNSUPPORTED",
+      `Transcode backend cannot convert ${from} \u2192 ${to}. This pair is not in the v1 matrix, or the required WebCodecs decoder/encoder is unavailable in this runtime.`
+    );
+    this.name = "TranscodeUnsupportedError";
+  }
+};
+var TranscodeInputTooLargeError = class extends WebcvtError {
+  constructor(size, max) {
+    super(
+      "TRANSCODE_INPUT_TOO_LARGE",
+      `Transcode input is ${size} bytes; maximum supported is ${max} bytes.`
+    );
+    this.name = "TranscodeInputTooLargeError";
+  }
+};
+var TranscodeDemuxError = class extends WebcvtError {
+  constructor(message, options) {
+    super("TRANSCODE_DEMUX_FAILED", `Transcode demux failed: ${message}`, options);
+    this.name = "TranscodeDemuxError";
+  }
+};
+var TranscodeCodecError = class extends WebcvtError {
+  constructor(message, options) {
+    super("TRANSCODE_CODEC_ERROR", `Transcode codec error: ${message}`, options);
+    this.name = "TranscodeCodecError";
+  }
+};
+var TranscodeMuxError = class extends WebcvtError {
+  constructor(message, options) {
+    super("TRANSCODE_MUX_FAILED", `Transcode mux failed: ${message}`, options);
+    this.name = "TranscodeMuxError";
+  }
+};
+
+// src/abort.ts
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw createAbortError();
+}
+function createAbortError() {
+  return new DOMException("The transcode was aborted.", "AbortError");
+}
+function isAbortError(err) {
+  return err instanceof DOMException && err.name === "AbortError";
+}
+function asCodecError(err, phase) {
+  if (isAbortError(err)) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new TranscodeCodecError(`${phase}: ${message}`, { cause: err });
+}
+
+// src/pcm.ts
+function readAudioDataPlanes(data) {
+  const frames = data.numberOfFrames;
+  const planes = [];
+  for (let ch = 0; ch < data.numberOfChannels; ch++) {
+    const plane = new Float32Array(frames);
+    data.copyTo(plane, { planeIndex: ch, format: "f32-planar" });
+    planes.push(plane);
+  }
+  return planes;
+}
+var PlanarAccumulator = class {
+  #perChannel = [];
+  #frames = 0;
+  #numChannels = 0;
+  #sampleRate = 0;
+  add(planes, sampleRate) {
+    if (this.#numChannels === 0) {
+      this.#numChannels = planes.length;
+      this.#sampleRate = sampleRate;
+      this.#perChannel = planes.map(() => []);
+    }
+    for (let ch = 0; ch < this.#numChannels; ch++) {
+      this.#perChannel[ch]?.push(planes[ch] ?? planes[0] ?? new Float32Array(0));
+    }
+    this.#frames += planes[0]?.length ?? 0;
+  }
+  finish(fallbackSampleRate, fallbackChannels) {
+    if (this.#numChannels === 0) {
+      return {
+        sampleRate: fallbackSampleRate,
+        numberOfChannels: fallbackChannels,
+        numberOfFrames: 0,
+        channels: Array.from({ length: fallbackChannels }, () => new Float32Array(0))
+      };
+    }
+    const channels = this.#perChannel.map((chunks) => concatFloat(chunks, this.#frames));
+    return {
+      sampleRate: this.#sampleRate,
+      numberOfChannels: this.#numChannels,
+      numberOfFrames: this.#frames,
+      channels
+    };
+  }
+};
+var WAVE_FORMAT_IEEE_FLOAT = 3;
+function wavToDecoded(file) {
+  const { format, audioData } = file;
+  const ch = Math.max(1, format.channels);
+  const bits = format.bitsPerSample;
+  const bytesPerSample = bits / 8;
+  const frameSize = bytesPerSample * ch;
+  const frames = frameSize > 0 ? Math.floor(audioData.length / frameSize) : 0;
+  const isFloat = format.audioFormat === WAVE_FORMAT_IEEE_FLOAT;
+  const view = new DataView(audioData.buffer, audioData.byteOffset, audioData.byteLength);
+  const channels = Array.from({ length: ch }, () => new Float32Array(frames));
+  for (let f = 0; f < frames; f++) {
+    for (let c = 0; c < ch; c++) {
+      const off = f * frameSize + c * bytesPerSample;
+      const target = channels[c];
+      if (target) target[f] = readSample(view, off, bits, isFloat);
+    }
+  }
+  return { sampleRate: format.sampleRate, numberOfChannels: ch, numberOfFrames: frames, channels };
+}
+function interleaveInt16(decoded) {
+  const { numberOfChannels: ch, numberOfFrames: n, channels } = decoded;
+  const out = new Uint8Array(n * ch * 2);
+  const view = new DataView(out.buffer);
+  let pos = 0;
+  for (let f = 0; f < n; f++) {
+    for (let c = 0; c < ch; c++) {
+      view.setInt16(pos, floatToInt16(channels[c]?.[f] ?? 0), true);
+      pos += 2;
+    }
+  }
+  return out;
+}
+function buildAudioData(decoded, startFrame, frameCount, timestampUs) {
+  const ch = decoded.numberOfChannels;
+  const data = new Float32Array(ch * frameCount);
+  for (let c = 0; c < ch; c++) {
+    const plane = decoded.channels[c];
+    if (plane) data.set(plane.subarray(startFrame, startFrame + frameCount), c * frameCount);
+  }
+  return new AudioData({
+    format: "f32-planar",
+    sampleRate: decoded.sampleRate,
+    numberOfFrames: frameCount,
+    numberOfChannels: ch,
+    timestamp: timestampUs,
+    data
+  });
+}
+function concatFloat(chunks, total) {
+  const out = new Float32Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+function floatToInt16(v) {
+  const s = Math.round(v * 32767);
+  return s < -32768 ? -32768 : s > 32767 ? 32767 : s;
+}
+function readSample(view, off, bits, isFloat) {
+  if (isFloat) {
+    return bits === 64 ? view.getFloat64(off, true) : view.getFloat32(off, true);
+  }
+  switch (bits) {
+    case 8:
+      return (view.getUint8(off) - 128) / 128;
+    case 16:
+      return view.getInt16(off, true) / 32768;
+    case 24: {
+      const b0 = view.getUint8(off);
+      const b1 = view.getUint8(off + 1);
+      const b2 = view.getUint8(off + 2);
+      let val = b0 | b1 << 8 | b2 << 16;
+      if (val & 8388608) val -= 16777216;
+      return val / 8388608;
+    }
+    case 32:
+      return view.getInt32(off, true) / 2147483648;
+    default:
+      return 0;
+  }
+}
+
+// src/decode.ts
+async function decodeToPcm(demux, ctx) {
+  throwIfAborted(ctx.signal);
+  if (demux.kind === "pcm") {
+    ctx.onProgress?.(1);
+    return demux.decoded;
+  }
+  const { config, chunks, sampleRate, numberOfChannels } = demux;
+  const acc = new PlanarAccumulator();
+  const decoder = new WebCodecsAudioDecoder({ config }, (data) => {
+    acc.add(readAudioDataPlanes(data), data.sampleRate);
+    data.close();
+  });
+  const onAbort = () => decoder.close();
+  ctx.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const total = chunks.length || 1;
+    for (let i = 0; i < chunks.length; i++) {
+      throwIfAborted(ctx.signal);
+      const spec = chunks[i];
+      if (!spec) continue;
+      decoder.decode(
+        new EncodedAudioChunk({
+          type: spec.type,
+          timestamp: spec.timestampUs,
+          duration: spec.durationUs,
+          data: spec.data
+        })
+      );
+      ctx.onProgress?.((i + 1) / total);
+    }
+    await decoder.flush();
+    throwIfAborted(ctx.signal);
+  } catch (err) {
+    throw asCodecError(err, "decode");
+  } finally {
+    ctx.signal?.removeEventListener("abort", onAbort);
+    decoder.close();
+  }
+  return acc.finish(sampleRate, numberOfChannels);
+}
+var US_PER_SEC = 1e6;
+var OPUS_RATE = 48e3;
+var NOMINAL_AUDIO_FRAME_US = 2e4;
+function demuxContainerVideo(family, bytes) {
+  return wrap(() => {
+    switch (family) {
+      case "mp4": {
+        const file = parseMp4(bytes);
+        return { video: mp4Video(file), audio: mp4Audio(file) };
+      }
+      case "webm": {
+        const file = parseWebm(bytes);
+        return { video: webmVideo(file), audio: webmAudio(file) };
+      }
+      case "mkv": {
+        const file = parseMkv(bytes);
+        return { video: mkvVideo(file), audio: mkvAudio(file) };
+      }
+    }
+  });
+}
+function demuxContainerAudioTrack(family, bytes) {
+  return wrap(() => {
+    let audio;
+    switch (family) {
+      case "mp4":
+        audio = mp4Audio(parseMp4(bytes));
+        break;
+      case "webm":
+        audio = webmAudio(parseWebm(bytes));
+        break;
+      case "mkv":
+        audio = mkvAudio(parseMkv(bytes));
+        break;
+    }
+    if (!audio) {
+      throw new TranscodeDemuxError(
+        `${family} container has no audio track decodable here (only AAC/Opus audio is supported)`
+      );
+    }
+    return audio;
+  });
+}
+function mp4Video(file) {
+  const track = findVideoTrack(file);
+  if (!track || track.sampleEntry.kind !== "video") {
+    throw new TranscodeDemuxError("mp4 has no video track");
+  }
+  const entry = track.sampleEntry.entry;
+  const config = {
+    codec: entry.codecString,
+    description: entry.codecConfig.bytes,
+    codedWidth: entry.width,
+    codedHeight: entry.height
+  };
+  const chunks = [];
+  for (const s of iterateVideoSamples(track, file.fileBytes)) {
+    chunks.push({
+      type: s.isKeyframe ? "key" : "delta",
+      timestampUs: Math.round(s.presentationTimeUs),
+      durationUs: Math.round(s.durationUs),
+      data: s.data
+    });
+  }
+  if (chunks.length === 0) throw new TranscodeDemuxError("mp4 video track has no samples");
+  return {
+    config,
+    chunks,
+    width: entry.width,
+    height: entry.height,
+    frameRate: estimateFrameRate(chunks),
+    codec: mp4VideoCodec(entry.format)
+  };
+}
+function mp4Audio(file) {
+  const track = findAudioTrack(file);
+  if (!track || track.sampleEntry.kind !== "audio") return null;
+  const entry = track.sampleEntry.entry;
+  const codec = deriveCodecString(entry.objectTypeIndication, entry.decoderSpecificInfo);
+  const numberOfChannels = Math.max(1, entry.channelCount);
+  const sampleRate = entry.sampleRate;
+  const chunks = [];
+  for (const s of iterateAudioSamplesAuto(file, track)) {
+    chunks.push({
+      type: "key",
+      timestampUs: Math.round(s.timestampUs),
+      durationUs: Math.round(s.durationUs),
+      data: s.data
+    });
+  }
+  if (chunks.length === 0) return null;
+  return {
+    config: { codec, description: entry.decoderSpecificInfo, sampleRate, numberOfChannels },
+    chunks,
+    sampleRate,
+    numberOfChannels
+  };
+}
+function mp4VideoCodec(format) {
+  if (format.startsWith("avc")) return "h264";
+  if (format.startsWith("hev") || format.startsWith("hvc")) return "hevc";
+  if (format === "vp09") return "vp9";
+  if (format === "av01") return "av1";
+  return "h264";
+}
+function webmVideo(file) {
+  const track = file.tracks.find((t) => t.trackType === 1);
+  if (!track) throw new TranscodeDemuxError("webm has no video track");
+  const { codec, config } = webmVideoConfig(track);
+  const chunks = collectVideoChunks(iterateVideoChunks(file, track.trackNumber));
+  if (chunks.length === 0) throw new TranscodeDemuxError("webm video track has no blocks");
+  return {
+    config,
+    chunks,
+    width: track.pixelWidth,
+    height: track.pixelHeight,
+    frameRate: estimateFrameRate(chunks),
+    codec
+  };
+}
+function webmVideoConfig(track) {
+  const base = { codedWidth: track.pixelWidth, codedHeight: track.pixelHeight };
+  switch (track.codecId) {
+    case "V_VP8":
+      return { codec: "vp8", config: { codec: "vp8", ...base } };
+    case "V_VP9":
+      return { codec: "vp9", config: { codec: "vp09.00.10.08", ...base } };
+    case "V_AV01":
+      return {
+        codec: "av1",
+        config: {
+          codec: "av01.0.04M.08",
+          ...track.codecPrivate ? { description: track.codecPrivate } : {},
+          ...base
+        }
+      };
+  }
+}
+function webmAudio(file) {
+  const track = file.tracks.find((t) => t.trackType === 2);
+  if (!track) return null;
+  if (track.codecId !== "A_OPUS") return null;
+  const numberOfChannels = Math.max(1, track.channels);
+  const chunks = deriveAudioDurations(
+    collectAudioChunks(iterateAudioChunks(file, track.trackNumber))
+  );
+  if (chunks.length === 0) return null;
+  return {
+    config: {
+      codec: "opus",
+      description: track.codecPrivate,
+      sampleRate: OPUS_RATE,
+      numberOfChannels
+    },
+    chunks,
+    sampleRate: OPUS_RATE,
+    numberOfChannels
+  };
+}
+function mkvVideo(file) {
+  const track = file.tracks.find((t) => t.trackType === 1);
+  if (!track) throw new TranscodeDemuxError("mkv has no video track");
+  const config = {
+    codec: track.webcodecsCodecString,
+    ...mkvNeedsDescription(track.codecId) && track.codecPrivate ? { description: track.codecPrivate } : {},
+    codedWidth: track.pixelWidth,
+    codedHeight: track.pixelHeight
+  };
+  const chunks = collectVideoChunks(iterateVideoChunks$1(file, track.trackNumber));
+  if (chunks.length === 0) throw new TranscodeDemuxError("mkv video track has no blocks");
+  return {
+    config,
+    chunks,
+    width: track.pixelWidth,
+    height: track.pixelHeight,
+    frameRate: estimateFrameRate(chunks),
+    codec: mkvVideoCodec(track.codecId)
+  };
+}
+function mkvAudio(file) {
+  const track = file.tracks.find((t) => t.trackType === 2);
+  if (!track) return null;
+  let config;
+  let sampleRate;
+  const numberOfChannels = Math.max(1, track.channels);
+  if (track.codecId === "A_OPUS") {
+    sampleRate = OPUS_RATE;
+    config = { codec: "opus", description: track.codecPrivate, sampleRate, numberOfChannels };
+  } else if (track.codecId === "A_AAC") {
+    sampleRate = track.samplingFrequency;
+    config = {
+      codec: track.webcodecsCodecString,
+      description: track.codecPrivate,
+      sampleRate,
+      numberOfChannels
+    };
+  } else {
+    return null;
+  }
+  const chunks = deriveAudioDurations(
+    collectAudioChunks(iterateAudioChunks$1(file, track.trackNumber))
+  );
+  if (chunks.length === 0) return null;
+  return { config, chunks, sampleRate, numberOfChannels };
+}
+function mkvNeedsDescription(codecId) {
+  return codecId === "V_MPEG4/ISO/AVC" || codecId === "V_MPEGH/ISO/HEVC" || codecId === "V_AV01";
+}
+function mkvVideoCodec(codecId) {
+  switch (codecId) {
+    case "V_MPEG4/ISO/AVC":
+      return "h264";
+    case "V_MPEGH/ISO/HEVC":
+      return "hevc";
+    case "V_VP8":
+      return "vp8";
+    case "V_VP9":
+      return "vp9";
+    case "V_AV01":
+      return "av1";
+  }
+}
+function collectVideoChunks(gen) {
+  const raw = [...gen];
+  const specs = [];
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (!c) continue;
+    const next = raw[i + 1];
+    const durationUs = next ? Math.max(1, next.timestampUs - c.timestampUs) : specs.at(-1)?.durationUs ?? NOMINAL_AUDIO_FRAME_US;
+    specs.push({ type: c.type, timestampUs: c.timestampUs, durationUs, data: c.data });
+  }
+  return specs;
+}
+function collectAudioChunks(gen) {
+  return [...gen].map((c) => ({
+    type: "key",
+    timestampUs: c.timestampUs,
+    durationUs: 0,
+    // filled by deriveAudioDurations
+    data: c.data
+  }));
+}
+function deriveAudioDurations(chunks) {
+  return chunks.map((c, i) => {
+    const next = chunks[i + 1];
+    const durationUs = next ? Math.max(1, next.timestampUs - c.timestampUs) : chunks[i - 1] ? Math.max(1, c.timestampUs - (chunks[i - 1]?.timestampUs ?? 0)) : NOMINAL_AUDIO_FRAME_US;
+    return { ...c, durationUs };
+  });
+}
+function estimateFrameRate(chunks) {
+  if (chunks.length < 2) return 0;
+  const first = chunks[0];
+  const last = chunks[chunks.length - 1];
+  if (!first || !last) return 0;
+  const spanUs = last.timestampUs + last.durationUs - first.timestampUs;
+  if (spanUs <= 0) return 0;
+  return Math.round(chunks.length / spanUs * US_PER_SEC);
+}
+function wrap(run) {
+  try {
+    return run();
+  } catch (err) {
+    if (err instanceof TranscodeDemuxError) throw err;
+    throw new TranscodeDemuxError(err instanceof Error ? err.message : String(err), { cause: err });
+  }
+}
+
+// src/demux.ts
+var US_PER_SEC2 = 1e6;
+function demuxAudio(inputCodec, bytes) {
+  try {
+    switch (inputCodec) {
+      case "pcm":
+        return { kind: "pcm", decoded: wavToDecoded(parseWav(bytes)) };
+      case "mp3":
+        return demuxMp3(bytes);
+      case "aac":
+        return demuxAac(bytes);
+      case "flac":
+        return demuxFlac(bytes);
+      case "opus":
+        return demuxOpus(bytes);
+      default:
+        throw new TranscodeDemuxError(`no demuxer for input codec "${inputCodec}"`);
+    }
+  } catch (err) {
+    if (err instanceof TranscodeDemuxError) throw err;
+    throw new TranscodeDemuxError(err instanceof Error ? err.message : String(err), { cause: err });
+  }
+}
+function demuxContainerAudio(family, bytes) {
+  const track = demuxContainerAudioTrack(family, bytes);
+  return {
+    kind: "encoded",
+    config: track.config,
+    chunks: track.chunks,
+    sampleRate: track.sampleRate,
+    numberOfChannels: track.numberOfChannels
+  };
+}
+function demuxMp3(bytes) {
+  const { frames } = parseMp3(bytes);
+  if (frames.length === 0) throw new TranscodeDemuxError("mp3 has no audio frames");
+  const first = frames[0]?.header;
+  if (!first) throw new TranscodeDemuxError("mp3 has no audio frames");
+  const sampleRate = first.sampleRate;
+  const numberOfChannels = first.channelMode === "mono" ? 1 : 2;
+  const chunks = [];
+  let sample = 0;
+  for (const frame of frames) {
+    const spf = frame.header.samplesPerFrame;
+    chunks.push({
+      type: "key",
+      timestampUs: Math.round(sample / sampleRate * US_PER_SEC2),
+      durationUs: Math.round(spf / sampleRate * US_PER_SEC2),
+      data: frame.data
+    });
+    sample += spf;
+  }
+  return {
+    kind: "encoded",
+    config: { codec: "mp3", sampleRate, numberOfChannels },
+    chunks,
+    sampleRate,
+    numberOfChannels
+  };
+}
+var AAC_SAMPLES_PER_FRAME = 1024;
+function demuxAac(bytes) {
+  const { frames } = parseAdts(bytes);
+  if (frames.length === 0) throw new TranscodeDemuxError("aac has no ADTS frames");
+  const header = frames[0]?.header;
+  if (!header) throw new TranscodeDemuxError("aac has no ADTS frames");
+  const sampleRate = header.sampleRate;
+  const numberOfChannels = Math.max(1, header.channelConfiguration);
+  const description = buildAudioSpecificConfig(header);
+  const chunks = [];
+  let sample = 0;
+  for (const frame of frames) {
+    const headerSize = frame.header.hasCrc ? 9 : 7;
+    chunks.push({
+      type: "key",
+      timestampUs: Math.round(sample / sampleRate * US_PER_SEC2),
+      durationUs: Math.round(AAC_SAMPLES_PER_FRAME / sampleRate * US_PER_SEC2),
+      data: frame.data.subarray(headerSize)
+      // raw AU (strip ADTS header)
+    });
+    sample += AAC_SAMPLES_PER_FRAME;
+  }
+  return {
+    kind: "encoded",
+    config: { codec: "mp4a.40.2", sampleRate, numberOfChannels, description },
+    chunks,
+    sampleRate,
+    numberOfChannels
+  };
+}
+function demuxFlac(bytes) {
+  const { streamInfo, frames } = parseFlac(bytes);
+  if (frames.length === 0) throw new TranscodeDemuxError("flac has no frames");
+  const sampleRate = streamInfo.sampleRate;
+  const numberOfChannels = streamInfo.channels;
+  const description = buildFlacDescription(streamInfo);
+  const chunks = [];
+  for (const frame of frames) {
+    chunks.push({
+      type: "key",
+      timestampUs: Math.round(frame.sampleNumber / sampleRate * US_PER_SEC2),
+      durationUs: Math.round(frame.blockSize / sampleRate * US_PER_SEC2),
+      data: frame.data
+    });
+  }
+  return {
+    kind: "encoded",
+    config: { codec: "flac", sampleRate, numberOfChannels, description },
+    chunks,
+    sampleRate,
+    numberOfChannels
+  };
+}
+function buildFlacDescription(info) {
+  const magic = new Uint8Array([102, 76, 97, 67]);
+  const header = encodeBlockHeader(true, BLOCK_TYPE_STREAMINFO, STREAMINFO_SIZE);
+  const body = encodeStreamInfo(info);
+  const out = new Uint8Array(magic.length + header.length + body.length);
+  out.set(magic, 0);
+  out.set(header, magic.length);
+  out.set(body, magic.length + header.length);
+  return out;
+}
+var OPUS_RATE2 = 48e3;
+var OPUS_NOMINAL_FRAME = 960;
+function demuxOpus(bytes) {
+  const { streams } = parseOgg(bytes);
+  const stream = streams[0];
+  if (!stream) throw new TranscodeDemuxError("ogg has no logical stream");
+  if (stream.codec !== "opus") {
+    throw new TranscodeDemuxError(
+      `ogg stream codec "${stream.codec}" is not decodable here (only opus-in-ogg is supported)`
+    );
+  }
+  const numberOfChannels = Math.max(1, stream.channels);
+  const chunks = [];
+  let sample = 0;
+  for (const pkt of stream.packets) {
+    let end = sample + OPUS_NOMINAL_FRAME;
+    if (pkt.granulePosition >= 0n) {
+      const g = Number(pkt.granulePosition);
+      if (g > sample) end = g;
+    }
+    const durationSamples = Math.max(1, end - sample);
+    chunks.push({
+      type: "key",
+      timestampUs: Math.round(sample / OPUS_RATE2 * US_PER_SEC2),
+      durationUs: Math.round(durationSamples / OPUS_RATE2 * US_PER_SEC2),
+      data: pkt.data
+    });
+    sample = end;
+  }
+  return {
+    kind: "encoded",
+    config: {
+      codec: "opus",
+      sampleRate: OPUS_RATE2,
+      numberOfChannels,
+      description: stream.identification
+    },
+    chunks,
+    sampleRate: OPUS_RATE2,
+    numberOfChannels
+  };
+}
+function encodeWav(decoded) {
+  const audioData = interleaveInt16(decoded);
+  const channels = Math.max(1, decoded.numberOfChannels);
+  const bitsPerSample = 16;
+  const blockAlign = channels * bitsPerSample / 8;
+  const file = {
+    format: {
+      audioFormat: 1,
+      channels,
+      sampleRate: decoded.sampleRate,
+      bitsPerSample,
+      blockAlign,
+      byteRate: decoded.sampleRate * blockAlign
+    },
+    audioData
+  };
+  return serializeWav(file);
+}
+async function encodeAudioChunks(decoded, config, ctx) {
+  throwIfAborted(ctx.signal);
+  const out = [];
+  let description;
+  const encoder = new WebCodecsAudioEncoder({ config }, (chunk, metadata) => {
+    const bytes = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(bytes);
+    out.push({
+      data: bytes,
+      timestampUs: chunk.timestamp,
+      durationUs: chunk.duration ?? 0
+    });
+    const desc = metadata?.decoderConfig?.description;
+    if (description === void 0 && desc !== void 0) {
+      description = new Uint8Array(
+        desc instanceof ArrayBuffer ? desc : desc.buffer,
+        desc instanceof ArrayBuffer ? 0 : desc.byteOffset,
+        desc instanceof ArrayBuffer ? desc.byteLength : desc.byteLength
+      ).slice();
+    }
+  });
+  const onAbort = () => encoder.close();
+  ctx.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const framesPerChunk = Math.max(1, Math.round(decoded.sampleRate / 50));
+    const total = decoded.numberOfFrames || 1;
+    for (let start = 0; start < decoded.numberOfFrames; start += framesPerChunk) {
+      throwIfAborted(ctx.signal);
+      const count = Math.min(framesPerChunk, decoded.numberOfFrames - start);
+      const timestampUs = Math.round(start / decoded.sampleRate * 1e6);
+      encoder.encode(buildAudioData(decoded, start, count, timestampUs));
+      ctx.onProgress?.(Math.min(1, (start + count) / total));
+    }
+    await encoder.flush();
+    throwIfAborted(ctx.signal);
+  } catch (err) {
+    throw asCodecError(err, "encode");
+  } finally {
+    ctx.signal?.removeEventListener("abort", onAbort);
+    encoder.close();
+  }
+  return { chunks: out, description };
+}
+var OPUS_RATE3 = 48e3;
+var OPUS_PRE_SKIP = 3840;
+var OGG_SERIAL = 1;
+var WEBM_TIMECODE_SCALE = 1e6;
+var WEBM_CLUSTER_MAX_TICKS = 3e4;
+function encodeOpusChunks(decoded, opts, ctx) {
+  return encodeOpus(decoded, opts, ctx);
+}
+async function encodeOpus(decoded, opts, ctx) {
+  const config = {
+    codec: "opus",
+    sampleRate: decoded.sampleRate,
+    numberOfChannels: Math.max(1, decoded.numberOfChannels),
+    ...opts.bitrate ? { bitrate: opts.bitrate } : {}
+  };
+  const { chunks } = await encodeAudioChunks(decoded, config, ctx);
+  return chunks;
+}
+async function encodeOpusOgg(decoded, opts, ctx) {
+  const channels = Math.max(1, decoded.numberOfChannels);
+  const chunks = await encodeOpus(decoded, opts, ctx);
+  const identification = buildOpusHead({
+    channelCount: channels,
+    preSkip: OPUS_PRE_SKIP,
+    inputSampleRate: decoded.sampleRate
+  });
+  const comments = buildOpusTags("webcvt-transcode", [
+    { key: "ENCODER", value: "webcvt-transcode" }
+  ]);
+  const packets = chunks.map((c) => ({
+    data: c.data,
+    // Opus granule = decoded 48 kHz samples (incl. pre-skip) at packet end.
+    granulePosition: BigInt(
+      Math.round((c.timestampUs + c.durationUs) / 1e6 * OPUS_RATE3) + OPUS_PRE_SKIP
+    ),
+    serialNumber: OGG_SERIAL
+  }));
+  const file = {
+    streams: [
+      {
+        serialNumber: OGG_SERIAL,
+        codec: "opus",
+        identification,
+        comments,
+        setup: void 0,
+        packets,
+        preSkip: OPUS_PRE_SKIP,
+        sampleRate: OPUS_RATE3,
+        channels
+      }
+    ]
+  };
+  return serializeOgg(file);
+}
+async function encodeOpusWebm(decoded, opts, ctx) {
+  const channels = Math.max(1, decoded.numberOfChannels);
+  const chunks = await encodeOpus(decoded, opts, ctx);
+  const codecPrivate = buildOpusHead({
+    channelCount: channels,
+    preSkip: OPUS_PRE_SKIP,
+    inputSampleRate: decoded.sampleRate
+  });
+  const clusters = [];
+  let current = null;
+  for (const c of chunks) {
+    const tick = BigInt(Math.round(c.timestampUs / 1e3));
+    if (current === null || tick - current.timecode > BigInt(WEBM_CLUSTER_MAX_TICKS)) {
+      current = { fileOffset: 0, timecode: tick, blocks: [] };
+      clusters.push(current);
+    }
+    current.blocks.push({
+      trackNumber: 1,
+      timestampNs: tick * BigInt(WEBM_TIMECODE_SCALE),
+      keyframe: true,
+      invisible: false,
+      discardable: false,
+      frames: [c.data]
+    });
+  }
+  const track = {
+    trackNumber: 1,
+    trackUid: 1n,
+    trackType: 2,
+    codecId: "A_OPUS",
+    codecPrivate,
+    samplingFrequency: OPUS_RATE3,
+    channels
+  };
+  const file = {
+    ebmlHeader: {
+      ebmlVersion: 1,
+      ebmlReadVersion: 1,
+      ebmlMaxIdLength: 4,
+      ebmlMaxSizeLength: 8,
+      docType: "webm",
+      docTypeVersion: 4,
+      docTypeReadVersion: 2
+    },
+    segmentPayloadOffset: 0,
+    // placeholder — ignored on write.
+    info: {
+      timecodeScale: WEBM_TIMECODE_SCALE,
+      muxingApp: "webcvt-transcode",
+      writingApp: "webcvt-transcode"
+    },
+    tracks: [track],
+    clusters,
+    fileBytes: new Uint8Array(0)
+    // placeholder — ignored on write.
+  };
+  return serializeWebm(file);
+}
+async function encodeAac(decoded, opts, ctx) {
+  const config = {
+    codec: "mp4a.40.2",
+    sampleRate: decoded.sampleRate,
+    numberOfChannels: Math.max(1, decoded.numberOfChannels),
+    ...opts.bitrate ? { bitrate: opts.bitrate } : {},
+    // Ask the encoder for self-framed ADTS output so concatenation is a valid
+    // .aac file (no container muxer needed).
+    aac: { format: "adts" }
+  };
+  const { chunks } = await encodeAudioChunks(decoded, config, ctx);
+  return concatBytes(chunks.map((c) => c.data));
+}
+async function encodeFlac(decoded, _opts, ctx) {
+  const config = {
+    codec: "flac",
+    sampleRate: decoded.sampleRate,
+    numberOfChannels: Math.max(1, decoded.numberOfChannels)
+  };
+  const { chunks, description } = await encodeAudioChunks(decoded, config, ctx);
+  if (description === void 0) {
+    throw new TranscodeCodecError(
+      "flac encoder did not supply a stream header (decoderConfig.description); cannot mux FLAC"
+    );
+  }
+  return concatBytes([description, ...chunks.map((c) => c.data)]);
+}
+function concatBytes(parts) {
+  const total = parts.reduce((s, p) => s + p.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+
+// src/matrix.ts
+var INPUT_CODECS = Object.freeze({
+  "audio/wav": "pcm",
+  "audio/x-wav": "pcm",
+  "audio/wave": "pcm",
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/x-mpeg": "mp3",
+  "audio/aac": "aac",
+  "audio/x-aac": "aac",
+  "audio/ogg": "opus",
+  "audio/opus": "opus",
+  "audio/flac": "flac",
+  "audio/x-flac": "flac"
+});
+var OUTPUT_TARGETS = Object.freeze({
+  "audio/wav": { container: "wav", codec: "pcm" },
+  "audio/x-wav": { container: "wav", codec: "pcm" },
+  "audio/wave": { container: "wav", codec: "pcm" },
+  "audio/ogg": { container: "ogg", codec: "opus" },
+  "audio/opus": { container: "ogg", codec: "opus" },
+  "audio/webm": { container: "webm", codec: "opus" },
+  "audio/aac": { container: "aac", codec: "aac" },
+  "audio/flac": { container: "flac", codec: "flac" }
+});
+var TRANSCODE_MATRIX = Object.freeze(
+  new Set(
+    Object.keys(INPUT_CODECS).flatMap(
+      (inMime) => Object.keys(OUTPUT_TARGETS).map((outMime) => `${inMime}|${outMime}`)
+    )
+  )
+);
+function matrixKey(inputMime, outputMime) {
+  return `${inputMime}|${outputMime}`;
+}
+function inputCodecFor(mime) {
+  return INPUT_CODECS[mime];
+}
+function outputTargetFor(mime) {
+  return OUTPUT_TARGETS[mime];
+}
+var CONTAINER_INPUTS = Object.freeze({
+  "video/mp4": "mp4",
+  "audio/mp4": "mp4",
+  // m4a — audio-only track extraction
+  "video/webm": "webm",
+  "audio/webm": "webm",
+  // webm audio-only extraction
+  "video/x-matroska": "mkv",
+  "video/mkv": "mkv"
+});
+var VIDEO_TARGETS = Object.freeze({
+  "video/webm": { container: "webm" },
+  "video/x-matroska": { container: "mkv" },
+  "video/mkv": { container: "mkv" }
+});
+var CONTAINER_AUDIO_CODEC = Object.freeze({ mp4: "aac", webm: "opus", mkv: "opus" });
+var CONTAINER_VIDEO_CODEC = Object.freeze({ mp4: "h264", webm: "vp9", mkv: "h264" });
+function containerFamilyFor(mime) {
+  return CONTAINER_INPUTS[mime];
+}
+function videoTargetFor(mime) {
+  return VIDEO_TARGETS[mime];
+}
+var DEFAULT_QUALITY = 0.7;
+var MAX_INPUT_BYTES = 256 * 1024 * 1024;
+function resolveBitrate(codec, quality, channels) {
+  const q = clamp01(quality);
+  let stereo;
+  switch (codec) {
+    case "opus":
+      stereo = ladder(q, 64e3, 128e3, 256e3);
+      break;
+    case "aac":
+      stereo = ladder(q, 96e3, 128e3, 256e3);
+      break;
+    default:
+      return void 0;
+  }
+  const scale = channels <= 1 ? 0.6 : 1;
+  return Math.round(stereo * scale);
+}
+function resolveVideoBitrate(width, height, quality, codec) {
+  const q = clamp01(quality);
+  const pixels = Math.max(1, width) * Math.max(1, height);
+  const ratio = pixels / (1280 * 720);
+  const base = VP9_720P_BPS * ratio;
+  const scale = q <= DEFAULT_QUALITY ? 0.6 + 0.4 * q / DEFAULT_QUALITY : 1 + 0.4 * (q - DEFAULT_QUALITY) / (1 - DEFAULT_QUALITY);
+  const codecFactor = codec === "vp8" ? 1.3 : 1;
+  return Math.max(VIDEO_MIN_BPS, Math.round(base * scale * codecFactor));
+}
+var VP9_720P_BPS = 3e6;
+var VIDEO_MIN_BPS = 1e5;
+function clamp01(v) {
+  if (Number.isNaN(v)) return DEFAULT_QUALITY;
+  return Math.max(0, Math.min(1, v));
+}
+function ladder(q, lo, mid, hi) {
+  const KNEE = DEFAULT_QUALITY;
+  if (q <= KNEE) return lo + (mid - lo) * q / KNEE;
+  return mid + (hi - mid) * (q - KNEE) / (1 - KNEE);
+}
+var ProbeCache = class {
+  #decode = /* @__PURE__ */ new Map();
+  #encode = /* @__PURE__ */ new Map();
+  #videoDecode = /* @__PURE__ */ new Map();
+  #videoEncode = /* @__PURE__ */ new Map();
+  /** True iff the current runtime can DECODE `codec`. Memoised. */
+  async canDecode(codec, hints = {}) {
+    const cached = this.#decode.get(codec);
+    if (cached !== void 0) return cached;
+    const ok = await probeSafely(() => probeAudioDecoder({ codec, ...hints }));
+    this.#decode.set(codec, ok);
+    return ok;
+  }
+  /** True iff the current runtime can ENCODE `codec` (probeAudioCodec). Memoised. */
+  async canEncode(codec, hints = {}) {
+    const cached = this.#encode.get(codec);
+    if (cached !== void 0) return cached;
+    const ok = await probeSafely(() => probeAudioCodec({ codec, ...hints }));
+    this.#encode.set(codec, ok);
+    return ok;
+  }
+  /** True iff the current runtime can DECODE video `codec`. Memoised. */
+  async canDecodeVideo(codec) {
+    const cached = this.#videoDecode.get(codec);
+    if (cached !== void 0) return cached;
+    const ok = await probeSafely(() => probeVideoDecoder({ codec }));
+    this.#videoDecode.set(codec, ok);
+    return ok;
+  }
+  /**
+   * Full encode probe for a video `codec` at the given geometry — returns the
+   * {@link ProbeResult} (with `hardwareAccelerated`) or `null` when unsupported
+   * / no WebCodecs. Memoised by codec + geometry so `canHandle` (default dims)
+   * and the pipeline (real dims) each cache their own lookup.
+   */
+  async probeEncodeVideo(codec, hints = {}) {
+    const key = `${codec}:${hints.width ?? 0}x${hints.height ?? 0}`;
+    const cached = this.#videoEncode.get(key);
+    if (cached !== void 0) return cached;
+    let result;
+    try {
+      const r = await probeVideoCodec({ codec, ...hints });
+      result = r.supported ? r : null;
+    } catch (err) {
+      if (err instanceof WebCodecsNotSupportedError) result = null;
+      else throw err;
+    }
+    this.#videoEncode.set(key, result);
+    return result;
+  }
+  /** True iff the current runtime can ENCODE video `codec`. Memoised. */
+  async canEncodeVideo(codec, hints = {}) {
+    return await this.probeEncodeVideo(codec, hints) !== null;
+  }
+};
+async function probeSafely(run) {
+  try {
+    const result = await run();
+    return result.supported;
+  } catch (err) {
+    if (err instanceof WebCodecsNotSupportedError) return false;
+    throw err;
+  }
+}
+var KEYFRAME_INTERVAL_US = 2e6;
+var WEBM_TIMECODE_SCALE2 = 1e6;
+var CLUSTER_MAX_TICKS = 3e4;
+var VIDEO_TRACK = 1;
+var AUDIO_TRACK = 2;
+async function transcodeVideo(family, outputContainer, bytes, probes, opts) {
+  const { signal } = opts;
+  const emit = monotone(opts.onProgress);
+  emit(0, "demux");
+  const demux = demuxContainerVideo(family, bytes);
+  emit(5, "demux");
+  throwIfAborted(signal);
+  const { videoCodec, codecString, hardwareAccelerated } = await selectVideoEncoder(
+    demux.video,
+    probes,
+    opts.hardwareAcceleration
+  );
+  const audioPlan = await planAudio(demux.audio, probes);
+  const videoCap = audioPlan ? 60 : 90;
+  emit(5, "decode");
+  const videoOut = await encodeVideoTrack(demux, videoCodec, codecString, {
+    signal,
+    hardwareAcceleration: opts.hardwareAcceleration,
+    quality: opts.quality,
+    onEncoded: (fraction) => emit(5 + fraction * (videoCap - 5), "encode")
+  });
+  throwIfAborted(signal);
+  let audioOut = null;
+  let audioChannels = 2;
+  if (audioPlan) {
+    emit(videoCap, "decode");
+    const decoded = await decodeToPcm(
+      {
+        kind: "encoded",
+        config: audioPlan.track.config,
+        chunks: audioPlan.track.chunks,
+        sampleRate: audioPlan.track.sampleRate,
+        numberOfChannels: audioPlan.track.numberOfChannels
+      },
+      { signal, onProgress: (f) => emit(videoCap + f * 10, "decode") }
+    );
+    throwIfAborted(signal);
+    audioChannels = Math.max(1, decoded.numberOfChannels);
+    audioOut = await encodeOpusChunks(
+      decoded,
+      {},
+      { signal, onProgress: (f) => emit(70 + f * 20, "encode") }
+    );
+    throwIfAborted(signal);
+  }
+  emit(90, "mux");
+  const outBytes = outputContainer === "mkv" ? buildMkv(
+    demux.video.width,
+    demux.video.height,
+    videoCodec,
+    videoOut,
+    audioOut,
+    audioChannels
+  ) : buildWebm(
+    demux.video.width,
+    demux.video.height,
+    videoCodec,
+    videoOut,
+    audioOut,
+    audioChannels
+  );
+  throwIfAborted(signal);
+  emit(100, "done");
+  return { bytes: outBytes, hardwareAccelerated, audioIncluded: audioOut !== null };
+}
+async function selectVideoEncoder(video, probes, hardwareAcceleration) {
+  const hints = {
+    width: video.width,
+    height: video.height,
+    ...hardwareAcceleration ? { hardwareAcceleration } : {}
+  };
+  const vp9 = await probes.probeEncodeVideo("vp9", hints);
+  if (vp9) {
+    return {
+      videoCodec: "vp9",
+      codecString: "vp09.00.10.08",
+      hardwareAccelerated: vp9.hardwareAccelerated
+    };
+  }
+  const vp8 = await probes.probeEncodeVideo("vp8", hints);
+  if (vp8) {
+    return { videoCodec: "vp8", codecString: "vp8", hardwareAccelerated: vp8.hardwareAccelerated };
+  }
+  throw new TranscodeCodecError("no VP9/VP8 video encoder is supported in this runtime");
+}
+async function planAudio(audio, probes) {
+  if (!audio) return null;
+  const inputCodec = audioCodecName(audio.config.codec);
+  if (!inputCodec) return null;
+  if (!await probes.canDecode(inputCodec)) return null;
+  if (!await probes.canEncode("opus")) return null;
+  return { track: audio };
+}
+function audioCodecName(codec) {
+  if (codec === "opus") return "opus";
+  if (codec.startsWith("mp4a") || codec === "aac") return "aac";
+  if (codec === "flac") return "flac";
+  return null;
+}
+async function encodeVideoTrack(demux, videoCodec, codecString, ctx) {
+  const { video } = demux;
+  const { width, height } = video;
+  const frameRate = video.frameRate > 0 ? video.frameRate : 30;
+  const bitrate = resolveVideoBitrate(width, height, ctx.quality, videoCodec);
+  const total = video.chunks.length || 1;
+  const out = [];
+  const encoder = new WebCodecsVideoEncoder(
+    {
+      config: {
+        codec: codecString,
+        width,
+        height,
+        bitrate,
+        framerate: frameRate,
+        ...ctx.hardwareAcceleration ? { hardwareAcceleration: ctx.hardwareAcceleration } : {}
+      }
+    },
+    (chunk) => {
+      const data = new Uint8Array(chunk.byteLength);
+      chunk.copyTo(data);
+      out.push({ data, timestampUs: chunk.timestamp, keyframe: chunk.type === "key" });
+      ctx.onEncoded(Math.min(1, out.length / total));
+    }
+  );
+  let frameIndex = 0;
+  let lastKeyframeUs = Number.NEGATIVE_INFINITY;
+  const decoder = new WebCodecsVideoDecoder({ config: video.config }, (frame) => {
+    if (ctx.signal?.aborted) {
+      frame.close();
+      return;
+    }
+    const ts = frame.timestamp;
+    const keyFrame = frameIndex === 0 || ts - lastKeyframeUs >= KEYFRAME_INTERVAL_US;
+    if (keyFrame) lastKeyframeUs = ts;
+    frameIndex++;
+    encoder.encode(frame, { keyFrame });
+  });
+  const onAbort = () => {
+    decoder.close();
+    encoder.close();
+  };
+  ctx.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for (let i = 0; i < video.chunks.length; i++) {
+      throwIfAborted(ctx.signal);
+      const c = video.chunks[i];
+      if (!c) continue;
+      decoder.decode(
+        new EncodedVideoChunk({
+          type: c.type,
+          timestamp: c.timestampUs,
+          duration: c.durationUs,
+          data: c.data
+        })
+      );
+    }
+    await decoder.flush();
+    throwIfAborted(ctx.signal);
+    await encoder.flush();
+    throwIfAborted(ctx.signal);
+  } catch (err) {
+    throw asCodecError(err, "video");
+  } finally {
+    ctx.signal?.removeEventListener("abort", onAbort);
+    decoder.close();
+    encoder.close();
+  }
+  return out;
+}
+function buildClusters(videoOut, audioOut) {
+  const blocks = [];
+  for (const v of videoOut) {
+    blocks.push({
+      trackNumber: VIDEO_TRACK,
+      timestampUs: v.timestampUs,
+      keyframe: v.keyframe,
+      data: v.data
+    });
+  }
+  if (audioOut) {
+    for (const a of audioOut) {
+      blocks.push({
+        trackNumber: AUDIO_TRACK,
+        timestampUs: a.timestampUs,
+        keyframe: true,
+        data: a.data
+      });
+    }
+  }
+  blocks.sort((x, y) => x.timestampUs - y.timestampUs);
+  const clusters = [];
+  let current = null;
+  for (const b of blocks) {
+    const tick = BigInt(Math.round(b.timestampUs / 1e3));
+    const startNew = current === null || b.trackNumber === VIDEO_TRACK && b.keyframe || tick - current.timecode > BigInt(CLUSTER_MAX_TICKS);
+    if (startNew) {
+      current = { fileOffset: 0, timecode: tick, blocks: [] };
+      clusters.push(current);
+    }
+    current?.blocks.push({
+      trackNumber: b.trackNumber,
+      timestampNs: tick * BigInt(WEBM_TIMECODE_SCALE2),
+      keyframe: b.keyframe,
+      invisible: false,
+      discardable: false,
+      frames: [b.data]
+    });
+  }
+  return clusters;
+}
+function buildWebm(width, height, videoCodec, videoOut, audioOut, audioChannels) {
+  const videoTrack = {
+    trackNumber: VIDEO_TRACK,
+    trackUid: 1n,
+    trackType: 1,
+    codecId: videoCodec === "vp8" ? "V_VP8" : "V_VP9",
+    pixelWidth: width,
+    pixelHeight: height
+  };
+  const tracks = [videoTrack];
+  if (audioOut) {
+    const audioTrack = {
+      trackNumber: AUDIO_TRACK,
+      trackUid: 2n,
+      trackType: 2,
+      codecId: "A_OPUS",
+      codecPrivate: opusHead(audioChannels),
+      samplingFrequency: OPUS_RATE3,
+      channels: audioChannels
+    };
+    tracks.push(audioTrack);
+  }
+  const file = {
+    ebmlHeader: {
+      ebmlVersion: 1,
+      ebmlReadVersion: 1,
+      ebmlMaxIdLength: 4,
+      ebmlMaxSizeLength: 8,
+      docType: "webm",
+      docTypeVersion: 4,
+      docTypeReadVersion: 2
+    },
+    segmentPayloadOffset: 0,
+    info: {
+      timecodeScale: WEBM_TIMECODE_SCALE2,
+      muxingApp: "webcvt-transcode",
+      writingApp: "webcvt-transcode"
+    },
+    tracks,
+    clusters: buildClusters(videoOut, audioOut),
+    fileBytes: new Uint8Array(0)
+  };
+  return serializeWebm(file);
+}
+function buildMkv(width, height, videoCodec, videoOut, audioOut, audioChannels) {
+  const videoTrack = {
+    trackNumber: VIDEO_TRACK,
+    trackUid: 1n,
+    trackType: 1,
+    codecId: videoCodec === "vp8" ? "V_VP8" : "V_VP9",
+    pixelWidth: width,
+    pixelHeight: height,
+    webcodecsCodecString: videoCodec === "vp8" ? "vp8" : "vp09.00.10.08"
+  };
+  const tracks = [videoTrack];
+  if (audioOut) {
+    const audioTrack = {
+      trackNumber: AUDIO_TRACK,
+      trackUid: 2n,
+      trackType: 2,
+      codecId: "A_OPUS",
+      codecPrivate: opusHead(audioChannels),
+      samplingFrequency: OPUS_RATE3,
+      channels: audioChannels,
+      webcodecsCodecString: "opus"
+    };
+    tracks.push(audioTrack);
+  }
+  const file = {
+    ebmlHeader: {
+      ebmlVersion: 1,
+      ebmlReadVersion: 1,
+      ebmlMaxIdLength: 4,
+      ebmlMaxSizeLength: 8,
+      docType: "matroska",
+      docTypeVersion: 4,
+      docTypeReadVersion: 2
+    },
+    segmentPayloadOffset: 0,
+    info: {
+      timecodeScale: WEBM_TIMECODE_SCALE2,
+      muxingApp: "webcvt-transcode",
+      writingApp: "webcvt-transcode"
+    },
+    tracks,
+    clusters: buildClusters(videoOut, audioOut),
+    chapters: [],
+    tags: [],
+    fileBytes: new Uint8Array(0)
+  };
+  return serializeMkv(file);
+}
+function opusHead(channels) {
+  return buildOpusHead({
+    channelCount: channels,
+    preSkip: OPUS_PRE_SKIP,
+    inputSampleRate: OPUS_RATE3
+  });
+}
+function monotone(onProgress) {
+  let last = 0;
+  return (percent, phase) => {
+    const p = Math.max(last, Math.min(100, percent));
+    last = p;
+    onProgress?.(p, phase);
+  };
+}
+
+// src/backend.ts
+var DEFAULT_QUALITY2 = 0.7;
+var TranscodeBackend = class {
+  name = "webcodecs-transcode";
+  priority = 0;
+  #probes = new ProbeCache();
+  async canHandle(input, output) {
+    if (TRANSCODE_MATRIX.has(matrixKey(input.mime, output.mime))) {
+      return this.#canHandleAudioMatrix(input.mime, output.mime);
+    }
+    const family = containerFamilyFor(input.mime);
+    if (family) return this.#canHandleContainer(family, input, output);
+    return false;
+  }
+  /** Stage-2 both-sided probe for the frozen audio matrix. */
+  async #canHandleAudioMatrix(inputMime, outputMime) {
+    const inputCodec = inputCodecFor(inputMime);
+    const target = outputTargetFor(outputMime);
+    if (!inputCodec || !target) return false;
+    if (inputCodec !== "pcm") {
+      if (!await this.#probes.canDecode(asAudioCodec(inputCodec))) return false;
+    }
+    if (target.codec !== "pcm") {
+      if (!await this.#probes.canEncode(asAudioCodec(target.codec))) return false;
+    }
+    return true;
+  }
+  /** Container input: gate a video-target or an audio-track-extraction pair. */
+  async #canHandleContainer(family, input, output) {
+    const videoTarget = videoTargetFor(output.mime);
+    if (videoTarget && input.category === "video") {
+      if (!await this.#probes.canDecodeVideo(CONTAINER_VIDEO_CODEC[family])) return false;
+      const canVp9 = await this.#probes.canEncodeVideo("vp9");
+      const canVp8 = canVp9 || await this.#probes.canEncodeVideo("vp8");
+      return canVp9 || canVp8;
+    }
+    const target = outputTargetFor(output.mime);
+    if (target && output.mime !== input.mime) {
+      if (!await this.#probes.canDecode(CONTAINER_AUDIO_CODEC[family])) return false;
+      if (target.codec !== "pcm") {
+        if (!await this.#probes.canEncode(asAudioCodec(target.codec))) return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  async convert(input, output, options) {
+    const startMs = Date.now();
+    if (input.size > MAX_INPUT_BYTES) {
+      throw new TranscodeInputTooLargeError(input.size, MAX_INPUT_BYTES);
+    }
+    const signal = options.signal;
+    throwIfAborted(signal);
+    const inputMime = resolveInputMime(input, options);
+    const inputCodec = inputCodecFor(inputMime);
+    const target = outputTargetFor(output.mime);
+    if (inputCodec && target && TRANSCODE_MATRIX.has(matrixKey(inputMime, output.mime))) {
+      const bytes = new Uint8Array(await input.arrayBuffer());
+      const outputBytes = await this.#runAudio(demuxAudio(inputCodec, bytes), target, options);
+      return this.#audioResult(outputBytes, output, startMs);
+    }
+    const family = containerFamilyFor(inputMime);
+    if (family) {
+      const bytes = new Uint8Array(await input.arrayBuffer());
+      const videoTarget = videoTargetFor(output.mime);
+      if (videoTarget && output.category === "video") {
+        return this.#convertVideo(family, videoTarget, bytes, output, options, startMs);
+      }
+      if (target) {
+        const outputBytes = await this.#runAudio(
+          demuxContainerAudio(family, bytes),
+          target,
+          options
+        );
+        return this.#audioResult(outputBytes, output, startMs);
+      }
+    }
+    throw new TranscodeUnsupportedError(inputMime, output.mime);
+  }
+  /** Shared audio demux→decode→encode→mux for both audio-matrix and container-audio. */
+  async #runAudio(demux, target, options) {
+    const signal = options.signal;
+    const report = (percent, phase) => options.onProgress?.({ percent, phase });
+    report(10, "demux");
+    throwIfAborted(signal);
+    const decoded = await decodeToPcm(demux, {
+      signal,
+      onProgress: (f) => report(10 + f * 35, "decode")
+    });
+    report(45, "decode");
+    throwIfAborted(signal);
+    const quality = options.quality ?? DEFAULT_QUALITY2;
+    const bitrate = resolveBitrate(target.codec, quality, decoded.numberOfChannels);
+    const encodeCtx = {
+      signal,
+      onProgress: (f) => report(45 + f * 45, "encode")
+    };
+    const outputBytes = await runSink(target, decoded, { bitrate }, encodeCtx);
+    report(90, "mux");
+    throwIfAborted(signal);
+    report(100, "done");
+    return outputBytes;
+  }
+  #audioResult(outputBytes, output, startMs) {
+    return {
+      blob: new Blob([outputBytes.buffer], { type: output.mime }),
+      format: output,
+      durationMs: Date.now() - startMs,
+      backend: this.name,
+      hardwareAccelerated: false
+      // audio decode/encode is always software today.
+    };
+  }
+  /** Video transcode dispatch (mp4/webm/mkv → webm/mkv, VP9|VP8 + Opus). */
+  async #convertVideo(family, videoTarget, bytes, output, options, startMs) {
+    const result = await transcodeVideo(family, videoTarget.container, bytes, this.#probes, {
+      quality: options.quality ?? DEFAULT_QUALITY2,
+      signal: options.signal,
+      ...options.hardwareAcceleration ? { hardwareAcceleration: mapHwAccel(options.hardwareAcceleration) } : {},
+      onProgress: (percent, phase) => options.onProgress?.({ percent, phase })
+    });
+    if (!result.audioIncluded) {
+      console.warn(
+        "[webcvt-transcode] emitted a VIDEO-ONLY output: the source audio track could not be transcoded (no WebCodecs AudioDecoder/AudioEncoder, or an unsupported audio codec)."
+      );
+    }
+    return {
+      blob: new Blob([result.bytes.buffer], { type: output.mime }),
+      format: output,
+      durationMs: Date.now() - startMs,
+      backend: this.name,
+      hardwareAccelerated: result.hardwareAccelerated
+    };
+  }
+};
+function registerTranscodeBackend(registry = defaultRegistry) {
+  const backend = new TranscodeBackend();
+  registry.register(backend);
+  return backend;
+}
+function runSink(target, decoded, opts, ctx) {
+  switch (target.container) {
+    case "wav":
+      return encodeWav(decoded);
+    case "ogg":
+      return encodeOpusOgg(decoded, opts, ctx);
+    case "webm":
+      return encodeOpusWebm(decoded, opts, ctx);
+    case "aac":
+      return encodeAac(decoded, opts, ctx);
+    case "flac":
+      return encodeFlac(decoded, opts, ctx);
+    default:
+      throw new TranscodeUnsupportedError("audio", target.container);
+  }
+}
+function resolveInputMime(input, options) {
+  if (options.inputFormat !== void 0) {
+    if (typeof options.inputFormat === "string") {
+      if (options.inputFormat.includes("/")) return options.inputFormat;
+    } else {
+      return options.inputFormat.mime;
+    }
+  }
+  return input.type;
+}
+function asAudioCodec(codec) {
+  return codec;
+}
+function mapHwAccel(pref) {
+  switch (pref) {
+    case "no":
+      return "prefer-software";
+    case "preferred":
+    case "required":
+      return "prefer-hardware";
+    default:
+      return "no-preference";
+  }
+}
+
+export { CONTAINER_AUDIO_CODEC, CONTAINER_INPUTS, CONTAINER_VIDEO_CODEC, DEFAULT_QUALITY, INPUT_CODECS, MAX_INPUT_BYTES, OUTPUT_TARGETS, TRANSCODE_MATRIX, TranscodeBackend, TranscodeCodecError, TranscodeDemuxError, TranscodeInputTooLargeError, TranscodeMuxError, TranscodeUnsupportedError, VIDEO_TARGETS, containerFamilyFor, inputCodecFor, matrixKey, outputTargetFor, registerTranscodeBackend, resolveBitrate, resolveVideoBitrate, videoTargetFor };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map