@fluxerjs/voice 1.2.0 → 1.2.1

package/dist/index.mjs

@@ -1,4 +1,2582 @@
-import "./chunk-EBO3CZXG.mjs";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoColorSpace.js
+var require_VideoColorSpace = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoColorSpace.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VideoColorSpace = void 0;
+    var VideoColorSpace = class {
+      constructor(init) {
+        this.primaries = init?.primaries ?? null;
+        this.transfer = init?.transfer ?? null;
+        this.matrix = init?.matrix ?? null;
+        this.fullRange = init?.fullRange ?? null;
+      }
+      toJSON() {
+        return {
+          primaries: this.primaries,
+          transfer: this.transfer,
+          matrix: this.matrix,
+          fullRange: this.fullRange
+        };
+      }
+    };
+    exports.VideoColorSpace = VideoColorSpace;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/types.js
+var require_types = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DOMException = exports.WebCodecsDOMException = exports.DOMRectReadOnly = void 0;
+    exports.createDOMException = createDOMException;
+    var DOMRectReadOnly = class {
+      constructor(x = 0, y = 0, width = 0, height = 0) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.top = y;
+        this.right = x + width;
+        this.bottom = y + height;
+        this.left = x;
+      }
+      toJSON() {
+        return { x: this.x, y: this.y, width: this.width, height: this.height };
+      }
+    };
+    exports.DOMRectReadOnly = DOMRectReadOnly;
+    var WebCodecsDOMException = class _WebCodecsDOMException extends Error {
+      constructor(message, name) {
+        super(message);
+        this.name = name ?? "Error";
+        this.code = _WebCodecsDOMException.ERROR_CODES[this.name] ?? 0;
+        Object.setPrototypeOf(this, _WebCodecsDOMException.prototype);
+      }
+    };
+    exports.WebCodecsDOMException = WebCodecsDOMException;
+    exports.DOMException = WebCodecsDOMException;
+    WebCodecsDOMException.INDEX_SIZE_ERR = 1;
+    WebCodecsDOMException.DOMSTRING_SIZE_ERR = 2;
+    WebCodecsDOMException.HIERARCHY_REQUEST_ERR = 3;
+    WebCodecsDOMException.WRONG_DOCUMENT_ERR = 4;
+    WebCodecsDOMException.INVALID_CHARACTER_ERR = 5;
+    WebCodecsDOMException.NO_DATA_ALLOWED_ERR = 6;
+    WebCodecsDOMException.NO_MODIFICATION_ALLOWED_ERR = 7;
+    WebCodecsDOMException.NOT_FOUND_ERR = 8;
+    WebCodecsDOMException.NOT_SUPPORTED_ERR = 9;
+    WebCodecsDOMException.INUSE_ATTRIBUTE_ERR = 10;
+    WebCodecsDOMException.INVALID_STATE_ERR = 11;
+    WebCodecsDOMException.SYNTAX_ERR = 12;
+    WebCodecsDOMException.INVALID_MODIFICATION_ERR = 13;
+    WebCodecsDOMException.NAMESPACE_ERR = 14;
+    WebCodecsDOMException.INVALID_ACCESS_ERR = 15;
+    WebCodecsDOMException.VALIDATION_ERR = 16;
+    WebCodecsDOMException.TYPE_MISMATCH_ERR = 17;
+    WebCodecsDOMException.SECURITY_ERR = 18;
+    WebCodecsDOMException.NETWORK_ERR = 19;
+    WebCodecsDOMException.ABORT_ERR = 20;
+    WebCodecsDOMException.URL_MISMATCH_ERR = 21;
+    WebCodecsDOMException.QUOTA_EXCEEDED_ERR = 22;
+    WebCodecsDOMException.TIMEOUT_ERR = 23;
+    WebCodecsDOMException.INVALID_NODE_TYPE_ERR = 24;
+    WebCodecsDOMException.DATA_CLONE_ERR = 25;
+    WebCodecsDOMException.ERROR_CODES = {
+      IndexSizeError: 1,
+      HierarchyRequestError: 3,
+      WrongDocumentError: 4,
+      InvalidCharacterError: 5,
+      NoModificationAllowedError: 7,
+      NotFoundError: 8,
+      NotSupportedError: 9,
+      InUseAttributeError: 10,
+      InvalidStateError: 11,
+      SyntaxError: 12,
+      InvalidModificationError: 13,
+      NamespaceError: 14,
+      InvalidAccessError: 15,
+      TypeMismatchError: 17,
+      SecurityError: 18,
+      NetworkError: 19,
+      AbortError: 20,
+      URLMismatchError: 21,
+      QuotaExceededError: 22,
+      TimeoutError: 23,
+      InvalidNodeTypeError: 24,
+      DataCloneError: 25,
+      EncodingError: 0,
+      NotReadableError: 0,
+      UnknownError: 0,
+      ConstraintError: 0,
+      DataError: 0,
+      TransactionInactiveError: 0,
+      ReadOnlyError: 0,
+      VersionError: 0,
+      OperationError: 0
+    };
+    function createDOMException(message, name) {
+      return new WebCodecsDOMException(message, name);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js
+var require_node_gyp_build = __commonJS({
+  "../../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    var vars = process.config && process.config.variables || {};
+    var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+    var abi = process.versions.modules;
+    var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
+    var arch = process.env.npm_config_arch || os.arch();
+    var platform = process.env.npm_config_platform || os.platform();
+    var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+    var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+    var uv = (process.versions.uv || "").split(".")[0];
+    module.exports = load;
+    function load(dir) {
+      return runtimeRequire(load.resolve(dir));
+    }
+    load.resolve = load.path = function(dir) {
+      dir = path.resolve(dir || ".");
+      try {
+        var name = runtimeRequire(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
+      } catch (err) {
+      }
+      if (!prebuildsOnly) {
+        var release = getFirst(path.join(dir, "build/Release"), matchBuild);
+        if (release) return release;
+        var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
+        if (debug) return debug;
+      }
+      var prebuild = resolve(dir);
+      if (prebuild) return prebuild;
+      var nearby = resolve(path.dirname(process.execPath));
+      if (nearby) return nearby;
+      var target = [
+        "platform=" + platform,
+        "arch=" + arch,
+        "runtime=" + runtime,
+        "abi=" + abi,
+        "uv=" + uv,
+        armv ? "armv=" + armv : "",
+        "libc=" + libc,
+        "node=" + process.versions.node,
+        process.versions.electron ? "electron=" + process.versions.electron : "",
+        typeof __webpack_require__ === "function" ? "webpack=true" : ""
+        // eslint-disable-line
+      ].filter(Boolean).join(" ");
+      throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
+      function resolve(dir2) {
+        var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
+        var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+        if (!tuple) return;
+        var prebuilds = path.join(dir2, "prebuilds", tuple.name);
+        var parsed = readdirSync(prebuilds).map(parseTags);
+        var candidates = parsed.filter(matchTags(runtime, abi));
+        var winner = candidates.sort(compareTags(runtime))[0];
+        if (winner) return path.join(prebuilds, winner.file);
+      }
+    };
+    function readdirSync(dir) {
+      try {
+        return fs.readdirSync(dir);
+      } catch (err) {
+        return [];
+      }
+    }
+    function getFirst(dir, filter) {
+      var files = readdirSync(dir).filter(filter);
+      return files[0] && path.join(dir, files[0]);
+    }
+    function matchBuild(name) {
+      return /\.node$/.test(name);
+    }
+    function parseTuple(name) {
+      var arr = name.split("-");
+      if (arr.length !== 2) return;
+      var platform2 = arr[0];
+      var architectures = arr[1].split("+");
+      if (!platform2) return;
+      if (!architectures.length) return;
+      if (!architectures.every(Boolean)) return;
+      return { name, platform: platform2, architectures };
+    }
+    function matchTuple(platform2, arch2) {
+      return function(tuple) {
+        if (tuple == null) return false;
+        if (tuple.platform !== platform2) return false;
+        return tuple.architectures.includes(arch2);
+      };
+    }
+    function compareTuples(a, b) {
+      return a.architectures.length - b.architectures.length;
+    }
+    function parseTags(file) {
+      var arr = file.split(".");
+      var extension = arr.pop();
+      var tags = { file, specificity: 0 };
+      if (extension !== "node") return;
+      for (var i = 0; i < arr.length; i++) {
+        var tag = arr[i];
+        if (tag === "node" || tag === "electron" || tag === "node-webkit") {
+          tags.runtime = tag;
+        } else if (tag === "napi") {
+          tags.napi = true;
+        } else if (tag.slice(0, 3) === "abi") {
+          tags.abi = tag.slice(3);
+        } else if (tag.slice(0, 2) === "uv") {
+          tags.uv = tag.slice(2);
+        } else if (tag.slice(0, 4) === "armv") {
+          tags.armv = tag.slice(4);
+        } else if (tag === "glibc" || tag === "musl") {
+          tags.libc = tag;
+        } else {
+          continue;
+        }
+        tags.specificity++;
+      }
+      return tags;
+    }
+    function matchTags(runtime2, abi2) {
+      return function(tags) {
+        if (tags == null) return false;
+        if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
+        if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
+        if (tags.uv && tags.uv !== uv) return false;
+        if (tags.armv && tags.armv !== armv) return false;
+        if (tags.libc && tags.libc !== libc) return false;
+        return true;
+      };
+    }
+    function runtimeAgnostic(tags) {
+      return tags.runtime === "node" && tags.napi;
+    }
+    function compareTags(runtime2) {
+      return function(a, b) {
+        if (a.runtime !== b.runtime) {
+          return a.runtime === runtime2 ? -1 : 1;
+        } else if (a.abi !== b.abi) {
+          return a.abi ? -1 : 1;
+        } else if (a.specificity !== b.specificity) {
+          return a.specificity > b.specificity ? -1 : 1;
+        } else {
+          return 0;
+        }
+      };
+    }
+    function isNwjs() {
+      return !!(process.versions && process.versions.nw);
+    }
+    function isElectron() {
+      if (process.versions && process.versions.electron) return true;
+      if (process.env.ELECTRON_RUN_AS_NODE) return true;
+      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+    }
+    function isAlpine(platform2) {
+      return platform2 === "linux" && fs.existsSync("/etc/alpine-release");
+    }
+    load.parseTags = parseTags;
+    load.matchTags = matchTags;
+    load.compareTags = compareTags;
+    load.parseTuple = parseTuple;
+    load.matchTuple = matchTuple;
+    load.compareTuples = compareTuples;
+  }
+});
+
+// ../../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/index.js
+var require_node_gyp_build2 = __commonJS({
+  "../../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/index.js"(exports, module) {
+    "use strict";
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    if (typeof runtimeRequire.addon === "function") {
+      module.exports = runtimeRequire.addon.bind(runtimeRequire);
+    } else {
+      module.exports = require_node_gyp_build();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/native.js
+var require_native = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/native.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.native = void 0;
+    var path_1 = __importDefault(__require("path"));
+    var nodeGypBuild = require_node_gyp_build2();
+    var native;
+    try {
+      exports.native = native = nodeGypBuild(path_1.default.join(__dirname, ".."));
+    } catch (error) {
+      exports.native = native = new Proxy({}, {
+        get() {
+          throw error;
+        }
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoFrame.js
+var require_VideoFrame = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoFrame.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VideoFrame = void 0;
+    var VideoColorSpace_1 = require_VideoColorSpace();
+    var types_1 = require_types();
+    var native_1 = require_native();
+    var VideoFrame2 = class _VideoFrame {
+      // Per WebCodecs spec, after close() these should return null/0
+      // Note: timestamp is preserved after close per spec
+      get format() {
+        return this._closed ? null : this._format;
+      }
+      get codedWidth() {
+        return this._closed ? 0 : this._codedWidth;
+      }
+      get codedHeight() {
+        return this._closed ? 0 : this._codedHeight;
+      }
+      get displayWidth() {
+        return this._closed ? 0 : this._displayWidth;
+      }
+      get displayHeight() {
+        return this._closed ? 0 : this._displayHeight;
+      }
+      get timestamp() {
+        return this._timestamp;
+      }
+      get duration() {
+        return this._closed ? null : this._duration;
+      }
+      get colorSpace() {
+        return this._colorSpace;
+      }
+      get visibleRect() {
+        return this._closed ? null : this._visibleRect;
+      }
+      constructor(dataOrImage, init) {
+        this._closed = false;
+        this._buffer = null;
+        if (dataOrImage instanceof _VideoFrame) {
+          if (dataOrImage._closed) {
+            throw new types_1.DOMException("Source VideoFrame is closed", "InvalidStateError");
+          }
+          this._native = dataOrImage._native ? dataOrImage._native.clone() : null;
+          this._buffer = dataOrImage._buffer ? new Uint8Array(dataOrImage._buffer) : null;
+          this._format = dataOrImage._format;
+          this._codedWidth = dataOrImage._codedWidth;
+          this._codedHeight = dataOrImage._codedHeight;
+          this._displayWidth = init?.displayWidth ?? dataOrImage._displayWidth;
+          this._displayHeight = init?.displayHeight ?? dataOrImage._displayHeight;
+          this._timestamp = init?.timestamp ?? dataOrImage._timestamp;
+          this._duration = init?.duration ?? dataOrImage._duration;
+          this._colorSpace = dataOrImage._colorSpace;
+          this._visibleRect = dataOrImage._visibleRect;
+        } else {
+          const bufferInit = init;
+          if (!bufferInit?.format || !bufferInit.codedWidth || !bufferInit.codedHeight) {
+            throw new TypeError("format, codedWidth, and codedHeight are required");
+          }
+          if (bufferInit.timestamp === void 0) {
+            throw new TypeError("timestamp is required");
+          }
+          let buffer;
+          if (dataOrImage instanceof ArrayBuffer) {
+            buffer = new Uint8Array(dataOrImage);
+          } else {
+            buffer = new Uint8Array(dataOrImage.buffer, dataOrImage.byteOffset, dataOrImage.byteLength);
+          }
+          this._buffer = new Uint8Array(buffer);
+          if (native_1.native) {
+            try {
+              this._native = native_1.native.createVideoFrame(Buffer.from(buffer), bufferInit.format, bufferInit.codedWidth, bufferInit.codedHeight);
+            } catch (e) {
+              this._native = null;
+            }
+          }
+          this._format = bufferInit.format;
+          this._codedWidth = bufferInit.codedWidth;
+          this._codedHeight = bufferInit.codedHeight;
+          this._displayWidth = bufferInit.displayWidth ?? bufferInit.codedWidth;
+          this._displayHeight = bufferInit.displayHeight ?? bufferInit.codedHeight;
+          this._timestamp = bufferInit.timestamp;
+          this._duration = bufferInit.duration ?? null;
+          const isRgbFormat = ["RGBA", "RGBX", "BGRA", "BGRX"].includes(bufferInit.format);
+          const defaultColorSpace = isRgbFormat ? { primaries: "bt709", transfer: "iec61966-2-1", matrix: "rgb", fullRange: true } : { primaries: "bt709", transfer: "bt709", matrix: "bt709", fullRange: false };
+          this._colorSpace = new VideoColorSpace_1.VideoColorSpace({
+            primaries: bufferInit.colorSpace?.primaries ?? defaultColorSpace.primaries,
+            transfer: bufferInit.colorSpace?.transfer ?? defaultColorSpace.transfer,
+            matrix: bufferInit.colorSpace?.matrix ?? defaultColorSpace.matrix,
+            fullRange: bufferInit.colorSpace?.fullRange ?? defaultColorSpace.fullRange
+          });
+          this._visibleRect = bufferInit.visibleRect ? new types_1.DOMRectReadOnly(bufferInit.visibleRect.x, bufferInit.visibleRect.y, bufferInit.visibleRect.width, bufferInit.visibleRect.height) : new types_1.DOMRectReadOnly(0, 0, bufferInit.codedWidth, bufferInit.codedHeight);
+        }
+      }
+      /**
+       * Get the native frame handle (internal use only)
+       */
+      _getNative() {
+        this._assertNotClosed();
+        return this._native;
+      }
+      /**
+       * Calculate the size in bytes needed to hold the frame data
+       */
+      allocationSize(options) {
+        this._assertNotClosed();
+        const width = options?.rect?.width ?? this.codedWidth;
+        const height = options?.rect?.height ?? this.codedHeight;
+        const targetFormat = options?.format ?? this.format;
+        return this._calculateFormatSize(targetFormat, width, height);
+      }
+      _calculateFormatSize(format, width, height) {
+        switch (format) {
+          case "RGBA":
+          case "RGBX":
+          case "BGRA":
+          case "BGRX":
+            return width * height * 4;
+          case "I420":
+            return Math.floor(width * height * 1.5);
+          case "I420A":
+            return width * height * 2;
+          case "I422":
+            return width * height * 2;
+          case "I444":
+            return width * height * 3;
+          case "NV12":
+            return Math.floor(width * height * 1.5);
+          default:
+            return width * height * 4;
+        }
+      }
+      /**
+       * Copy the frame data to a destination buffer
+       */
+      async copyTo(destination, options) {
+        this._assertNotClosed();
+        let dest;
+        if (destination instanceof ArrayBuffer) {
+          dest = new Uint8Array(destination);
+        } else {
+          dest = new Uint8Array(destination.buffer, destination.byteOffset, destination.byteLength);
+        }
+        if (this._native) {
+          this._native.copyTo(Buffer.from(dest.buffer, dest.byteOffset, dest.byteLength), options);
+        } else if (this._buffer) {
+          const size = Math.min(dest.byteLength, this._buffer.byteLength);
+          dest.set(this._buffer.subarray(0, size));
+        }
+        return this._getPlaneLayouts(options);
+      }
+      /**
+       * Create a clone of this frame
+       */
+      clone() {
+        this._assertNotClosed();
+        return new _VideoFrame(this);
+      }
+      /**
+       * Close the frame and release resources
+       */
+      close() {
+        if (!this._closed) {
+          if (this._native) {
+            this._native.close();
+            this._native = null;
+          }
+          this._buffer = null;
+          this._closed = true;
+        }
+      }
+      _assertNotClosed() {
+        if (this._closed) {
+          throw new types_1.DOMException("VideoFrame is closed", "InvalidStateError");
+        }
+      }
+      _getPlaneLayouts(options) {
+        const width = options?.rect?.width ?? this.codedWidth;
+        const height = options?.rect?.height ?? this.codedHeight;
+        const targetFormat = options?.format ?? this.format;
+        switch (targetFormat) {
+          case "RGBA":
+          case "RGBX":
+          case "BGRA":
+          case "BGRX":
+            return [{ offset: 0, stride: width * 4 }];
+          case "I420": {
+            const ySize = width * height;
+            const uvSize = Math.floor(width / 2 * (height / 2));
+            return [
+              { offset: 0, stride: width },
+              { offset: ySize, stride: Math.floor(width / 2) },
+              { offset: ySize + uvSize, stride: Math.floor(width / 2) }
+            ];
+          }
+          case "I420A": {
+            const ySize = width * height;
+            const uvSize = Math.floor(width / 2 * (height / 2));
+            return [
+              { offset: 0, stride: width },
+              { offset: ySize, stride: Math.floor(width / 2) },
+              { offset: ySize + uvSize, stride: Math.floor(width / 2) },
+              { offset: ySize + 2 * uvSize, stride: width }
+            ];
+          }
+          case "I422": {
+            const ySize = width * height;
+            const uvSize = Math.floor(width / 2 * height);
+            return [
+              { offset: 0, stride: width },
+              { offset: ySize, stride: Math.floor(width / 2) },
+              { offset: ySize + uvSize, stride: Math.floor(width / 2) }
+            ];
+          }
+          case "I444": {
+            const planeSize = width * height;
+            return [
+              { offset: 0, stride: width },
+              { offset: planeSize, stride: width },
+              { offset: planeSize * 2, stride: width }
+            ];
+          }
+          case "NV12": {
+            const ySize = width * height;
+            return [
+              { offset: 0, stride: width },
+              { offset: ySize, stride: width }
+            ];
+          }
+          default:
+            return [{ offset: 0, stride: width * 4 }];
+        }
+      }
+    };
+    exports.VideoFrame = VideoFrame2;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/AudioData.js
+var require_AudioData = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/AudioData.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AudioData = void 0;
+    var types_1 = require_types();
+    var native_1 = require_native();
+    function getBytesPerSample(format) {
+      switch (format) {
+        case "u8":
+        case "u8-planar":
+          return 1;
+        case "s16":
+        case "s16-planar":
+          return 2;
+        case "s32":
+        case "s32-planar":
+        case "f32":
+        case "f32-planar":
+          return 4;
+        default:
+          return 4;
+      }
+    }
+    function isPlanar(format) {
+      return format.endsWith("-planar");
+    }
+    var AudioData = class _AudioData {
+      // Per WebCodecs spec, after close() these should return null/0
+      get format() {
+        return this._closed ? null : this._format;
+      }
+      get sampleRate() {
+        return this._closed ? 0 : this._sampleRate;
+      }
+      get numberOfFrames() {
+        return this._closed ? 0 : this._numberOfFrames;
+      }
+      get numberOfChannels() {
+        return this._closed ? 0 : this._numberOfChannels;
+      }
+      get duration() {
+        return this._closed ? 0 : this._duration;
+      }
+      get timestamp() {
+        return this._closed ? 0 : this._timestamp;
+      }
+      constructor(init) {
+        this._closed = false;
+        this._buffer = null;
+        if (!init.format) {
+          throw new TypeError("format is required");
+        }
+        if (!init.sampleRate || init.sampleRate <= 0) {
+          throw new TypeError("sampleRate must be positive");
+        }
+        if (!init.numberOfFrames || init.numberOfFrames <= 0) {
+          throw new TypeError("numberOfFrames must be positive");
+        }
+        if (!init.numberOfChannels || init.numberOfChannels <= 0) {
+          throw new TypeError("numberOfChannels must be positive");
+        }
+        if (init.timestamp === void 0) {
+          throw new TypeError("timestamp is required");
+        }
+        if (!init.data) {
+          throw new TypeError("data is required");
+        }
+        let buffer;
+        if (init.data instanceof ArrayBuffer) {
+          buffer = new Uint8Array(init.data);
+        } else {
+          buffer = new Uint8Array(init.data.buffer, init.data.byteOffset, init.data.byteLength);
+        }
+        this._buffer = new Uint8Array(buffer);
+        if (native_1.native) {
+          try {
+            this._native = native_1.native.createAudioData(Buffer.from(buffer), init.format, init.sampleRate, init.numberOfFrames, init.numberOfChannels, init.timestamp);
+          } catch {
+            this._native = null;
+          }
+        }
+        this._format = init.format;
+        this._sampleRate = init.sampleRate;
+        this._numberOfFrames = init.numberOfFrames;
+        this._numberOfChannels = init.numberOfChannels;
+        this._timestamp = init.timestamp;
+        this._duration = Math.floor(init.numberOfFrames / init.sampleRate * 1e6);
+      }
+      /**
+       * Calculate the size in bytes needed to hold the audio data for a plane
+       */
+      allocationSize(options) {
+        this._assertNotClosed();
+        const frameOffset = options.frameOffset ?? 0;
+        const frameCount = options.frameCount ?? this.numberOfFrames - frameOffset;
+        const format = options.format ?? this.format;
+        if (!format) {
+          throw new types_1.DOMException("No format available", "InvalidStateError");
+        }
+        const bytesPerSample = getBytesPerSample(format);
+        if (isPlanar(format)) {
+          return frameCount * bytesPerSample;
+        } else {
+          return frameCount * this.numberOfChannels * bytesPerSample;
+        }
+      }
+      /**
+       * Copy audio data to a destination buffer
+       */
+      copyTo(destination, options) {
+        this._assertNotClosed();
+        if (options.planeIndex < 0) {
+          throw new RangeError("planeIndex must be non-negative");
+        }
+        const format = options.format ?? this.format;
+        if (!format) {
+          throw new types_1.DOMException("No format available", "InvalidStateError");
+        }
+        if (isPlanar(format)) {
+          if (options.planeIndex >= this.numberOfChannels) {
+            throw new RangeError(`planeIndex ${options.planeIndex} out of range for ${this.numberOfChannels} channels`);
+          }
+        } else {
+          if (options.planeIndex !== 0) {
+            throw new RangeError("planeIndex must be 0 for interleaved formats");
+          }
+        }
+        let dest;
+        if (destination instanceof ArrayBuffer) {
+          dest = new Uint8Array(destination);
+        } else {
+          dest = new Uint8Array(destination.buffer, destination.byteOffset, destination.byteLength);
+        }
+        if (this._native) {
+          this._native.copyTo(Buffer.from(dest.buffer, dest.byteOffset, dest.byteLength), options);
+        } else if (this._buffer) {
+          const frameOffset = options.frameOffset ?? 0;
+          const frameCount = options.frameCount ?? this.numberOfFrames - frameOffset;
+          const bytesPerSample = getBytesPerSample(format);
+          if (isPlanar(format)) {
+            const planeSize = this.numberOfFrames * bytesPerSample;
+            const srcOffset = options.planeIndex * planeSize + frameOffset * bytesPerSample;
+            const copySize = frameCount * bytesPerSample;
+            dest.set(this._buffer.subarray(srcOffset, srcOffset + copySize));
+          } else {
+            const srcOffset = frameOffset * this.numberOfChannels * bytesPerSample;
+            const copySize = frameCount * this.numberOfChannels * bytesPerSample;
+            dest.set(this._buffer.subarray(srcOffset, srcOffset + copySize));
+          }
+        }
+      }
+      /**
+       * Create a clone of this audio data
+       */
+      clone() {
+        this._assertNotClosed();
+        if (!this._buffer || !this.format) {
+          throw new types_1.DOMException("Cannot clone AudioData without data", "InvalidStateError");
+        }
+        return new _AudioData({
+          format: this.format,
+          sampleRate: this.sampleRate,
+          numberOfFrames: this.numberOfFrames,
+          numberOfChannels: this.numberOfChannels,
+          timestamp: this.timestamp,
+          data: new Uint8Array(this._buffer)
+        });
+      }
+      /**
+       * Close the audio data and release resources
+       */
+      close() {
+        if (!this._closed) {
+          if (this._native) {
+            this._native.close();
+            this._native = null;
+          }
+          this._buffer = null;
+          this._closed = true;
+        }
+      }
+      _assertNotClosed() {
+        if (this._closed) {
+          throw new types_1.DOMException("AudioData is closed", "InvalidStateError");
+        }
+      }
+    };
+    exports.AudioData = AudioData;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/EncodedVideoChunk.js
+var require_EncodedVideoChunk = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/EncodedVideoChunk.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EncodedVideoChunk = void 0;
+    var EncodedVideoChunk2 = class {
+      constructor(init) {
+        if (!init.type) {
+          throw new TypeError("type is required");
+        }
+        if (init.type !== "key" && init.type !== "delta") {
+          throw new TypeError('type must be "key" or "delta"');
+        }
+        if (init.timestamp === void 0) {
+          throw new TypeError("timestamp is required");
+        }
+        if (!init.data) {
+          throw new TypeError("data is required");
+        }
+        this.type = init.type;
+        this.timestamp = init.timestamp;
+        this.duration = init.duration ?? null;
+        let source;
+        if (init.data instanceof ArrayBuffer) {
+          source = new Uint8Array(init.data);
+        } else {
+          source = new Uint8Array(init.data.buffer, init.data.byteOffset, init.data.byteLength);
+        }
+        this._data = new Uint8Array(source);
+        this.byteLength = this._data.byteLength;
+      }
+      /**
+       * Copy the encoded data to a destination buffer
+       */
+      copyTo(destination) {
+        let dest;
+        if (destination instanceof ArrayBuffer) {
+          dest = new Uint8Array(destination);
+        } else {
+          dest = new Uint8Array(destination.buffer, destination.byteOffset, destination.byteLength);
+        }
+        if (dest.byteLength < this._data.byteLength) {
+          throw new TypeError("Destination buffer is too small");
+        }
+        dest.set(this._data);
+      }
+    };
+    exports.EncodedVideoChunk = EncodedVideoChunk2;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/EncodedAudioChunk.js
+var require_EncodedAudioChunk = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/EncodedAudioChunk.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EncodedAudioChunk = void 0;
+    var EncodedAudioChunk = class {
+      constructor(init) {
+        if (!init.type) {
+          throw new TypeError("type is required");
+        }
+        if (init.type !== "key" && init.type !== "delta") {
+          throw new TypeError('type must be "key" or "delta"');
+        }
+        if (init.timestamp === void 0) {
+          throw new TypeError("timestamp is required");
+        }
+        if (!init.data) {
+          throw new TypeError("data is required");
+        }
+        this.type = init.type;
+        this.timestamp = init.timestamp;
+        this.duration = init.duration ?? null;
+        let source;
+        if (init.data instanceof ArrayBuffer) {
+          source = new Uint8Array(init.data);
+        } else {
+          source = new Uint8Array(init.data.buffer, init.data.byteOffset, init.data.byteLength);
+        }
+        this._data = new Uint8Array(source);
+        this.byteLength = this._data.byteLength;
+      }
+      /**
+       * Copy the encoded data to a destination buffer
+       */
+      copyTo(destination) {
+        let dest;
+        if (destination instanceof ArrayBuffer) {
+          dest = new Uint8Array(destination);
+        } else {
+          dest = new Uint8Array(destination.buffer, destination.byteOffset, destination.byteLength);
+        }
+        if (dest.byteLength < this._data.byteLength) {
+          throw new TypeError("Destination buffer is too small");
+        }
+        dest.set(this._data);
+      }
+    };
+    exports.EncodedAudioChunk = EncodedAudioChunk;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/ImageDecoder.js
+var require_ImageDecoder = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/ImageDecoder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ImageDecoder = void 0;
+    var VideoFrame_1 = require_VideoFrame();
+    var types_1 = require_types();
+    var native_1 = require_native();
+    function isReadableStream(value) {
+      return typeof value === "object" && value !== null && typeof value.getReader === "function";
+    }
+    var ImageDecoder = class {
+      /**
+       * Check if a MIME type is supported for decoding
+       */
+      static isTypeSupported(type) {
+        if (!native_1.native || !native_1.native.ImageDecoderNative) {
+          return Promise.resolve(false);
+        }
+        return Promise.resolve(native_1.native.ImageDecoderNative.isTypeSupported(type));
+      }
+      constructor(init) {
+        this._complete = false;
+        this._closed = false;
+        if (!init.data) {
+          throw new TypeError("data is required");
+        }
+        if (!init.type) {
+          throw new TypeError("type is required");
+        }
+        if (!native_1.native || !native_1.native.ImageDecoderNative) {
+          throw new types_1.DOMException("Native addon not available", "NotSupportedError");
+        }
+        this._type = init.type;
+        this._completedPromise = new Promise((resolve, reject) => {
+          this._completedResolve = resolve;
+          this._completedReject = reject;
+        });
+        if (isReadableStream(init.data)) {
+          this._handleReadableStream(init.data);
+          return;
+        }
+        let dataBuffer;
+        if (init.data instanceof ArrayBuffer) {
+          dataBuffer = Buffer.from(init.data);
+        } else if (ArrayBuffer.isView(init.data)) {
+          dataBuffer = Buffer.from(init.data.buffer, init.data.byteOffset, init.data.byteLength);
+        } else {
+          throw new TypeError("Invalid data type: expected BufferSource or ReadableStream");
+        }
+        this._initNative(dataBuffer);
+      }
+      /**
+       * Handle ReadableStream input by reading all chunks and concatenating them
+       */
+      async _handleReadableStream(stream) {
+        this._streamReader = stream.getReader();
+        const chunks = [];
+        try {
+          while (true) {
+            const { done, value } = await this._streamReader.read();
+            if (done)
+              break;
+            let chunk;
+            if (value instanceof ArrayBuffer) {
+              chunk = new Uint8Array(value);
+            } else if (ArrayBuffer.isView(value)) {
+              chunk = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+            } else {
+              throw new TypeError("ReadableStream yielded invalid chunk type");
+            }
+            chunks.push(chunk);
+          }
+          const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+          const fullData = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            fullData.set(chunk, offset);
+            offset += chunk.length;
+          }
+          this._initNative(Buffer.from(fullData));
+        } catch (error) {
+          this._completedReject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      /**
+       * Initialize the native decoder with buffer data
+       */
+      _initNative(dataBuffer) {
+        try {
+          this._native = new native_1.native.ImageDecoderNative({
+            data: dataBuffer,
+            type: this._type
+          });
+          this._complete = this._native.complete;
+          if (this._complete) {
+            this._completedResolve();
+          }
+        } catch (e) {
+          const error = new types_1.DOMException(e.message || "Failed to create ImageDecoder", "NotSupportedError");
+          this._completedReject(error);
+          throw error;
+        }
+      }
+      /**
+       * Whether all image data has been received
+       */
+      get complete() {
+        return this._complete;
+      }
+      /**
+       * Promise that resolves when complete becomes true
+       */
+      get completed() {
+        return this._completedPromise;
+      }
+      /**
+       * The MIME type of the image
+       */
+      get type() {
+        return this._type;
+      }
+      /**
+       * Decode an image frame
+       */
+      async decode(options) {
+        if (this._closed) {
+          throw new types_1.DOMException("ImageDecoder is closed", "InvalidStateError");
+        }
+        if (!this._complete) {
+          throw new types_1.DOMException("Image data is not complete", "InvalidStateError");
+        }
+        try {
+          const result = this._native.decode(options?.frameIndex ?? 0);
+          const videoFrame = new VideoFrame_1.VideoFrame(result.image);
+          return {
+            image: videoFrame,
+            complete: result.complete
+          };
+        } catch (e) {
+          throw new types_1.DOMException(e.message || "Failed to decode image", "EncodingError");
+        }
+      }
+      /**
+       * Reset the decoder state
+       */
+      reset() {
+        if (!this._closed) {
+          this._native.reset();
+        }
+      }
+      /**
+       * Close the decoder and release resources
+       */
+      close() {
+        if (!this._closed) {
+          this._closed = true;
+          this._native.close();
+        }
+      }
+    };
+    exports.ImageDecoder = ImageDecoder;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/codec-registry.js
+var require_codec_registry = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/codec-registry.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AUDIO_CODECS = exports.VIDEO_CODECS = void 0;
+    exports.parseAvcCodecString = parseAvcCodecString;
+    exports.parseAacCodecString = parseAacCodecString;
+    exports.parseVp9CodecString = parseVp9CodecString;
+    exports.isVideoCodecSupported = isVideoCodecSupported;
+    exports.isAudioCodecSupported = isAudioCodecSupported;
+    exports.getFFmpegVideoCodec = getFFmpegVideoCodec;
+    exports.getFFmpegVideoDecoder = getFFmpegVideoDecoder;
+    exports.getFFmpegAudioCodec = getFFmpegAudioCodec;
+    exports.getFFmpegAudioDecoder = getFFmpegAudioDecoder;
+    function parseAvcCodecString(codec) {
+      const match = codec.match(/^avc1\.([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
+      if (!match)
+        return null;
+      const profile = parseInt(match[1], 16);
+      const level = parseInt(match[3], 16);
+      return { profile, level };
+    }
+    function parseAacCodecString(codec) {
+      const match = codec.match(/^mp4a\.40\.(\d+)$/);
+      if (!match)
+        return null;
+      return { objectType: parseInt(match[1], 10) };
+    }
+    function parseVp9CodecString(codec) {
+      if (codec === "vp9" || codec === "vp09") {
+        return { profile: 0, level: 10, bitDepth: 8 };
+      }
+      const match = codec.match(/^vp09\.(\d{2})\.(\d{2})\.(\d{2})/);
+      if (!match)
+        return null;
+      return {
+        profile: parseInt(match[1], 10),
+        level: parseInt(match[2], 10),
+        bitDepth: parseInt(match[3], 10)
+      };
+    }
+    exports.VIDEO_CODECS = {
+      // H.264/AVC
+      "avc1": {
+        ffmpegCodec: "libx264",
+        type: "video",
+        profiles: {
+          "42": 66,
+          // Baseline
+          "4d": 77,
+          // Main
+          "58": 88,
+          // Extended
+          "64": 100
+          // High
+        }
+      },
+      // VP8
+      "vp8": {
+        ffmpegCodec: "libvpx",
+        type: "video"
+      },
+      // VP9
+      "vp09": {
+        ffmpegCodec: "libvpx-vp9",
+        type: "video"
+      },
+      "vp9": {
+        ffmpegCodec: "libvpx-vp9",
+        type: "video"
+      },
+      // H.265/HEVC
+      "hvc1": {
+        ffmpegCodec: "libx265",
+        type: "video"
+      },
+      "hev1": {
+        ffmpegCodec: "libx265",
+        type: "video"
+      },
+      // AV1
+      "av01": {
+        ffmpegCodec: "libaom-av1",
+        type: "video"
+      }
+    };
+    exports.AUDIO_CODECS = {
+      // AAC
+      "mp4a.40": {
+        ffmpegCodec: "aac",
+        type: "audio"
+      },
+      // Opus
+      "opus": {
+        ffmpegCodec: "libopus",
+        type: "audio"
+      },
+      // MP3
+      "mp3": {
+        ffmpegCodec: "libmp3lame",
+        type: "audio"
+      },
+      // FLAC
+      "flac": {
+        ffmpegCodec: "flac",
+        type: "audio"
+      },
+      // Vorbis
+      "vorbis": {
+        ffmpegCodec: "libvorbis",
+        type: "audio"
+      },
+      // PCM
+      "pcm": {
+        ffmpegCodec: "pcm_f32le",
+        type: "audio"
+      }
+    };
+    function isVideoCodecSupported(codec) {
+      if (codec.startsWith("avc1.")) {
+        return parseAvcCodecString(codec) !== null;
+      }
+      if (codec.startsWith("vp09.")) {
+        return parseVp9CodecString(codec) !== null;
+      }
+      if (codec.startsWith("hvc1.") || codec.startsWith("hev1.")) {
+        return true;
+      }
+      if (codec.startsWith("av01.")) {
+        return true;
+      }
+      return codec in exports.VIDEO_CODECS;
+    }
+    function isAudioCodecSupported(codec) {
+      if (codec.startsWith("mp4a.40.")) {
+        return parseAacCodecString(codec) !== null;
+      }
+      return codec in exports.AUDIO_CODECS;
+    }
+    function getFFmpegVideoCodec(codec) {
+      if (codec.startsWith("avc1.")) {
+        return "libx264";
+      }
+      if (codec.startsWith("vp09.") || codec === "vp9") {
+        return "libvpx-vp9";
+      }
+      if (codec === "vp8") {
+        return "libvpx";
+      }
+      if (codec.startsWith("hvc1.") || codec.startsWith("hev1.")) {
+        return "libx265";
+      }
+      if (codec.startsWith("av01.")) {
+        return "libaom-av1";
+      }
+      const info = exports.VIDEO_CODECS[codec];
+      return info?.ffmpegCodec ?? null;
+    }
+    function getFFmpegVideoDecoder(codec) {
+      if (codec.startsWith("avc1.")) {
+        return "h264";
+      }
+      if (codec.startsWith("vp09.") || codec === "vp9") {
+        return "vp9";
+      }
+      if (codec === "vp8") {
+        return "vp8";
+      }
+      if (codec.startsWith("hvc1.") || codec.startsWith("hev1.")) {
+        return "hevc";
+      }
+      if (codec.startsWith("av01.")) {
+        return "av1";
+      }
+      const encoderToDecoder = {
+        "libx264": "h264",
+        "libvpx": "vp8",
+        "libvpx-vp9": "vp9",
+        "libx265": "hevc",
+        "libaom-av1": "av1"
+      };
+      const info = exports.VIDEO_CODECS[codec];
+      if (info) {
+        return encoderToDecoder[info.ffmpegCodec] ?? info.ffmpegCodec;
+      }
+      return null;
+    }
+    function getFFmpegAudioCodec(codec) {
+      if (codec.startsWith("mp4a.40.")) {
+        return "aac";
+      }
+      const info = exports.AUDIO_CODECS[codec];
+      return info?.ffmpegCodec ?? null;
+    }
+    function getFFmpegAudioDecoder(codec) {
+      if (codec.startsWith("mp4a.40.")) {
+        return "aac";
+      }
+      const encoderToDecoder = {
+        "libopus": "opus",
+        "libmp3lame": "mp3",
+        "libvorbis": "vorbis"
+      };
+      const info = exports.AUDIO_CODECS[codec];
+      if (info) {
+        return encoderToDecoder[info.ffmpegCodec] ?? info.ffmpegCodec;
+      }
+      return null;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoEncoder.js
+var require_VideoEncoder = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoEncoder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VideoEncoder = void 0;
+    var EncodedVideoChunk_1 = require_EncodedVideoChunk();
+    var codec_registry_1 = require_codec_registry();
+    var types_1 = require_types();
+    var native_1 = require_native();
+    var VideoEncoder = class {
+      /**
+       * Check if a VideoEncoder configuration is supported
+       *
+       * Tests whether the specified codec and parameters can be encoded on this platform.
+       * This method probes the native FFmpeg installation for codec availability.
+       *
+       * @param config - Configuration to test
+       * @returns Promise resolving to support status and normalized config
+       *
+       * @example
+       * ```ts
+       * const result = await VideoEncoder.isConfigSupported({
+       *   codec: 'avc1.42E01E',
+       *   width: 1920,
+       *   height: 1080
+       * });
+       *
+       * if (result.supported) {
+       *   console.log('H.264 encoding is supported');
+       * } else {
+       *   console.log('H.264 encoding is NOT supported');
+       * }
+       * ```
+       *
+       * @example Check hardware encoder
+       * ```ts
+       * const hwSupport = await VideoEncoder.isConfigSupported({
+       *   codec: 'h264_videotoolbox',
+       *   width: 3840,
+       *   height: 2160,
+       *   hardwareAcceleration: 'prefer-hardware'
+       * });
+       *
+       * if (!hwSupport.supported) {
+       *   // Fallback to software encoder
+       *   encoder.configure({ codec: 'avc1.42E01E', ... });
+       * }
+       * ```
+       */
+      static async isConfigSupported(config) {
+        if (!config.codec || config.width <= 0 || config.height <= 0) {
+          return { supported: false, config };
+        }
+        if (!(0, codec_registry_1.isVideoCodecSupported)(config.codec)) {
+          return { supported: false, config };
+        }
+        if (native_1.native?.CapabilityProbe?.probeVideoEncoder) {
+          try {
+            const ffmpegCodec = (0, codec_registry_1.getFFmpegVideoCodec)(config.codec);
+            const result = native_1.native.CapabilityProbe.probeVideoEncoder({
+              codec: ffmpegCodec,
+              width: config.width,
+              height: config.height,
+              hardwareAcceleration: config.hardwareAcceleration || "no-preference"
+            });
+            return {
+              supported: result.supported,
+              config
+            };
+          } catch {
+          }
+        }
+        return { supported: true, config };
+      }
+      /**
+       * Create a new VideoEncoder
+       *
+       * @param init - Initialization callbacks for output and errors
+       * @throws TypeError if callbacks are not functions
+       *
+       * @example
+       * ```ts
+       * const encoder = new VideoEncoder({
+       *   output: (chunk, metadata) => {
+       *     // Handle encoded chunk
+       *     if (metadata?.decoderConfig) {
+       *       console.log('Received decoder config:', metadata.decoderConfig);
+       *     }
+       *   },
+       *   error: (err) => {
+       *     console.error('Encoding failed:', err.message);
+       *   }
+       * });
+       * ```
+       */
+      constructor(init) {
+        this._state = "unconfigured";
+        this._encodeQueueSize = 0;
+        this._pendingCallbacks = 0;
+        this._config = null;
+        this._sentDecoderConfig = false;
+        this._listeners = /* @__PURE__ */ new Map();
+        this._useAsync = true;
+        this._nativeCreated = false;
+        this._ondequeue = null;
+        if (!init.output || typeof init.output !== "function") {
+          throw new TypeError("output callback is required");
+        }
+        if (!init.error || typeof init.error !== "function") {
+          throw new TypeError("error callback is required");
+        }
+        this._outputCallback = init.output;
+        this._errorCallback = init.error;
+      }
+      /**
+       * Current encoder state
+       * - `unconfigured`: Not configured yet, or reset() was called
+       * - `configured`: Ready to encode frames
+       * - `closed`: Encoder has been closed and cannot be used
+       */
+      get state() {
+        return this._state;
+      }
+      /**
+       * Number of pending encode operations
+       * Useful for backpressure management in async mode
+       *
+       * @example Backpressure handling
+       * ```ts
+       * for (const frame of frames) {
+       *   encoder.encode(frame);
+       *
+       *   // Wait if queue gets too large
+       *   if (encoder.encodeQueueSize > 10) {
+       *     await new Promise(resolve => {
+       *       encoder.addEventListener('dequeue', resolve, { once: true });
+       *     });
+       *   }
+       * }
+       * ```
+       */
+      get encodeQueueSize() {
+        return this._encodeQueueSize;
+      }
+      /**
+       * Event handler for dequeue events
+       *
+       * Called when an item is removed from the encode queue. Useful for backpressure
+       * management. This is an alternative to using addEventListener('dequeue', ...).
+       *
+       * @example
+       * ```ts
+       * encoder.ondequeue = () => {
+       *   console.log('Queue size:', encoder.encodeQueueSize);
+       * };
+       * ```
+       */
+      get ondequeue() {
+        return this._ondequeue;
+      }
+      set ondequeue(handler) {
+        this._ondequeue = handler;
+      }
+      /**
+       * Add an event listener
+       * Currently supports 'dequeue' events fired when encode queue decreases
+       *
+       * @param type - Event type ('dequeue')
+       * @param listener - Callback to invoke
+       * @param options - Event listener options
+       *
+       * @example Wait for queue to drain
+       * ```ts
+       * encoder.addEventListener('dequeue', () => {
+       *   console.log('Queue size:', encoder.encodeQueueSize);
+       * });
+       * ```
+       */
+      addEventListener(type, listener, options) {
+        if (typeof listener !== "function")
+          return;
+        const once = !!(options && options.once);
+        const wrapper = once ? () => {
+          this.removeEventListener(type, wrapper);
+          listener();
+        } : listener;
+        let set = this._listeners.get(type);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this._listeners.set(type, set);
+        }
+        set.add(wrapper);
+      }
+      /**
+       * Remove an event listener
+       *
+       * @param type - Event type ('dequeue')
+       * @param listener - Callback to remove
+       */
+      removeEventListener(type, listener) {
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        if (set.has(listener)) {
+          set.delete(listener);
+        }
+        if (set.size === 0) {
+          this._listeners.delete(type);
+        }
+      }
+      _dispatchEvent(type) {
+        if (type === "dequeue" && this._ondequeue) {
+          try {
+            this._ondequeue(new Event("dequeue"));
+          } catch {
+          }
+        }
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        for (const listener of Array.from(set)) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+      }
+      /**
+       * Configure the encoder with codec parameters
+       *
+       * Must be called before encoding frames. Can be called multiple times to
+       * reconfigure (e.g., to change bitrate or resolution).
+       *
+       * @param config - Encoder configuration
+       * @throws DOMException if encoder is closed
+       * @throws DOMException if codec is not supported
+       * @throws DOMException if dimensions are invalid
+       *
+       * @example Basic H.264
+       * ```ts
+       * encoder.configure({
+       *   codec: 'avc1.42E01E',
+       *   width: 1920,
+       *   height: 1080,
+       *   bitrate: 5_000_000,
+       *   framerate: 30
+       * });
+       * ```
+       *
+       * @example Hardware acceleration
+       * ```ts
+       * encoder.configure({
+       *   codec: 'h264_videotoolbox',  // macOS
+       *   width: 1920,
+       *   height: 1080,
+       *   hardwareAcceleration: 'prefer-hardware'
+       * });
+       * ```
+       *
+       * @example VP9 with HDR
+       * ```ts
+       * encoder.configure({
+       *   codec: 'vp09.00.10.08',
+       *   width: 3840,
+       *   height: 2160,
+       *   bitrate: 20_000_000,
+       *   colorSpace: {
+       *     primaries: 'bt2020',
+       *     transfer: 'pq',
+       *     matrix: 'bt2020-ncl'
+       *   }
+       * });
+       * ```
+       */
+      configure(config) {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Encoder is closed", "InvalidStateError");
+        }
+        if (!(0, codec_registry_1.isVideoCodecSupported)(config.codec)) {
+          throw new types_1.DOMException(`Unsupported codec: ${config.codec}`, "NotSupportedError");
+        }
+        if (config.width <= 0 || config.height <= 0) {
+          throw new types_1.DOMException("Invalid dimensions", "NotSupportedError");
+        }
+        if (config.latencyMode && !["quality", "realtime"].includes(config.latencyMode)) {
+          throw new types_1.DOMException(`Invalid latencyMode: ${config.latencyMode}. Must be 'quality' or 'realtime'.`, "TypeError");
+        }
+        if (config.bitrateMode && !["constant", "variable", "quantizer"].includes(config.bitrateMode)) {
+          throw new types_1.DOMException(`Invalid bitrateMode: ${config.bitrateMode}. Must be 'constant', 'variable', or 'quantizer'.`, "TypeError");
+        }
+        if (!native_1.native) {
+          throw new types_1.DOMException("Native addon not available", "NotSupportedError");
+        }
+        this._useAsync = config.useWorkerThread !== false && !!native_1.native.VideoEncoderAsync;
+        if (!this._nativeCreated) {
+          if (this._useAsync) {
+            this._native = new native_1.native.VideoEncoderAsync(this._onChunk.bind(this), this._onError.bind(this));
+          } else {
+            this._native = new native_1.native.VideoEncoderNative(this._onChunk.bind(this), this._onError.bind(this));
+          }
+          this._nativeCreated = true;
+        }
+        const ffmpegCodec = (0, codec_registry_1.getFFmpegVideoCodec)(config.codec);
+        const codecParams = {
+          codec: ffmpegCodec,
+          width: config.width,
+          height: config.height
+        };
+        if (config.codec.startsWith("avc1.")) {
+          const avcInfo = (0, codec_registry_1.parseAvcCodecString)(config.codec);
+          if (avcInfo) {
+            codecParams.profile = avcInfo.profile;
+            codecParams.level = avcInfo.level;
+          }
+          codecParams.avcFormat = config.avc?.format ?? "annexb";
+        }
+        if (config.bitrate)
+          codecParams.bitrate = config.bitrate;
+        if (config.framerate)
+          codecParams.framerate = config.framerate;
+        if (config.bitrateMode)
+          codecParams.bitrateMode = config.bitrateMode;
+        if (config.latencyMode)
+          codecParams.latencyMode = config.latencyMode;
+        if (config.colorSpace)
+          codecParams.colorSpace = config.colorSpace;
+        if (config.hardwareAcceleration)
+          codecParams.hardwareAcceleration = config.hardwareAcceleration;
+        if (config.alpha)
+          codecParams.alpha = config.alpha;
+        if (config.scalabilityMode)
+          codecParams.scalabilityMode = config.scalabilityMode;
+        this._native.configure(codecParams);
+        this._config = config;
+        this._state = "configured";
+        this._sentDecoderConfig = false;
+      }
+      /**
+       * Encode a video frame
+       *
+       * Queues a frame for encoding. In async mode (default), encoding happens in
+       * a worker thread and the output callback is invoked when complete.
+       *
+       * **IMPORTANT**: Always call `frame.close()` after encoding to prevent memory leaks.
+       *
+       * @param frame - VideoFrame to encode
+       * @param options - Encoding options (keyFrame)
+       * @throws DOMException if encoder is not configured
+       * @throws DOMException if frame is invalid
+       *
+       * @example Basic encoding
+       * ```ts
+       * const frame = new VideoFrame(buffer, {
+       *   format: 'RGBA',
+       *   codedWidth: 1920,
+       *   codedHeight: 1080,
+       *   timestamp: 0
+       * });
+       *
+       * encoder.encode(frame);
+       * frame.close();  // MUST close to prevent memory leak
+       * ```
+       *
+       * @example Force keyframe
+       * ```ts
+       * // Force first frame to be keyframe
+       * encoder.encode(frame, { keyFrame: true });
+       * frame.close();
+       *
+       * // Keyframe every 2 seconds at 30fps
+       * for (let i = 0; i < frames.length; i++) {
+       *   encoder.encode(frames[i], { keyFrame: i % 60 === 0 });
+       *   frames[i].close();
+       * }
+       * ```
+       */
+      encode(frame, options) {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Encoder is not configured", "InvalidStateError");
+        }
+        const nativeFrame = frame._getNative();
+        if (!nativeFrame) {
+          throw new types_1.DOMException("VideoFrame has no native handle", "InvalidStateError");
+        }
+        const keyFrame = options?.keyFrame ?? false;
+        this._encodeQueueSize++;
+        this._pendingCallbacks++;
+        this._native.encode(nativeFrame, frame.timestamp, keyFrame);
+        setImmediate(() => {
+          this._pendingCallbacks--;
+          this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
+          this._dispatchEvent("dequeue");
+        });
+      }
+      /**
+       * Wait for all pending encodes to complete
+       *
+       * Flushes the internal encode queue and returns a promise that resolves when
+       * all frames have been encoded. Call this before closing the encoder to ensure
+       * no frames are lost.
+       *
+       * @returns Promise that resolves when flush is complete
+       * @throws DOMException if encoder is not configured
+       * @throws DOMException if encoding fails
+       *
+       * @example
+       * ```ts
+       * // Encode all frames
+       * for (const frame of frames) {
+       *   encoder.encode(frame);
+       *   frame.close();
+       * }
+       *
+       * // Wait for encoding to finish
+       * await encoder.flush();
+       *
+       * console.log('All frames encoded!');
+       * encoder.close();
+       * ```
+       */
+      async flush() {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Encoder is not configured", "InvalidStateError");
+        }
+        return new Promise((resolve, reject) => {
+          this._native.flush(async (err) => {
+            if (err) {
+              reject(new types_1.DOMException(err.message, "EncodingError"));
+            } else {
+              while (this._pendingCallbacks > 0) {
+                await new Promise((r) => setImmediate(r));
+              }
+              resolve();
+            }
+          });
+        });
+      }
+      /**
+       * Reset the encoder to unconfigured state
+       *
+       * Aborts all pending encode operations and resets to unconfigured state.
+       * You must call `configure()` again before encoding more frames.
+       *
+       * @throws DOMException if encoder is closed
+       *
+       * @example
+       * ```ts
+       * encoder.configure({ codec: 'avc1.42E01E', width: 1920, height: 1080 });
+       * encoder.encode(frame1);
+       *
+       * // Abort and reconfigure with different settings
+       * encoder.reset();
+       * encoder.configure({ codec: 'vp09.00.10.08', width: 1280, height: 720 });
+       * encoder.encode(frame2);
+       * ```
+       */
+      reset() {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Encoder is closed", "InvalidStateError");
+        }
+        if (this._native) {
+          this._native.reset();
+        }
+        this._encodeQueueSize = 0;
+        this._state = "unconfigured";
+        this._sentDecoderConfig = false;
+        this._config = null;
+      }
+      /**
+       * Close the encoder and release resources
+       *
+       * Closes the encoder and frees all native resources. The encoder cannot be
+       * used after calling close(). Any pending encode operations are aborted.
+       *
+       * @example
+       * ```ts
+       * // Encode frames
+       * for (const frame of frames) {
+       *   encoder.encode(frame);
+       *   frame.close();
+       * }
+       *
+       * await encoder.flush();
+       * encoder.close();  // Release resources
+       *
+       * // encoder.encode() will now throw
+       * ```
+       */
+      close() {
+        if (this._state === "closed")
+          return;
+        if (this._native) {
+          this._native.close();
+        }
+        this._state = "closed";
+        this._encodeQueueSize = 0;
+        this._config = null;
+      }
+      _onChunk(data, isKeyframe, timestamp, duration, extradata) {
+        const dataCopy = new Uint8Array(data);
+        const extradataCopy = extradata ? new Uint8Array(extradata) : void 0;
+        const chunk = new EncodedVideoChunk_1.EncodedVideoChunk({
+          type: isKeyframe ? "key" : "delta",
+          timestamp,
+          duration: duration > 0 ? duration : void 0,
+          data: dataCopy
+        });
+        let metadata;
+        if (isKeyframe && !this._sentDecoderConfig && this._config) {
+          const colorSpace = this._config.colorSpace ?? {
+            primaries: "bt709",
+            transfer: "iec61966-2-1",
+            matrix: "rgb",
+            fullRange: true
+          };
+          metadata = {
+            decoderConfig: {
+              codec: this._config.codec,
+              codedWidth: this._config.width,
+              codedHeight: this._config.height,
+              description: extradataCopy ? extradataCopy.buffer : void 0,
+              colorSpace
+            }
+          };
+          this._sentDecoderConfig = true;
+        }
+        try {
+          this._outputCallback(chunk, metadata);
+        } catch (e) {
+        }
+      }
+      _onError(message) {
+        try {
+          this._errorCallback(new types_1.DOMException(message, "EncodingError"));
+        } catch (e) {
+        }
+      }
+    };
+    exports.VideoEncoder = VideoEncoder;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoDecoder.js
+var require_VideoDecoder = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/VideoDecoder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VideoDecoder = void 0;
+    var VideoFrame_1 = require_VideoFrame();
+    var codec_registry_1 = require_codec_registry();
+    var types_1 = require_types();
+    var native_1 = require_native();
+    var VideoDecoder2 = class {
+      static async isConfigSupported(config) {
+        if (!config.codec) {
+          return { supported: false, config };
+        }
+        if (!(0, codec_registry_1.isVideoCodecSupported)(config.codec)) {
+          return { supported: false, config };
+        }
+        if (native_1.native?.CapabilityProbe?.probeVideoDecoder) {
+          try {
+            const ffmpegCodec = (0, codec_registry_1.getFFmpegVideoDecoder)(config.codec);
+            const result = native_1.native.CapabilityProbe.probeVideoDecoder({
+              codec: ffmpegCodec,
+              width: config.codedWidth || 1920,
+              height: config.codedHeight || 1080,
+              hardwareAcceleration: config.hardwareAcceleration || "no-preference"
+            });
+            return {
+              supported: result.supported,
+              config
+            };
+          } catch {
+          }
+        }
+        return { supported: true, config };
+      }
+      constructor(init) {
+        this._state = "unconfigured";
+        this._decodeQueueSize = 0;
+        this._pendingCallbacks = 0;
+        this._config = null;
+        this._listeners = /* @__PURE__ */ new Map();
+        this._useAsync = true;
+        this._nativeCreated = false;
+        this._ondequeue = null;
+        if (!init.output || typeof init.output !== "function") {
+          throw new TypeError("output callback is required");
+        }
+        if (!init.error || typeof init.error !== "function") {
+          throw new TypeError("error callback is required");
+        }
+        this._outputCallback = init.output;
+        this._errorCallback = init.error;
+      }
+      get state() {
+        return this._state;
+      }
+      get decodeQueueSize() {
+        return this._decodeQueueSize;
+      }
+      /**
+       * Event handler for dequeue events
+       */
+      get ondequeue() {
+        return this._ondequeue;
+      }
+      set ondequeue(handler) {
+        this._ondequeue = handler;
+      }
+      /**
+       * Minimal EventTarget-style API for 'dequeue' events.
+       * Enables compatibility with MediaBunny and browser WebCodecs code.
+       */
+      addEventListener(type, listener, options) {
+        if (typeof listener !== "function")
+          return;
+        const once = !!(options && options.once);
+        const wrapper = once ? () => {
+          this.removeEventListener(type, wrapper);
+          listener();
+        } : listener;
+        let set = this._listeners.get(type);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this._listeners.set(type, set);
+        }
+        set.add(wrapper);
+      }
+      removeEventListener(type, listener) {
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        if (set.has(listener)) {
+          set.delete(listener);
+        }
+        if (set.size === 0) {
+          this._listeners.delete(type);
+        }
+      }
+      _dispatchEvent(type) {
+        if (type === "dequeue" && this._ondequeue) {
+          try {
+            this._ondequeue(new Event("dequeue"));
+          } catch {
+          }
+        }
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        for (const listener of Array.from(set)) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+      }
+      configure(config) {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Decoder is closed", "InvalidStateError");
+        }
+        if (!(0, codec_registry_1.isVideoCodecSupported)(config.codec)) {
+          throw new types_1.DOMException(`Unsupported codec: ${config.codec}`, "NotSupportedError");
+        }
+        if (!native_1.native) {
+          throw new types_1.DOMException("Native addon not available", "NotSupportedError");
+        }
+        this._useAsync = config.useWorkerThread !== false && !!native_1.native.VideoDecoderAsync;
+        if (!this._nativeCreated) {
+          if (this._useAsync) {
+            this._native = new native_1.native.VideoDecoderAsync(this._onFrame.bind(this), this._onError.bind(this));
+          } else {
+            this._native = new native_1.native.VideoDecoderNative(this._onFrame.bind(this), this._onError.bind(this));
+          }
+          this._nativeCreated = true;
+        }
+        const ffmpegCodec = (0, codec_registry_1.getFFmpegVideoDecoder)(config.codec);
+        const codecParams = { codec: ffmpegCodec };
+        if (config.codec.startsWith("avc1.")) {
+          const avcInfo = (0, codec_registry_1.parseAvcCodecString)(config.codec);
+          if (avcInfo) {
+            codecParams.profile = avcInfo.profile;
+            codecParams.level = avcInfo.level;
+          }
+        }
+        if (config.codedWidth)
+          codecParams.width = config.codedWidth;
+        if (config.codedHeight)
+          codecParams.height = config.codedHeight;
+        if (config.description) {
+          let desc;
+          if (config.description instanceof ArrayBuffer) {
+            desc = new Uint8Array(config.description);
+          } else {
+            desc = new Uint8Array(config.description.buffer, config.description.byteOffset, config.description.byteLength);
+          }
+          codecParams.extradata = Buffer.from(desc);
+        }
+        this._native.configure(codecParams);
+        this._config = config;
+        this._state = "configured";
+      }
+      decode(chunk) {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Decoder is not configured", "InvalidStateError");
+        }
+        const data = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(data);
+        this._decodeQueueSize++;
+        this._pendingCallbacks++;
+        this._native.decode(Buffer.from(data), chunk.type === "key", chunk.timestamp, chunk.duration ?? 0);
+        setImmediate(() => {
+          this._pendingCallbacks--;
+          this._decodeQueueSize = Math.max(0, this._decodeQueueSize - 1);
+          this._dispatchEvent("dequeue");
+        });
+      }
+      async flush() {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Decoder is not configured", "InvalidStateError");
+        }
+        return new Promise((resolve, reject) => {
+          this._native.flush(async (err) => {
+            if (err) {
+              reject(new types_1.DOMException(err.message, "EncodingError"));
+            } else {
+              while (this._pendingCallbacks > 0) {
+                await new Promise((r) => setImmediate(r));
+              }
+              resolve();
+            }
+          });
+        });
+      }
+      reset() {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Decoder is closed", "InvalidStateError");
+        }
+        if (this._native) {
+          this._native.reset();
+        }
+        this._decodeQueueSize = 0;
+        this._state = "unconfigured";
+        this._config = null;
+      }
+      close() {
+        if (this._state === "closed")
+          return;
+        if (this._native) {
+          this._native.close();
+        }
+        this._state = "closed";
+        this._decodeQueueSize = 0;
+        this._config = null;
+      }
+      _onFrame(nativeFrame, timestamp, duration) {
+        const width = nativeFrame.width;
+        const height = nativeFrame.height;
+        const format = nativeFrame.format || "I420";
+        const size = nativeFrame.allocationSize();
+        const buffer = Buffer.alloc(size);
+        nativeFrame.copyTo(buffer);
+        try {
+          const frame = new VideoFrame_1.VideoFrame(buffer, {
+            format,
+            codedWidth: width,
+            codedHeight: height,
+            timestamp,
+            duration: duration > 0 ? duration : void 0
+          });
+          this._outputCallback(frame);
+        } catch (e) {
+          console.error("VideoDecoder output callback error:", e);
+        }
+      }
+      _onError(message) {
+        try {
+          this._errorCallback(new types_1.DOMException(message, "EncodingError"));
+        } catch (e) {
+        }
+      }
+    };
+    exports.VideoDecoder = VideoDecoder2;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/AudioEncoder.js
+var require_AudioEncoder = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/AudioEncoder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AudioEncoder = void 0;
+    var EncodedAudioChunk_1 = require_EncodedAudioChunk();
+    var codec_registry_1 = require_codec_registry();
+    var types_1 = require_types();
+    var native_1 = require_native();
+    var AudioEncoder = class {
+      static async isConfigSupported(config) {
+        const supported = (0, codec_registry_1.isAudioCodecSupported)(config.codec) && config.sampleRate > 0 && config.numberOfChannels > 0;
+        return { supported, config };
+      }
+      constructor(init) {
+        this._state = "unconfigured";
+        this._encodeQueueSize = 0;
+        this._pendingCallbacks = 0;
+        this._config = null;
+        this._sentDecoderConfig = false;
+        this._listeners = /* @__PURE__ */ new Map();
+        this._ondequeue = null;
+        if (!init.output || typeof init.output !== "function") {
+          throw new TypeError("output callback is required");
+        }
+        if (!init.error || typeof init.error !== "function") {
+          throw new TypeError("error callback is required");
+        }
+        this._outputCallback = init.output;
+        this._errorCallback = init.error;
+        if (native_1.native) {
+          this._native = new native_1.native.AudioEncoderNative(this._onChunk.bind(this), this._onError.bind(this));
+        }
+      }
+      get state() {
+        return this._state;
+      }
+      get encodeQueueSize() {
+        return this._encodeQueueSize;
+      }
+      /**
+       * Event handler for dequeue events
+       */
+      get ondequeue() {
+        return this._ondequeue;
+      }
+      set ondequeue(handler) {
+        this._ondequeue = handler;
+      }
+      /**
+       * Minimal EventTarget-style API for 'dequeue' events, mirroring VideoEncoder.
+       */
+      addEventListener(type, listener, options) {
+        if (typeof listener !== "function")
+          return;
+        const once = !!(options && options.once);
+        const wrapper = once ? () => {
+          this.removeEventListener(type, wrapper);
+          listener();
+        } : listener;
+        let set = this._listeners.get(type);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this._listeners.set(type, set);
+        }
+        set.add(wrapper);
+      }
+      removeEventListener(type, listener) {
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        if (set.has(listener)) {
+          set.delete(listener);
+        }
+        if (set.size === 0) {
+          this._listeners.delete(type);
+        }
+      }
+      _dispatchEvent(type) {
+        if (type === "dequeue" && this._ondequeue) {
+          try {
+            this._ondequeue(new Event("dequeue"));
+          } catch {
+          }
+        }
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        for (const listener of Array.from(set)) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+      }
+      configure(config) {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Encoder is closed", "InvalidStateError");
+        }
+        if (!(0, codec_registry_1.isAudioCodecSupported)(config.codec)) {
+          throw new types_1.DOMException(`Unsupported codec: ${config.codec}`, "NotSupportedError");
+        }
+        if (!native_1.native) {
+          throw new types_1.DOMException("Native addon not available", "NotSupportedError");
+        }
+        if (config.sampleRate <= 0 || config.numberOfChannels <= 0) {
+          throw new types_1.DOMException("Invalid audio parameters", "NotSupportedError");
+        }
+        const ffmpegCodec = (0, codec_registry_1.getFFmpegAudioCodec)(config.codec);
+        const codecParams = {
+          codec: ffmpegCodec,
+          sampleRate: config.sampleRate,
+          channels: config.numberOfChannels
+        };
+        if (config.bitrate)
+          codecParams.bitrate = config.bitrate;
+        this._native.configure(codecParams);
+        this._config = config;
+        this._state = "configured";
+        this._sentDecoderConfig = false;
+      }
+      encode(data) {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Encoder is not configured", "InvalidStateError");
+        }
+        const bufferSize = data.allocationSize({ planeIndex: 0 });
+        const buffer = new ArrayBuffer(bufferSize);
+        data.copyTo(buffer, { planeIndex: 0 });
+        this._encodeQueueSize++;
+        this._pendingCallbacks++;
+        this._native.encode(new Float32Array(buffer), data.format, data.sampleRate, data.numberOfFrames, data.numberOfChannels, data.timestamp);
+        setImmediate(() => {
+          this._pendingCallbacks--;
+          this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
+          this._dispatchEvent("dequeue");
+        });
+      }
+      async flush() {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Encoder is not configured", "InvalidStateError");
+        }
+        return new Promise((resolve, reject) => {
+          this._native.flush(async (err) => {
+            if (err) {
+              reject(new types_1.DOMException(err.message, "EncodingError"));
+            } else {
+              while (this._pendingCallbacks > 0) {
+                await new Promise((r) => setImmediate(r));
+              }
+              resolve();
+            }
+          });
+        });
+      }
+      reset() {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Encoder is closed", "InvalidStateError");
+        }
+        if (this._native) {
+          this._native.reset();
+        }
+        this._encodeQueueSize = 0;
+        this._state = "unconfigured";
+        this._sentDecoderConfig = false;
+        this._config = null;
+      }
+      close() {
+        if (this._state === "closed")
+          return;
+        if (this._native) {
+          this._native.close();
+        }
+        this._state = "closed";
+        this._encodeQueueSize = 0;
+        this._config = null;
+      }
+      _onChunk(data, timestamp, duration, extradata) {
+        const chunk = new EncodedAudioChunk_1.EncodedAudioChunk({
+          type: "key",
+          // Audio frames are typically all keyframes
+          timestamp,
+          duration: duration > 0 ? duration : void 0,
+          data
+        });
+        let metadata;
+        if (!this._sentDecoderConfig && this._config) {
+          metadata = {
+            decoderConfig: {
+              codec: this._config.codec,
+              sampleRate: this._config.sampleRate,
+              numberOfChannels: this._config.numberOfChannels,
+              description: extradata ? new Uint8Array(extradata).buffer : void 0
+            }
+          };
+          this._sentDecoderConfig = true;
+        }
+        try {
+          this._outputCallback(chunk, metadata);
+        } catch (e) {
+        }
+      }
+      _onError(message) {
+        try {
+          this._errorCallback(new types_1.DOMException(message, "EncodingError"));
+        } catch (e) {
+        }
+      }
+    };
+    exports.AudioEncoder = AudioEncoder;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/AudioDecoder.js
+var require_AudioDecoder = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/AudioDecoder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AudioDecoder = void 0;
+    var AudioData_1 = require_AudioData();
+    var codec_registry_1 = require_codec_registry();
+    var types_1 = require_types();
+    var native_1 = require_native();
+    var AudioDecoder = class {
+      static async isConfigSupported(config) {
+        const supported = (0, codec_registry_1.isAudioCodecSupported)(config.codec);
+        return { supported, config };
+      }
+      constructor(init) {
+        this._state = "unconfigured";
+        this._decodeQueueSize = 0;
+        this._config = null;
+        this._ondequeue = null;
+        this._listeners = /* @__PURE__ */ new Map();
+        if (!init.output || typeof init.output !== "function") {
+          throw new TypeError("output callback is required");
+        }
+        if (!init.error || typeof init.error !== "function") {
+          throw new TypeError("error callback is required");
+        }
+        this._outputCallback = init.output;
+        this._errorCallback = init.error;
+        if (native_1.native) {
+          this._native = new native_1.native.AudioDecoderNative(this._onData.bind(this), this._onError.bind(this));
+        }
+      }
+      get state() {
+        return this._state;
+      }
+      get decodeQueueSize() {
+        return this._decodeQueueSize;
+      }
+      /**
+       * Event handler for dequeue events
+       */
+      get ondequeue() {
+        return this._ondequeue;
+      }
+      set ondequeue(handler) {
+        this._ondequeue = handler;
+      }
+      /**
+       * Minimal EventTarget-style API for 'dequeue' events.
+       * Enables compatibility with MediaBunny and browser WebCodecs code.
+       */
+      addEventListener(type, listener, options) {
+        if (typeof listener !== "function")
+          return;
+        const once = !!(options && options.once);
+        const wrapper = once ? () => {
+          this.removeEventListener(type, wrapper);
+          listener();
+        } : listener;
+        let set = this._listeners.get(type);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this._listeners.set(type, set);
+        }
+        set.add(wrapper);
+      }
+      removeEventListener(type, listener) {
+        const set = this._listeners.get(type);
+        if (!set)
+          return;
+        if (set.has(listener)) {
+          set.delete(listener);
+        }
+        if (set.size === 0) {
+          this._listeners.delete(type);
+        }
+      }
+      _dispatchEvent(type) {
+        if (type === "dequeue" && this._ondequeue) {
+          try {
+            this._ondequeue(new Event("dequeue"));
+          } catch {
+          }
+        }
+        const set = this._listeners.get(type);
+        if (set) {
+          for (const listener of set) {
+            try {
+              listener();
+            } catch {
+            }
+          }
+        }
+      }
+      configure(config) {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Decoder is closed", "InvalidStateError");
+        }
+        if (!(0, codec_registry_1.isAudioCodecSupported)(config.codec)) {
+          throw new types_1.DOMException(`Unsupported codec: ${config.codec}`, "NotSupportedError");
+        }
+        if (!native_1.native) {
+          throw new types_1.DOMException("Native addon not available", "NotSupportedError");
+        }
+        const ffmpegCodec = (0, codec_registry_1.getFFmpegAudioDecoder)(config.codec);
+        const codecParams = {
+          codec: ffmpegCodec,
+          sampleRate: config.sampleRate,
+          channels: config.numberOfChannels
+        };
+        if (config.description) {
+          let desc;
+          if (config.description instanceof ArrayBuffer) {
+            desc = new Uint8Array(config.description);
+          } else {
+            desc = new Uint8Array(config.description.buffer, config.description.byteOffset, config.description.byteLength);
+          }
+          codecParams.extradata = Buffer.from(desc);
+        }
+        this._native.configure(codecParams);
+        this._config = config;
+        this._state = "configured";
+      }
+      decode(chunk) {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Decoder is not configured", "InvalidStateError");
+        }
+        const data = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(data);
+        this._decodeQueueSize++;
+        this._native.decode(Buffer.from(data), chunk.type === "key", chunk.timestamp, chunk.duration ?? 0);
+      }
+      async flush() {
+        if (this._state !== "configured") {
+          throw new types_1.DOMException("Decoder is not configured", "InvalidStateError");
+        }
+        return new Promise((resolve, reject) => {
+          this._native.flush((err) => {
+            if (err) {
+              reject(new types_1.DOMException(err.message, "EncodingError"));
+            } else {
+              resolve();
+            }
+          });
+        });
+      }
+      reset() {
+        if (this._state === "closed") {
+          throw new types_1.DOMException("Decoder is closed", "InvalidStateError");
+        }
+        if (this._native) {
+          this._native.reset();
+        }
+        this._decodeQueueSize = 0;
+        this._state = "unconfigured";
+        this._config = null;
+      }
+      close() {
+        if (this._state === "closed")
+          return;
+        if (this._native) {
+          this._native.close();
+        }
+        this._state = "closed";
+        this._decodeQueueSize = 0;
+        this._config = null;
+      }
+      _onData(buffer, format, sampleRate, numberOfFrames, numberOfChannels, timestamp) {
+        const bufferCopy = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength).slice();
+        setImmediate(() => {
+          this._decodeQueueSize = Math.max(0, this._decodeQueueSize - 1);
+          this._dispatchEvent("dequeue");
+          try {
+            const audioData = new AudioData_1.AudioData({
+              format,
+              sampleRate,
+              numberOfFrames,
+              numberOfChannels,
+              timestamp,
+              data: bufferCopy.buffer
+            });
+            this._outputCallback(audioData);
+          } catch (e) {
+            console.error("AudioDecoder output callback error:", e);
+          }
+        });
+      }
+      _onError(message) {
+        try {
+          this._errorCallback(new types_1.DOMException(message, "EncodingError"));
+        } catch (e) {
+        }
+      }
+    };
+    exports.AudioDecoder = AudioDecoder;
+  }
+});
+
+// ../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/node-webcodecs@1.0.0/node_modules/node-webcodecs/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DOMRectReadOnly = exports.parseVp9CodecString = exports.parseAacCodecString = exports.parseAvcCodecString = exports.getFFmpegAudioCodec = exports.getFFmpegVideoCodec = exports.isAudioCodecSupported = exports.isVideoCodecSupported = exports.AudioDecoder = exports.AudioEncoder = exports.VideoDecoder = exports.VideoEncoder = exports.ImageDecoder = exports.VideoColorSpace = exports.EncodedAudioChunk = exports.EncodedVideoChunk = exports.AudioData = exports.VideoFrame = void 0;
+    exports.getFFmpegVersion = getFFmpegVersion;
+    exports.listCodecs = listCodecs;
+    exports.hasCodec = hasCodec;
+    exports.isNativeAvailable = isNativeAvailable;
+    var VideoFrame_1 = require_VideoFrame();
+    Object.defineProperty(exports, "VideoFrame", { enumerable: true, get: function() {
+      return VideoFrame_1.VideoFrame;
+    } });
+    var AudioData_1 = require_AudioData();
+    Object.defineProperty(exports, "AudioData", { enumerable: true, get: function() {
+      return AudioData_1.AudioData;
+    } });
+    var EncodedVideoChunk_1 = require_EncodedVideoChunk();
+    Object.defineProperty(exports, "EncodedVideoChunk", { enumerable: true, get: function() {
+      return EncodedVideoChunk_1.EncodedVideoChunk;
+    } });
+    var EncodedAudioChunk_1 = require_EncodedAudioChunk();
+    Object.defineProperty(exports, "EncodedAudioChunk", { enumerable: true, get: function() {
+      return EncodedAudioChunk_1.EncodedAudioChunk;
+    } });
+    var VideoColorSpace_1 = require_VideoColorSpace();
+    Object.defineProperty(exports, "VideoColorSpace", { enumerable: true, get: function() {
+      return VideoColorSpace_1.VideoColorSpace;
+    } });
+    var ImageDecoder_1 = require_ImageDecoder();
+    Object.defineProperty(exports, "ImageDecoder", { enumerable: true, get: function() {
+      return ImageDecoder_1.ImageDecoder;
+    } });
+    var VideoEncoder_1 = require_VideoEncoder();
+    Object.defineProperty(exports, "VideoEncoder", { enumerable: true, get: function() {
+      return VideoEncoder_1.VideoEncoder;
+    } });
+    var VideoDecoder_1 = require_VideoDecoder();
+    Object.defineProperty(exports, "VideoDecoder", { enumerable: true, get: function() {
+      return VideoDecoder_1.VideoDecoder;
+    } });
+    var AudioEncoder_1 = require_AudioEncoder();
+    Object.defineProperty(exports, "AudioEncoder", { enumerable: true, get: function() {
+      return AudioEncoder_1.AudioEncoder;
+    } });
+    var AudioDecoder_1 = require_AudioDecoder();
+    Object.defineProperty(exports, "AudioDecoder", { enumerable: true, get: function() {
+      return AudioDecoder_1.AudioDecoder;
+    } });
+    var codec_registry_1 = require_codec_registry();
+    Object.defineProperty(exports, "isVideoCodecSupported", { enumerable: true, get: function() {
+      return codec_registry_1.isVideoCodecSupported;
+    } });
+    Object.defineProperty(exports, "isAudioCodecSupported", { enumerable: true, get: function() {
+      return codec_registry_1.isAudioCodecSupported;
+    } });
+    Object.defineProperty(exports, "getFFmpegVideoCodec", { enumerable: true, get: function() {
+      return codec_registry_1.getFFmpegVideoCodec;
+    } });
+    Object.defineProperty(exports, "getFFmpegAudioCodec", { enumerable: true, get: function() {
+      return codec_registry_1.getFFmpegAudioCodec;
+    } });
+    Object.defineProperty(exports, "parseAvcCodecString", { enumerable: true, get: function() {
+      return codec_registry_1.parseAvcCodecString;
+    } });
+    Object.defineProperty(exports, "parseAacCodecString", { enumerable: true, get: function() {
+      return codec_registry_1.parseAacCodecString;
+    } });
+    Object.defineProperty(exports, "parseVp9CodecString", { enumerable: true, get: function() {
+      return codec_registry_1.parseVp9CodecString;
+    } });
+    var types_1 = require_types();
+    Object.defineProperty(exports, "DOMRectReadOnly", { enumerable: true, get: function() {
+      return types_1.DOMRectReadOnly;
+    } });
+    var native_1 = require_native();
+    function getFFmpegVersion() {
+      if (native_1.native && native_1.native.getFFmpegVersion) {
+        return native_1.native.getFFmpegVersion();
+      }
+      return null;
+    }
+    function listCodecs() {
+      if (native_1.native && native_1.native.listCodecs) {
+        return native_1.native.listCodecs();
+      }
+      return null;
+    }
+    function hasCodec(codecName, type) {
+      if (native_1.native && native_1.native.hasCodec) {
+        return native_1.native.hasCodec(codecName, type);
+      }
+      return false;
+    }
+    function isNativeAvailable() {
+      return native_1.native !== null;
+    }
+  }
+});
 
 // src/VoiceManager.ts
 import { EventEmitter as EventEmitter3 } from "events";
