@remotion/video-matting 4.0.527 → 4.0.528

package/dist/esm/index.mjs

@@ -14,6 +14,16 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 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) {
@@ -22,6 +32,363 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/import-node-module.ts
+var importNodeModule = (specifier) => {
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  return dynamicImport(specifier);
+};
+
+// src/probe-node-webgpu.ts
+var exports_probe_node_webgpu = {};
+__export(exports_probe_node_webgpu, {
+  probeNodeWebGpu: () => probeNodeWebGpu
+});
+var webGpuProbeModel, webGpuFp16ProbeModel, probeNodeWebGpu = async ({
+  requiresShaderF16
+}) => {
+  const { InferenceSession, Tensor } = await importNodeModule("onnxruntime-node");
+  const session = await InferenceSession.create(requiresShaderF16 ? webGpuFp16ProbeModel : webGpuProbeModel, {
+    executionProviders: ["webgpu"],
+    extra: { session: { disable_cpu_ep_fallback: "1" } }
+  });
+  try {
+    await session.run({ X: new Tensor("float32", new Float32Array([1]), [1]) });
+  } finally {
+    await session.release();
+  }
+};
+var init_probe_node_webgpu = __esm(() => {
+  webGpuProbeModel = new Uint8Array([
+    8,
+    8,
+    58,
+    64,
+    10,
+    14,
+    10,
+    1,
+    88,
+    10,
+    1,
+    88,
+    18,
+    1,
+    89,
+    34,
+    3,
+    77,
+    117,
+    108,
+    18,
+    12,
+    119,
+    101,
+    98,
+    103,
+    112,
+    117,
+    45,
+    112,
+    114,
+    111,
+    98,
+    101,
+    90,
+    15,
+    10,
+    1,
+    88,
+    18,
+    10,
+    10,
+    8,
+    8,
+    1,
+    18,
+    4,
+    10,
+    2,
+    8,
+    1,
+    98,
+    15,
+    10,
+    1,
+    89,
+    18,
+    10,
+    10,
+    8,
+    8,
+    1,
+    18,
+    4,
+    10,
+    2,
+    8,
+    1,
+    66,
+    2,
+    16,
+    13
+  ]);
+  webGpuFp16ProbeModel = new Uint8Array([
+    8,
+    8,
+    58,
+    114,
+    10,
+    23,
+    10,
+    1,
+    88,
+    18,
+    1,
+    72,
+    34,
+    4,
+    67,
+    97,
+    115,
+    116,
+    42,
+    9,
+    10,
+    2,
+    116,
+    111,
+    24,
+    10,
+    160,
+    1,
+    2,
+    10,
+    14,
+    10,
+    1,
+    72,
+    10,
+    1,
+    72,
+    18,
+    1,
+    83,
+    34,
+    3,
+    77,
+    117,
+    108,
+    10,
+    23,
+    10,
+    1,
+    83,
+    18,
+    1,
+    89,
+    34,
+    4,
+    67,
+    97,
+    115,
+    116,
+    42,
+    9,
+    10,
+    2,
+    116,
+    111,
+    24,
+    1,
+    160,
+    1,
+    2,
+    18,
+    12,
+    119,
+    101,
+    98,
+    103,
+    112,
+    117,
+    45,
+    112,
+    114,
+    111,
+    98,
+    101,
+    90,
+    15,
+    10,
+    1,
+    88,
+    18,
+    10,
+    10,
+    8,
+    8,
+    1,
+    18,
+    4,
+    10,
+    2,
+    8,
+    1,
+    98,
+    15,
+    10,
+    1,
+    89,
+    18,
+    10,
+    10,
+    8,
+    8,
+    1,
+    18,
+    4,
+    10,
+    2,
+    8,
+    1,
+    66,
+    2,
+    16,
+    13
+  ]);
+});
+
+// src/node-video-matting-frames.ts
+var exports_node_video_matting_frames = {};
+__export(exports_node_video_matting_frames, {
+  createNodeVideoMattingFrames: () => createNodeVideoMattingFrames
+});
+import { VideoSample, VideoSampleSink, VideoSampleSource } from "mediabunny";
+var createNodeVideoMattingFrames = ({
+  videoTrack,
+  width,
+  height,
+  videoQuality,
+  keyframeIntervalInSeconds,
+  videoStartTimestamp,
+  videoEndTimestamp,
+  includeBase
+}) => {
+  const sink = new VideoSampleSink(videoTrack);
+  const baseSource = includeBase ? new VideoSampleSource({
+    codec: "vp9",
+    quality: videoQuality,
+    keyFrameInterval: keyframeIntervalInSeconds,
+    alpha: "discard"
+  }) : null;
+  const foregroundSource = new VideoSampleSource({
+    codec: "vp9",
+    quality: videoQuality,
+    keyFrameInterval: keyframeIntervalInSeconds,
+    alpha: "keep"
+  });
+  return {
+    frames: async function* () {
+      for await (const sample of sink.samples(videoStartTimestamp, videoEndTimestamp)) {
+        const data = new Uint8ClampedArray(width * height * 4);
+        try {
+          const transformed = await sample.transform({
+            width,
+            height,
+            fit: "fill"
+          });
+          try {
+            await transformed.copyTo(data, { format: "RGBA" });
+          } finally {
+            transformed.close();
+          }
+        } finally {
+          sample.close();
+        }
+        yield {
+          image: { data, width, height, channels: 4 },
+          timestamp: sample.timestamp,
+          duration: sample.duration
+        };
+      }
+    }(),
+    baseSource,
+    foregroundSource,
+    addFrame: async ({ frame, foreground, timestamp, duration }) => {
+      if (!("data" in frame.image)) {
+        throw new Error("Expected an RGBA frame.");
+      }
+      const baseData = includeBase ? frame.image.data.slice() : null;
+      let foregroundData;
+      if (foreground.width === width && foreground.height === height) {
+        foregroundData = foreground.data.slice();
+      } else {
+        foregroundData = new Uint8ClampedArray(width * height * 4);
+        const foregroundSample = new VideoSample(foreground.data, {
+          format: "RGBA",
+          codedWidth: foreground.width,
+          codedHeight: foreground.height,
+          timestamp,
+          duration
+        });
+        try {
+          const resized = await foregroundSample.transform({
+            width,
+            height,
+            fit: "fill"
+          });
+          try {
+            await resized.copyTo(foregroundData, { format: "RGBA" });
+          } finally {
+            resized.close();
+          }
+        } finally {
+          foregroundSample.close();
+        }
+      }
+      for (let i = 0;i < foregroundData.length; i += 4) {
+        const alpha = frame.image.data[i + 3] / 255;
+        if (baseData) {
+          baseData[i] = Math.round(baseData[i] * alpha);
+          baseData[i + 1] = Math.round(baseData[i + 1] * alpha);
+          baseData[i + 2] = Math.round(baseData[i + 2] * alpha);
+          baseData[i + 3] = 255;
+        }
+        foregroundData[i + 3] = Math.round(foregroundData[i + 3] * alpha);
+      }
+      const base = baseData ? new VideoSample(baseData, {
+        format: "RGBA",
+        codedWidth: width,
+        codedHeight: height,
+        timestamp,
+        duration
+      }) : null;
+      const foregroundFrame = new VideoSample(foregroundData, {
+        format: "RGBA",
+        codedWidth: width,
+        codedHeight: height,
+        timestamp,
+        duration
+      });
+      try {
+        const results = await Promise.allSettled([
+          baseSource?.add(base),
+          foregroundSource.add(foregroundFrame)
+        ]);
+        for (const result of results) {
+          if (result.status === "rejected") {
+            throw result.reason;
+          }
+        }
+      } finally {
+        base?.close();
+        foregroundFrame.close();
+      }
+    }
+  };
+};
+var init_node_video_matting_frames = () => {};
+
 // src/models.ts
 var VIDEO_MATTING_MODELS = ["modnet", "ben2-base"];
 var MODEL_INFO = {
@@ -81,11 +448,25 @@ var canUseVideoMatting = async ({
   model = "modnet"
 } = {}) => {
   const modelInfo = getVideoMattingModelInfo(model);
+  if (typeof window === "undefined" && typeof process !== "undefined" && process.release?.name === "node") {
+    try {
+      const { probeNodeWebGpu: probeNodeWebGpu2 } = await Promise.resolve().then(() => (init_probe_node_webgpu(), exports_probe_node_webgpu));
+      await probeNodeWebGpu2({ requiresShaderF16: modelInfo.requiresShaderF16 });
+      return { supported: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        supported: false,
+        reason: "webgpu-unavailable" /* WebGpuUnavailable */,
+        detailedReason: `ONNX Runtime could not run WebGPU inference for "${model}": ${message}`
+      };
+    }
+  }
   if (typeof window === "undefined" && typeof OffscreenCanvas === "undefined") {
     return {
       supported: false,
       reason: "window-undefined" /* WindowUndefined */,
-      detailedReason: "No browser window or worker canvas environment is available. @remotion/video-matting is intended for browser environments."
+      detailedReason: "No browser, worker canvas, or Node.js environment is available."
     };
   }
   const isSecureContext = typeof window === "undefined" ? globalThis.isSecureContext : window.isSecureContext;
@@ -126,6 +507,13 @@ var canUseVideoMatting = async ({
   }
   return { supported: true };
 };
+// src/symbol-async-dispose.ts
+if (typeof Symbol.asyncDispose !== "symbol") {
+  Object.defineProperty(Symbol, "asyncDispose", {
+    value: Symbol.for("asyncDispose")
+  });
+}
+
 // src/with-remotion-model-host.ts
 var REMOTION_MODEL_HOST = "https://remotion.media/";
 var REMOTION_MODEL_PATH_TEMPLATE = "models/{model}/";
@@ -237,7 +625,8 @@ var getOrCreateVideoMattingPipeline = ({
     activeUses: 0,
     onIdle: [],
     progressListeners: new Set,
-    lastProgress: null
+    lastProgress: null,
+    retainedLoadHandles: 0
   };
   const pendingDisposal = disposals.get(model) ?? null;
   state.loading = Promise.resolve().then(async () => {
@@ -247,39 +636,24 @@ var getOrCreateVideoMattingPipeline = ({
     return withRemotionModelHost(async ({
       AutoModelForImageSegmentation,
       AutoProcessor,
-      BackgroundRemovalPipeline
+      BackgroundRemovalPipeline,
+      ModelRegistry,
+      RawImage
     }) => {
       const hostedModelId = getHostedVideoMattingModelId(model);
-      const totalBytes = modelInfo.webGpuDownloadSize;
-      const loadedByFile = new Map;
-      let lastProgress = 0;
-      let lastLoadedBytes = 0;
+      if (!await ModelRegistry.is_pipeline_cached("background-removal", hostedModelId, { device: "webgpu", dtype: modelInfo.dtype })) {
+        throw new Error(`The video matting model "${model}" is not downloaded. Call downloadVideoMattingModel() first.`);
+      }
       notifyProgress(state, {
-        status: "loading",
+        status: "initializing",
         file: null,
-        progress: 0,
-        loadedBytes: 0,
-        totalBytes
+        progress: null,
+        loadedBytes: null,
+        totalBytes: null
       });
       const pretrainedOptions = {
         device: "webgpu",
-        dtype: modelInfo.dtype,
-        progress_callback: (event) => {
-          const record = event;
-          if (record.status === "progress" && typeof record.file === "string" && typeof record.loaded === "number" && Number.isFinite(record.loaded)) {
-            loadedByFile.set(record.file, Math.max(loadedByFile.get(record.file) ?? 0, record.loaded));
-            const loadedBytes = [...loadedByFile.values()].reduce((sum, loaded) => sum + loaded, 0);
-            lastProgress = Math.max(lastProgress, Math.min(loadedBytes / totalBytes, 0.99));
-            lastLoadedBytes = Math.max(lastLoadedBytes, loadedBytes);
-            notifyProgress(state, {
-              status: "loading",
-              file: null,
-              progress: lastProgress,
-              loadedBytes: Math.min(lastLoadedBytes, totalBytes),
-              totalBytes
-            });
-          }
-        }
+        dtype: modelInfo.dtype
       };
       const transformerProcessor = await AutoProcessor.from_pretrained(hostedModelId, pretrainedOptions);
       const transformerModel = await AutoModelForImageSegmentation.from_pretrained(hostedModelId, pretrainedOptions);
@@ -296,12 +670,12 @@ var getOrCreateVideoMattingPipeline = ({
           status: "ready",
           file: null,
           progress: 1,
-          loadedBytes: totalBytes,
-          totalBytes
+          loadedBytes: null,
+          totalBytes: null
         });
         const loadedPipeline = {
           run: async (image) => {
-            const result = await loadedTransformerPipeline(image);
+            const result = await loadedTransformerPipeline("data" in image ? new RawImage(image.data, image.width, image.height, image.channels) : image);
             if (result.channels !== 4) {
               throw new Error(`The video matting model "${model}" returned ${result.channels} channels instead of RGBA.`);
             }
@@ -355,18 +729,94 @@ var subscribeToProgress = (state, onProgress) => {
     state.progressListeners.delete(listener);
   };
 };
+var disposeVideoMattingModel = async ({
+  model
+} = {}) => {
+  if (model !== undefined) {
+    getVideoMattingModelInfo(model);
+  }
+  const matching = [...pipelines.entries()].filter(([loadedModel]) => {
+    return model === undefined || loadedModel === model;
+  });
+  for (const [key, state] of matching) {
+    if (pipelines.get(key) === state) {
+      pipelines.delete(key);
+    }
+  }
+  const pending = new Map;
+  for (const [key, disposal] of disposals) {
+    if (model === undefined || model === key) {
+      pending.set(key, disposal);
+    }
+  }
+  for (const [key, state] of matching) {
+    const previousDisposal = disposals.get(key) ?? Promise.resolve();
+    const disposal = previousDisposal.then(async () => {
+      const loadedPipeline = await state.loading;
+      if (state.pendingUses > 0 || state.activeUses > 0) {
+        await new Promise((resolve) => {
+          state.onIdle.push(resolve);
+        });
+      }
+      await loadedPipeline.dispose();
+    });
+    const disposalBarrier = disposal.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    disposals.set(key, disposalBarrier);
+    disposalBarrier.then(() => {
+      if (disposals.get(key) === disposalBarrier) {
+        disposals.delete(key);
+      }
+    });
+    pending.set(key, disposal);
+  }
+  await Promise.all(pending.values());
+};
 var loadVideoMattingModel = async ({
   model,
+  signal,
   onProgress
 }) => {
+  signal?.throwIfAborted();
   const { state, alreadyLoaded } = getOrCreateVideoMattingPipeline({ model });
+  state.pendingUses++;
   const unsubscribe = subscribeToProgress(state, onProgress);
   try {
-    await state.loading;
+    await waitForLoadingOrAbort({
+      loading: state.loading,
+      signal: signal ?? null
+    });
+    signal?.throwIfAborted();
+    state.retainedLoadHandles++;
   } finally {
     unsubscribe();
+    state.pendingUses--;
+    notifyIfIdle(state);
+    if (signal?.aborted && state.pendingUses === 0 && state.activeUses === 0 && state.retainedLoadHandles === 0 && pipelines.get(model) === state) {
+      disposeVideoMattingModel({ model }).catch(() => {
+        return;
+      });
+    }
   }
-  return { alreadyLoaded };
+  let released = false;
+  const result = { alreadyLoaded };
+  Object.defineProperty(result, Symbol.asyncDispose, {
+    enumerable: false,
+    value: async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      state.retainedLoadHandles--;
+      if (state.retainedLoadHandles === 0 && pipelines.get(model) === state) {
+        await disposeVideoMattingModel({ model });
+      }
+    }
+  });
+  return result;
 };
 var withLoadedVideoMattingPipeline = async ({
   model,
@@ -397,51 +847,152 @@ var withLoadedVideoMattingPipeline = async ({
     notifyIfIdle(state);
   }
 };
-var disposeVideoMattingModel = async ({
-  model
-} = {}) => {
-  if (model !== undefined) {
-    getVideoMattingModelInfo(model);
+// src/download-video-matting-model.ts
+var downloadVideoMattingModel = ({
+  model,
+  signal,
+  onProgress
+}) => {
+  const modelInfo = getVideoMattingModelInfo(model);
+  const totalBytes = modelInfo.webGpuDownloadSize;
+  const hostedModelId = getHostedVideoMattingModelId(model);
+  if (signal?.aborted) {
+    return Promise.reject(signal.reason);
   }
-  const matching = [...pipelines.entries()].filter(([loadedModel]) => {
-    return model === undefined || loadedModel === model;
-  });
-  for (const [key, state] of matching) {
-    if (pipelines.get(key) === state) {
-      pipelines.delete(key);
+  return withRemotionModelHost(async ({ env, ModelRegistry }) => {
+    signal?.throwIfAborted();
+    const cache = env.useCustomCache ? env.customCache : env.useBrowserCache && typeof caches !== "undefined" ? await caches.open(env.cacheKey) : null;
+    const useFileCache = cache === null && env.useFSCache;
+    if (cache === null && !useFileCache) {
+      throw new Error("A Transformers.js model cache is required to download a video matting model.");
     }
-  }
-  const pending = new Map;
-  for (const [key, disposal] of disposals) {
-    if (model === undefined || model === key) {
-      pending.set(key, disposal);
+    const registryOptions = {
+      device: "webgpu",
+      dtype: modelInfo.dtype
+    };
+    const cacheStatus = await ModelRegistry.is_pipeline_cached_files("background-removal", hostedModelId, registryOptions);
+    signal?.throwIfAborted();
+    if (cacheStatus.allCached) {
+      onProgress?.({
+        file: null,
+        progress: 1,
+        loadedBytes: totalBytes,
+        totalBytes
+      });
+      signal?.throwIfAborted();
+      return { alreadyDownloaded: true };
     }
-  }
-  for (const [key, state] of matching) {
-    const previousDisposal = disposals.get(key) ?? Promise.resolve();
-    const disposal = previousDisposal.then(async () => {
-      const loadedPipeline = await state.loading;
-      if (state.pendingUses > 0 || state.activeUses > 0) {
-        await new Promise((resolve) => {
-          state.onIdle.push(resolve);
-        });
+    let loadedBytes = 0;
+    const emitProgress = (file) => {
+      onProgress?.({
+        file,
+        progress: Math.min(loadedBytes / totalBytes, 0.99),
+        loadedBytes,
+        totalBytes
+      });
+    };
+    emitProgress(null);
+    for (const { file, cached } of cacheStatus.files) {
+      signal?.throwIfAborted();
+      if (cached) {
+        continue;
       }
-      await loadedPipeline.dispose();
-    });
-    const disposalBarrier = disposal.then(() => {
-      return;
-    }, () => {
-      return;
-    });
-    disposals.set(key, disposalBarrier);
-    disposalBarrier.then(() => {
-      if (disposals.get(key) === disposalBarrier) {
-        disposals.delete(key);
+      const url = `${env.remoteHost}${env.remotePathTemplate.replace("{model}", hostedModelId)}${file}`;
+      const cacheKey = cache === null ? `${hostedModelId}/${file}` : url;
+      const response = await env.fetch(url, { signal });
+      if (!response.ok || response.body === null) {
+        throw new Error(`Could not download ${url}: HTTP ${response.status}.`);
       }
+      const reader = response.body.getReader();
+      const onAbort = () => {
+        reader.cancel(signal?.reason).catch(() => {
+          return;
+        });
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        signal?.throwIfAborted();
+        if (cache !== null) {
+          const stream = new ReadableStream({
+            async pull(controller) {
+              try {
+                const { done, value } = await reader.read();
+                signal?.throwIfAborted();
+                if (done) {
+                  controller.close();
+                  return;
+                }
+                loadedBytes += value.byteLength;
+                emitProgress(file);
+                signal?.throwIfAborted();
+                controller.enqueue(value);
+              } catch (error) {
+                controller.error(error);
+              }
+            },
+            cancel: () => reader.cancel()
+          });
+          await cache.put(cacheKey, new Response(stream, { headers: response.headers }));
+        } else {
+          const [{ mkdir, open, rename, unlink }, { join, dirname }, { randomUUID }] = await Promise.all([
+            importNodeModule("node:fs/promises"),
+            importNodeModule("node:path"),
+            importNodeModule("node:crypto")
+          ]);
+          if (env.cacheDir === null) {
+            throw new Error("Transformers.js env.cacheDir must be set.");
+          }
+          const destination = join(env.cacheDir, cacheKey);
+          const temporary = `${destination}.tmp.${randomUUID()}`;
+          await mkdir(dirname(destination), { recursive: true });
+          const handle = await open(temporary, "wx");
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              signal?.throwIfAborted();
+              if (done) {
+                break;
+              }
+              await handle.writeFile(value);
+              loadedBytes += value.byteLength;
+              emitProgress(file);
+            }
+            await handle.close();
+            signal?.throwIfAborted();
+            await rename(temporary, destination);
+          } catch (error) {
+            await Promise.allSettled([handle.close(), reader.cancel(error)]);
+            await unlink(temporary).catch(() => {
+              return;
+            });
+            throw error;
+          }
+        }
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+        await reader.cancel().catch(() => {
+          return;
+        });
+        reader.releaseLock();
+      }
+    }
+    signal?.throwIfAborted();
+    if (!await ModelRegistry.is_pipeline_cached("background-removal", hostedModelId, registryOptions)) {
+      throw new Error(`The video matting model "${model}" was not fully cached.`);
+    }
+    signal?.throwIfAborted();
+    onProgress?.({
+      file: null,
+      progress: 1,
+      loadedBytes: totalBytes,
+      totalBytes
     });
-    pending.set(key, disposal);
-  }
-  await Promise.all(pending.values());
+    signal?.throwIfAborted();
+    return { alreadyDownloaded: false };
+  }).catch((error) => {
+    signal?.throwIfAborted();
+    throw error;
+  });
 };
 // src/is-video-matting-model-cached.ts
 var isVideoMattingModelCached = ({
@@ -472,8 +1023,7 @@ var removeVideoMattingModel = async ({
 import {
   ALL_FORMATS,
   BlobSource,
-  CanvasSink,
-  CanvasSource,
+  FilePathSource,
   Input,
   UrlSource,
   WebMOutputFormat,
@@ -487,7 +1037,7 @@ import {
   StreamTarget
 } from "mediabunny";
 // package.json
-var version = "4.0.527";
+var version = "4.0.528";
 
 // src/web-fs-target.ts
 var filePrefix = "__remotion_video_matting:";
@@ -595,6 +1145,13 @@ var createWebFsVideoLayerTarget = async () => {
 };
 
 // src/create-video-layer-output.ts
+var withAsyncDispose = (result) => {
+  Object.defineProperty(result, Symbol.asyncDispose, {
+    enumerable: false,
+    value: result.dispose
+  });
+  return result;
+};
 var createVideoLayerOutput = async ({
   format,
   options
@@ -754,17 +1311,17 @@ var createVideoLayerOutput = async ({
         }
         finalized = true;
         if (outputMode === "writable") {
-          return {
+          return withAsyncDispose({
             dispose: () => Promise.resolve(),
             getBlob: () => Promise.reject(new Error("getBlob() is unavailable when outputWritable is used"))
-          };
+          });
         }
         if (outputMode === "web-fs") {
           if (webFsTarget === null) {
             throw new Error("Expected an OPFS-backed output target");
           }
           let blobPromise = null;
-          return {
+          return withAsyncDispose({
             dispose: discard,
             getBlob: () => {
               blobPromise ??= (async () => {
@@ -774,12 +1331,12 @@ var createVideoLayerOutput = async ({
               })();
               return blobPromise;
             }
-          };
+          });
         }
         if (!(target instanceof BufferTarget)) {
           throw new Error("Expected an in-memory output target");
         }
-        return {
+        return withAsyncDispose({
           dispose: () => Promise.resolve(),
           getBlob: () => {
             if (target.buffer === null) {
@@ -787,7 +1344,7 @@ var createVideoLayerOutput = async ({
             }
             return Promise.resolve(new Blob([target.buffer], { type: mimeType }));
           }
-        };
+        });
       } catch (error) {
         await Promise.allSettled([cancelMediabunnyOutput(), discard()]);
         throw error;
@@ -798,6 +1355,156 @@ var createVideoLayerOutput = async ({
   return { output, finalize, cancel, discard };
 };
 
+// src/create-video-matting-frames.ts
+import { CanvasSink, CanvasSource } from "mediabunny";
+
+// src/video-matting-canvas.ts
+var createVideoMattingCanvas = ({
+  width,
+  height
+}) => {
+  if (typeof OffscreenCanvas !== "undefined") {
+    return new OffscreenCanvas(width, height);
+  }
+  if (typeof document !== "undefined") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  }
+  throw new Error("Could not create a canvas. This API must run in a browser with OffscreenCanvas or the DOM available.");
+};
+var getVideoMattingCanvasContext = (canvas) => {
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) {
+    throw new Error("Could not create a 2D canvas context.");
+  }
+  return context;
+};
+var drawOpaqueBaseFrame = ({
+  context,
+  source,
+  width,
+  height
+}) => {
+  context.save();
+  context.globalCompositeOperation = "copy";
+  context.fillStyle = "#000000";
+  context.fillRect(0, 0, width, height);
+  context.globalCompositeOperation = "source-over";
+  context.drawImage(source, 0, 0, width, height);
+  context.restore();
+};
+var drawForegroundFrame = ({
+  context,
+  result,
+  source,
+  targetWidth,
+  targetHeight
+}) => {
+  if (!Number.isInteger(result.width) || result.width <= 0 || !Number.isInteger(result.height) || result.height <= 0) {
+    throw new Error("The video matting model returned invalid dimensions.");
+  }
+  const expectedLength = result.width * result.height * result.channels;
+  if (result.data.length !== expectedLength) {
+    throw new Error(`The video matting model returned ${result.data.length} bytes, but ${expectedLength} RGBA bytes were expected.`);
+  }
+  const imageData = new ImageData(result.data, result.width, result.height);
+  context.clearRect(0, 0, targetWidth, targetHeight);
+  if (result.width === targetWidth && result.height === targetHeight) {
+    context.putImageData(imageData, 0, 0);
+  } else {
+    const intermediateCanvas = createVideoMattingCanvas({
+      width: result.width,
+      height: result.height
+    });
+    const intermediateContext = getVideoMattingCanvasContext(intermediateCanvas);
+    intermediateContext.putImageData(imageData, 0, 0);
+    context.drawImage(intermediateCanvas, 0, 0, targetWidth, targetHeight);
+  }
+  context.save();
+  context.globalCompositeOperation = "destination-in";
+  context.drawImage(source, 0, 0, targetWidth, targetHeight);
+  context.restore();
+};
+
+// src/create-video-matting-frames.ts
+var createVideoMattingFrames = async (options) => {
+  if (typeof window === "undefined" && typeof process !== "undefined" && process.release?.name === "node") {
+    const { createNodeVideoMattingFrames: createNodeVideoMattingFrames2 } = await Promise.resolve().then(() => (init_node_video_matting_frames(), exports_node_video_matting_frames));
+    return createNodeVideoMattingFrames2(options);
+  }
+  const {
+    videoTrack,
+    width,
+    height,
+    videoQuality,
+    keyframeIntervalInSeconds,
+    videoStartTimestamp,
+    videoEndTimestamp,
+    includeBase
+  } = options;
+  const sink = new CanvasSink(videoTrack, {
+    alpha: true,
+    width,
+    height,
+    fit: "fill",
+    poolSize: 1
+  });
+  const baseCanvas = includeBase ? createVideoMattingCanvas({ width, height }) : null;
+  const foregroundCanvas = createVideoMattingCanvas({ width, height });
+  const baseContext = baseCanvas ? getVideoMattingCanvasContext(baseCanvas) : null;
+  const foregroundContext = getVideoMattingCanvasContext(foregroundCanvas);
+  const baseSource = baseCanvas ? new CanvasSource(baseCanvas, {
+    codec: "vp9",
+    quality: videoQuality,
+    keyFrameInterval: keyframeIntervalInSeconds,
+    alpha: "discard"
+  }) : null;
+  const foregroundSource = new CanvasSource(foregroundCanvas, {
+    codec: "vp9",
+    quality: videoQuality,
+    keyFrameInterval: keyframeIntervalInSeconds,
+    alpha: "keep"
+  });
+  return {
+    frames: async function* () {
+      for await (const frame of sink.canvases(videoStartTimestamp, videoEndTimestamp)) {
+        yield {
+          image: frame.canvas,
+          timestamp: frame.timestamp,
+          duration: frame.duration
+        };
+      }
+    }(),
+    baseSource,
+    foregroundSource,
+    addFrame: async ({ frame, foreground, timestamp, duration }) => {
+      if ("data" in frame.image) {
+        throw new Error("Expected a canvas frame.");
+      }
+      if (baseContext) {
+        drawOpaqueBaseFrame({
+          context: baseContext,
+          source: frame.image,
+          width,
+          height
+        });
+      }
+      drawForegroundFrame({
+        context: foregroundContext,
+        result: foreground,
+        source: frame.image,
+        targetWidth: width,
+        targetHeight: height
+      });
+      await Promise.all([
+        baseSource?.add(timestamp, duration),
+        foregroundSource.add(timestamp, duration)
+      ]);
+    }
+  };
+};
 // src/prepare-audio.ts
 import {
   AudioSampleSink,
@@ -858,6 +1565,9 @@ var prepareAudio = async ({
       cancel: () => Promise.resolve()
     };
   }
+  if ((destination === "base" || destination === "both") && baseOutput === null) {
+    throw new Error("A base output is required for this audio destination.");
+  }
   const outputs = destination === "both" ? [baseOutput, foregroundOutput] : destination === "base" ? [baseOutput] : [foregroundOutput];
   const sourceCodec = await audioTrack.getCodec();
   const canCopyPackets = !forceTranscode && sourceCodec === "opus" && firstAudioTimestamp >= videoStartTimestamp;
@@ -1151,76 +1861,6 @@ var prepareAudio = async ({
   };
 };
 
-// src/video-matting-canvas.ts
-var createVideoMattingCanvas = ({
-  width,
-  height
-}) => {
-  if (typeof OffscreenCanvas !== "undefined") {
-    return new OffscreenCanvas(width, height);
-  }
-  if (typeof document !== "undefined") {
-    const canvas = document.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-    return canvas;
-  }
-  throw new Error("Could not create a canvas. This API must run in a browser with OffscreenCanvas or the DOM available.");
-};
-var getVideoMattingCanvasContext = (canvas) => {
-  const context = canvas.getContext("2d", { willReadFrequently: true });
-  if (!context) {
-    throw new Error("Could not create a 2D canvas context.");
-  }
-  return context;
-};
-var drawOpaqueBaseFrame = ({
-  context,
-  source,
-  width,
-  height
-}) => {
-  context.save();
-  context.globalCompositeOperation = "copy";
-  context.fillStyle = "#000000";
-  context.fillRect(0, 0, width, height);
-  context.globalCompositeOperation = "source-over";
-  context.drawImage(source, 0, 0, width, height);
-  context.restore();
-};
-var drawForegroundFrame = ({
-  context,
-  result,
-  source,
-  targetWidth,
-  targetHeight
-}) => {
-  if (!Number.isInteger(result.width) || result.width <= 0 || !Number.isInteger(result.height) || result.height <= 0) {
-    throw new Error("The video matting model returned invalid dimensions.");
-  }
-  const expectedLength = result.width * result.height * result.channels;
-  if (result.data.length !== expectedLength) {
-    throw new Error(`The video matting model returned ${result.data.length} bytes, but ${expectedLength} RGBA bytes were expected.`);
-  }
-  const imageData = new ImageData(result.data, result.width, result.height);
-  context.clearRect(0, 0, targetWidth, targetHeight);
-  if (result.width === targetWidth && result.height === targetHeight) {
-    context.putImageData(imageData, 0, 0);
-  } else {
-    const intermediateCanvas = createVideoMattingCanvas({
-      width: result.width,
-      height: result.height
-    });
-    const intermediateContext = getVideoMattingCanvasContext(intermediateCanvas);
-    intermediateContext.putImageData(imageData, 0, 0);
-    context.drawImage(intermediateCanvas, 0, 0, targetWidth, targetHeight);
-  }
-  context.save();
-  context.globalCompositeOperation = "destination-in";
-  context.drawImage(source, 0, 0, targetWidth, targetHeight);
-  context.restore();
-};
-
 // src/video-matting-quality.ts
 import { Quality as Quality2 } from "mediabunny";
 var VIDEO_MATTING_QUALITIES = [
@@ -1316,7 +1956,7 @@ var createAbortError = (signal) => {
   if (signal.reason !== undefined) {
     return signal.reason;
   }
-  const error = new Error("Video layer separation was aborted.");
+  const error = new Error("Video matting was aborted.");
   error.name = "AbortError";
   return error;
 };
@@ -1350,9 +1990,9 @@ var validateLayerOutputOptions = ({
     }
   }
 };
-var validateOptions = (options) => {
+var validateOptions = (options, operationName) => {
   if (!options || typeof options !== "object") {
-    throw new TypeError("separateVideoLayers() expects an options object.");
+    throw new TypeError(`${operationName}() expects an options object.`);
   }
   const isBlob = typeof Blob !== "undefined" && options.src instanceof Blob;
   const isUrl = options.src instanceof URL;
@@ -1392,13 +2032,30 @@ var validateOptions = (options) => {
     throw new TypeError("onModelLoadProgress must be a function.");
   }
 };
-var makeInput = (src) => {
+var makeInput = async (src) => {
+  if (typeof window === "undefined" && typeof process !== "undefined" && process.release?.name === "node" && (typeof src === "string" || src instanceof URL)) {
+    const path = String(src);
+    if (path.startsWith("file:")) {
+      const { fileURLToPath } = await importNodeModule("node:url");
+      return new Input({
+        formats: ALL_FORMATS,
+        source: new FilePathSource(fileURLToPath(path))
+      });
+    }
+    if (/^[a-z]:[/\\]/i.test(path) || !/^[a-z][a-z\d+.-]*:/i.test(path)) {
+      return new Input({
+        formats: ALL_FORMATS,
+        source: new FilePathSource(path)
+      });
+    }
+  }
   const source = typeof src === "string" || src instanceof URL ? new UrlSource(src) : new BlobSource(src);
   return new Input({ formats: ALL_FORMATS, source });
 };
 var probeVideoInput = async ({
   input,
-  videoQuality
+  videoQuality,
+  includeBase
 }) => {
   if (!await input.canRead()) {
     throw new Error("The input is not a supported media file.");
@@ -1418,12 +2075,12 @@ var probeVideoInput = async ({
     throw new Error("The input video has invalid dimensions.");
   }
   const [canEncodeBase, canEncodeForeground] = await Promise.all([
-    canEncodeVideo("vp9", {
+    includeBase ? canEncodeVideo("vp9", {
       width,
       height,
       quality: videoQuality,
       alpha: "discard"
-    }),
+    }) : Promise.resolve(true),
     canEncodeVideo("vp9", {
       width,
       height,
@@ -1432,25 +2089,27 @@ var probeVideoInput = async ({
     })
   ]);
   if (!canEncodeBase || !canEncodeForeground) {
-    throw new Error("This browser cannot encode the VP9 video streams required for video layer separation.");
+    throw new Error("This environment cannot encode the VP9 video streams required for video matting.");
   }
   return { videoTrack, width, height };
 };
-var separateVideoLayers = async (options) => {
-  validateOptions(options);
+var runVideoMatting = async (options, includeBase) => {
+  validateOptions(options, includeBase ? "separateVideoLayers" : "removeVideoBackground");
   throwIfAborted(options.signal);
   const model = options.model ?? "modnet";
-  const audio = options.audio ?? "base";
+  const audio = options.audio ?? (includeBase ? "base" : "foreground");
   const videoQuality = resolveVideoMattingQuality(options.videoBitrate ?? "very-high");
   const audioQuality = resolveVideoMattingQuality(options.audioBitrate ?? "medium");
   const keyframeIntervalInSeconds = options.keyframeIntervalInSeconds ?? 1;
-  const input = makeInput(options.src);
+  const input = await makeInput(options.src);
   const onInputAbort = () => input.dispose();
   options.signal?.addEventListener("abort", onInputAbort, { once: true });
   try {
+    throwIfAborted(options.signal);
     const { videoTrack, width, height } = await probeVideoInput({
       input,
-      videoQuality
+      videoQuality,
+      includeBase
     });
     const [inputFirstVideoTimestamp, videoEndTimestamp] = await Promise.all([
       videoTrack.getFirstTimestamp(),
@@ -1468,11 +2127,9 @@ var separateVideoLayers = async (options) => {
       signal: options.signal ?? null,
       run: async (pipeline) => {
         throwIfAborted(options.signal);
-        let iterator = null;
+        let videoFrames = null;
         let baseOutput = null;
         let foregroundOutput = null;
-        let baseVideoSource = null;
-        let foregroundVideoSource = null;
         let audioWriter = null;
         let completed = false;
         let abortCleanupPromise = null;
@@ -1492,50 +2149,41 @@ var separateVideoLayers = async (options) => {
         };
         options.signal?.addEventListener("abort", onAbort, { once: true });
         try {
-          const canvasSink = new CanvasSink(videoTrack, {
-            alpha: true,
+          videoFrames = await createVideoMattingFrames({
+            videoTrack,
             width,
             height,
-            fit: "fill",
-            poolSize: 1
+            videoQuality,
+            keyframeIntervalInSeconds,
+            videoStartTimestamp,
+            videoEndTimestamp,
+            includeBase
           });
-          iterator = canvasSink.canvases(videoStartTimestamp, videoEndTimestamp);
+          const iterator = videoFrames.frames;
           let nextFrame = await iterator.next();
           if (nextFrame.done) {
             throw new Error("The primary video track contains no presentable decodable frames.");
           }
           throwIfAborted(options.signal);
-          const baseCanvas = createVideoMattingCanvas({ width, height });
-          const foregroundCanvas = createVideoMattingCanvas({ width, height });
-          const baseContext = getVideoMattingCanvasContext(baseCanvas);
-          const foregroundContext = getVideoMattingCanvasContext(foregroundCanvas);
-          baseOutput = await createVideoLayerOutput({
-            format: new WebMOutputFormat,
-            options: options.outputs?.base
-          });
+          if (includeBase) {
+            baseOutput = await createVideoLayerOutput({
+              format: new WebMOutputFormat,
+              options: options.outputs?.base
+            });
+          }
           throwIfAborted(options.signal);
           foregroundOutput = await createVideoLayerOutput({
             format: new WebMOutputFormat,
             options: options.outputs?.foreground
           });
           throwIfAborted(options.signal);
-          baseVideoSource = new CanvasSource(baseCanvas, {
-            codec: "vp9",
-            quality: videoQuality,
-            keyFrameInterval: keyframeIntervalInSeconds,
-            alpha: "discard"
-          });
-          foregroundVideoSource = new CanvasSource(foregroundCanvas, {
-            codec: "vp9",
-            quality: videoQuality,
-            keyFrameInterval: keyframeIntervalInSeconds,
-            alpha: "keep"
-          });
-          baseOutput.output.addVideoTrack(baseVideoSource);
-          foregroundOutput.output.addVideoTrack(foregroundVideoSource);
+          if (baseOutput && videoFrames.baseSource) {
+            baseOutput.output.addVideoTrack(videoFrames.baseSource);
+          }
+          foregroundOutput.output.addVideoTrack(videoFrames.foregroundSource);
           audioWriter = await prepareAudio({
             input,
-            baseOutput: baseOutput.output,
+            baseOutput: baseOutput?.output ?? null,
             foregroundOutput: foregroundOutput.output,
             destination: audio,
             videoStartTimestamp,
@@ -1545,7 +2193,7 @@ var separateVideoLayers = async (options) => {
           });
           throwIfAborted(options.signal);
           await Promise.all([
-            baseOutput.output.start(),
+            baseOutput?.output.start(),
             foregroundOutput.output.start()
           ]);
           throwIfAborted(options.signal);
@@ -1573,24 +2221,14 @@ var separateVideoLayers = async (options) => {
               nextFrame = await iterator.next();
               continue;
             }
-            const foregroundFrame = await pipeline(frame.canvas);
+            const foregroundFrame = await pipeline(frame.image);
             throwIfAborted(options.signal);
-            drawOpaqueBaseFrame({
-              context: baseContext,
-              source: frame.canvas,
-              width,
-              height
-            });
-            drawForegroundFrame({
-              context: foregroundContext,
-              result: foregroundFrame,
-              source: frame.canvas,
-              targetWidth: width,
-              targetHeight: height
-            });
             await Promise.all([
-              baseVideoSource.add(timing.timestamp, timing.duration),
-              foregroundVideoSource.add(timing.timestamp, timing.duration),
+              videoFrames.addFrame({
+                frame,
+                foreground: foregroundFrame,
+                ...timing
+              }),
               audioWriter.writeAudioUntil(timing.timestamp + timing.duration)
             ]);
             processedFrames++;
@@ -1618,23 +2256,29 @@ var separateVideoLayers = async (options) => {
             durationInSeconds
           });
           await audioWriter.finishAudio();
-          baseVideoSource.close();
-          foregroundVideoSource.close();
+          videoFrames.baseSource?.close();
+          videoFrames.foregroundSource.close();
           const [base, foreground] = await Promise.all([
-            baseOutput.finalize(),
+            baseOutput?.finalize() ?? Promise.resolve(null),
             foregroundOutput.finalize()
           ]);
           throwIfAborted(options.signal);
           completed = true;
-          return {
-            base,
-            foreground,
+          const separated = {
+            ...base ? { base, foreground } : { video: foreground },
             model,
             width,
             height,
             durationInSeconds,
             processedFrames
           };
+          Object.defineProperty(separated, Symbol.asyncDispose, {
+            enumerable: false,
+            value: async () => {
+              await Promise.all([base?.dispose(), foreground.dispose()]);
+            }
+          });
+          return separated;
         } catch (error) {
           await cancelPendingMedia();
           if (options.signal?.aborted) {
@@ -1646,7 +2290,7 @@ var separateVideoLayers = async (options) => {
           await abortCleanupPromise;
           if (!completed) {
             try {
-              await iterator?.return();
+              await videoFrames?.frames.return();
             } catch {}
           }
         }
@@ -1663,13 +2307,24 @@ var separateVideoLayers = async (options) => {
     input.dispose();
   }
 };
+var separateVideoLayers = async (options) => await runVideoMatting(options, true);
+var removeVideoBackground = async (options) => await runVideoMatting({
+  ...options,
+  audio: options.audio === "none" ? "none" : "foreground",
+  outputs: { foreground: options.output }
+}, false);
+
+// src/index.ts
+var VideoMattingInternals = { removeVideoBackground };
 export {
   separateVideoLayers,
   removeVideoMattingModel,
   loadVideoMattingModel,
   isVideoMattingModelCached,
   getAvailableModels,
+  downloadVideoMattingModel,
   disposeVideoMattingModel,
   canUseVideoMatting,
-  VideoMattingUnsupportedReason
+  VideoMattingUnsupportedReason,
+  VideoMattingInternals
 };