@@ -13,6 +2591,9 @@ var thumbnail = MINIMAL_PNG_BASE64;
 import { EventEmitter } from "events";
 import * as nacl from "tweetnacl";
 import * as dgram from "dgram";
+import * as ws from "ws";
+import { Readable } from "stream";
+import { opus } from "prism-media";
 var VOICE_WS_OPCODES = {
   Identify: 0,
   SelectProtocol: 1,
@@ -156,11 +2737,11 @@ var VoiceConnection = class extends EventEmitter {
           this.voiceWs.removeAllListeners();
         }
       };
-      const ws = this.voiceWs;
-      ws.on("open", onOpen);
-      ws.on("error", onError);
-      ws.on("message", (data) => onMessage(data));
-      ws.once("close", () => {
+      const ws2 = this.voiceWs;
+      ws2.on("open", onOpen);
+      ws2.on("error", onError);
+      ws2.on("message", (data) => onMessage(data));
+      ws2.once("close", () => {
         cleanup();
         if (!this._destroyed) reject(new Error("Voice WebSocket closed"));
       });
@@ -168,7 +2749,6 @@ var VoiceConnection = class extends EventEmitter {
   }
   async getWebSocketConstructor() {
     try {
-      const ws = await import("ws");
       return ws.default;
     } catch {
       throw new Error('Install "ws" for voice support: pnpm add ws');
@@ -254,8 +2834,6 @@ var VoiceConnection = class extends EventEmitter {
    */
   async play(urlOrStream) {
     this.stop();
-    const { opus: prismOpus } = await import("prism-media");
-    const { Readable } = await import("stream");
     let inputStream;
     if (typeof urlOrStream === "string") {
       try {
@@ -271,7 +2849,7 @@ var VoiceConnection = class extends EventEmitter {
     } else {
       inputStream = urlOrStream;
     }
-    const demuxer = new prismOpus.WebmDemuxer();
+    const demuxer = new opus.WebmDemuxer();
     inputStream.pipe(demuxer);
     this._playing = true;
     this.currentStream = demuxer;
@@ -364,7 +2942,7 @@ var VoiceConnection = class extends EventEmitter {
 };
 
 // src/LiveKitRtcConnection.ts
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 import {
   Room,
@@ -466,6 +3044,12 @@ function concatUint8Arrays(a, b) {
 }
 
 // src/LiveKitRtcConnection.ts
+var WebCodecs = __toESM(require_dist());
+import { Readable as Readable2 } from "stream";
+import { OpusDecoder } from "opus-decoder";
+import { opus as opus2 } from "prism-media";
+import { promisify } from "util";
+import { createFile } from "mp4box";
 var SAMPLE_RATE = 48e3;
 var CHANNELS2 = 1;
 function getNaluByteLength(nalu) {
@@ -710,13 +3294,11 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
       this.emit("error", new Error("useFFmpeg requires a URL; buffer/ArrayBuffer not supported"));
       return;
     }
-    const { createFile } = await import("mp4box");
-    let VideoDecoder;
-    let EncodedVideoChunk;
+    let VideoDecoder2;
+    let EncodedVideoChunk2;
     try {
-      const webcodecs = await import("./dist-N4IEBIZ4.mjs");
-      VideoDecoder = webcodecs.VideoDecoder;
-      EncodedVideoChunk = webcodecs.EncodedVideoChunk;
+      VideoDecoder2 = WebCodecs.VideoDecoder;
+      EncodedVideoChunk2 = WebCodecs.EncodedVideoChunk;
     } catch {
       this.emit(
         "error",
@@ -800,7 +3382,7 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
       const FRAME_INTERVAL_MS = Math.round(1e3 / maxFps);
       const MAX_QUEUED_FRAMES = 30;
       let pacingInterval = null;
-      const decoder = new VideoDecoder({
+      const decoder = new VideoDecoder2({
         output: async (frame) => {
           if (!this._playingVideo || !source) return;
           const { codedWidth, codedHeight } = frame;
@@ -944,7 +3526,7 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
                 try {
                   for (const sample of samp) {
                     const isKeyFrame = sample.is_sync ?? sample.is_rap ?? sample.dts === 0;
-                    const chunk = new EncodedVideoChunk({
+                    const chunk = new EncodedVideoChunk2({
                       type: isKeyFrame ? "key" : "delta",
                       timestamp: Math.round(sample.dts / sample.timescale * 1e6),
                       duration: Math.round(sample.duration / sample.timescale * 1e6),
@@ -983,7 +3565,7 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
           try {
             for (const sample of samples) {
               const isKeyFrame = sample.is_sync ?? sample.is_rap ?? sample.dts === 0;
-              const chunk = new EncodedVideoChunk({
+              const chunk = new EncodedVideoChunk2({
                 type: isKeyFrame ? "key" : "delta",
                 timestamp: Math.round(sample.dts / sample.timescale * 1e6),
                 duration: Math.round(sample.duration / sample.timescale * 1e6),
@@ -1056,8 +3638,6 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
           file.start();
         });
         if (videoUrl && audioSource && audioTrack) {
-          const { opus: prismOpus } = await import("prism-media");
-          const { OpusDecoder } = await import("opus-decoder");
           const runAudioFfmpeg = async () => {
             if (!this._playingVideo || cleanupCalled || !audioSource) return;
             const audioProc = spawn(
@@ -1079,7 +3659,7 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
               { stdio: ["ignore", "pipe", "pipe"] }
             );
             audioFfmpegProc = audioProc;
-            const demuxer = new prismOpus.WebmDemuxer();
+            const demuxer = new opus2.WebmDemuxer();
             if (audioProc.stdout) audioProc.stdout.pipe(demuxer);
             const decoder2 = new OpusDecoder({ sampleRate: SAMPLE_RATE, channels: CHANNELS2 });
             await decoder2.ready;
@@ -1169,8 +3749,6 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
     let height = 480;
     let hasAudio = false;
     try {
-      const { execFile } = await import("child_process");
-      const { promisify } = await import("util");
       const exec = promisify(execFile);
       const { stdout } = await exec(
         "ffprobe",
@@ -1433,9 +4011,7 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
       }
       if (hasAudio && audioReady && audioSource && proc.stdio[3]) {
         const audioPipe = proc.stdio[3];
-        const { opus: prismOpus } = await import("prism-media");
-        const { OpusDecoder } = await import("opus-decoder");
-        const demuxer = new prismOpus.WebmDemuxer();
+        const demuxer = new opus2.WebmDemuxer();
         audioPipe.pipe(demuxer);
         const decoder = new OpusDecoder({ sampleRate: SAMPLE_RATE, channels: CHANNELS2 });
         await decoder.ready;
@@ -1517,16 +4093,13 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
       this.emit("error", new Error("LiveKit: not connected"));
       return;
     }
-    const { opus: prismOpus } = await import("prism-media");
-    const { Readable } = await import("stream");
-    const { OpusDecoder } = await import("opus-decoder");
     let inputStream;
     if (typeof urlOrStream === "string") {
       try {
         const response = await fetch(urlOrStream);
         if (!response.ok) throw new Error(`HTTP ${response.status}`);
         if (!response.body) throw new Error("No response body");
-        inputStream = Readable.fromWeb(response.body);
+        inputStream = Readable2.fromWeb(response.body);
       } catch (e) {
         this.emit("error", e instanceof Error ? e : new Error(String(e)));
         return;
@@ -1541,7 +4114,7 @@ var LiveKitRtcConnection = class extends EventEmitter2 {
     const options = new TrackPublishOptions();
     options.source = TrackSource.SOURCE_MICROPHONE;
     await this.room.localParticipant.publishTrack(track, options);
-    const demuxer = new prismOpus.WebmDemuxer();
+    const demuxer = new opus2.WebmDemuxer();
     inputStream.pipe(demuxer);
     this.currentStream = demuxer;
     const decoder = new OpusDecoder({ sampleRate: SAMPLE_RATE, channels: CHANNELS2 });