hyperframes 0.8.155 → 0.8.157

package/dist/{chunk-TLC4GYT5.js → chunk-IRRRH66M.js}

@@ -10,7 +10,8 @@ import {
   isLowMemorySystem
 } from "./chunk-JYVGYKXG.js";
 import {
-  describeWslGpuAccess
+  describeWslGpuAccess,
+  detectWsl
 } from "./chunk-7KDQAD2W.js";
 import {
   MEDIA_VISUAL_STYLE_PROPERTIES,
@@ -29,7 +30,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-ZDEEHQ2Y.js";
+} from "./chunk-SGIZMTWO.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -58,7 +59,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-GV7I3ZSQ.js";
+} from "./chunk-LPOTN5GW.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
@@ -665,6 +666,7 @@ function fingerprintKey(fingerprint) {
   return JSON.stringify([
     fingerprint.args,
     fingerprint.executablePath ?? null,
+    fingerprint.withoutWaylandDisplay === true,
     fingerprint.browserTimeoutMs,
     fingerprint.protocolTimeoutMs,
     fingerprint.requestedCaptureMode
@@ -902,6 +904,7 @@ async function probeHardwareWebGlInfo(ppt, options) {
       args: options.args,
       defaultViewport: { width: 64, height: 64 },
       executablePath: options.executablePath,
+      env: options.env,
       timeout: options.browserTimeout,
       waitForInitialPage: false
     };
@@ -1025,6 +1028,43 @@ function resolveHeadlessShellPath(config) {
     join2(home, ".cache", "hyperframes", "chrome", "chrome-headless-shell")
   ) ?? findCachedHeadlessShell(join2(home, ".cache", "puppeteer", "chrome-headless-shell"));
 }
+function resolveFullChromePath() {
+  const baseDir = join2(homedir(), ".cache", "puppeteer", "chrome");
+  let versions;
+  try {
+    versions = readdirSync(baseDir).sort(compareBrowserVersionsDescending);
+  } catch {
+    return void 0;
+  }
+  for (const version of versions) {
+    const candidates = [
+      join2(
+        baseDir,
+        version,
+        "chrome-mac-arm64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      ),
+      join2(
+        baseDir,
+        version,
+        "chrome-mac-x64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      ),
+      join2(baseDir, version, "chrome-linux64", "chrome"),
+      join2(baseDir, version, "chrome-win64", "chrome.exe")
+    ];
+    for (const binary of candidates) {
+      if (existsSync(binary)) return binary;
+    }
+  }
+  return void 0;
+}
 var ENABLE_BROWSER_POOL = DEFAULT_CONFIG.enableBrowserPool;
 var BEGINFRAME_ONLY_FLAGS = /* @__PURE__ */ new Set([
   "--deterministic-mode",
@@ -1203,30 +1243,45 @@ function formatProbeFailure(err) {
   return `probe failed (${err instanceof Error ? err.message : String(err)})`;
 }
 async function probeAutoBrowserGpuMode(options) {
-  const platform = options.platform ?? process.platform;
-  const browserTimeout = options.browserTimeout ?? DEFAULT_CONFIG.browserTimeout;
-  const executablePath = options.chromePath ?? resolveHeadlessShellPath({});
   const ppt = await getPuppeteerOrNull();
   if (ppt === null) {
     logResolvedBrowserGpuMode("software", "puppeteer unavailable");
     return { mode: "software", cause: "probe-error" };
   }
+  const probed = await probeWebGlMode(ppt, options);
+  if (probed.mode === "hardware") return probed;
+  if (detectWsl(options.wslHost) && process.env.WAYLAND_DISPLAY !== void 0) {
+    const env = envWithoutWaylandDisplay();
+    const retried = await probeWebGlMode(ppt, options, env, "without WAYLAND_DISPLAY: ");
+    if (retried.mode === "hardware") return { mode: "hardware", withoutWaylandDisplay: true };
+  }
+  return { ...probed, ...wslAccess(options) };
+}
+async function probeWebGlMode(ppt, options, env, label = "") {
   try {
     const info = await probeHardwareWebGlInfo(ppt, {
-      args: getHardwareGpuProbeArgs(platform),
-      browserTimeout,
-      executablePath,
-      probeLifecycle: options.probeLifecycle
+      args: getHardwareGpuProbeArgs(options.platform ?? process.platform),
+      browserTimeout: options.browserTimeout ?? DEFAULT_CONFIG.browserTimeout,
+      executablePath: options.chromePath ?? resolveHeadlessShellPath({}),
+      probeLifecycle: options.probeLifecycle,
+      env
     });
     const resolved = resolveWebGlProbeMode(info);
-    logResolvedBrowserGpuMode(resolved, describeWebGlProbe(info));
-    if (resolved === "hardware") return { mode: "hardware" };
-    return { mode: "software", cause: "no-gpu", ...wslAccess(options) };
+    logResolvedBrowserGpuMode(resolved, label + describeWebGlProbe(info));
+    return resolved === "hardware" ? { mode: "hardware" } : { mode: "software", cause: "no-gpu" };
   } catch (err) {
-    logResolvedBrowserGpuMode("software", formatProbeFailure(err));
-    return { mode: "software", cause: "probe-error", ...wslAccess(options) };
+    logResolvedBrowserGpuMode("software", label + formatProbeFailure(err));
+    return { mode: "software", cause: "probe-error" };
   }
 }
+function envWithoutWaylandDisplay() {
+  const { WAYLAND_DISPLAY: _wslg, ...env } = process.env;
+  return env;
+}
+async function captureWithoutWaylandDisplay(resolvedMode) {
+  if (resolvedMode !== "hardware") return false;
+  return (await _autoBrowserGpuModeCache)?.withoutWaylandDisplay === true;
+}
 function wslAccess(options) {
   const lines = describeWslGpuAccess(options.wslHost);
   return lines ? { wslAccess: lines } : {};
@@ -1286,6 +1341,7 @@ function createBrowserLaunchFingerprint(chromeArgs, config) {
   return {
     args: chromeArgs,
     executablePath: headlessShell,
+    withoutWaylandDisplay: launchConfig.withoutWaylandDisplay === true,
     browserTimeoutMs: launchConfig.browserTimeout,
     protocolTimeoutMs: launchConfig.protocolTimeout,
     requestedCaptureMode
@@ -1297,6 +1353,7 @@ async function acquireBrowser(chromeArgs, config) {
 }
 async function launchBrowser(fingerprint) {
   const ppt = await getPuppeteer();
+  const env = fingerprint.withoutWaylandDisplay ? envWithoutWaylandDisplay() : void 0;
   let captureMode = fingerprint.requestedCaptureMode;
   let browser;
   try {
@@ -1306,6 +1363,7 @@ async function launchBrowser(fingerprint) {
       args: [...fingerprint.args],
       defaultViewport: null,
       executablePath: fingerprint.executablePath,
+      env,
       timeout: fingerprint.browserTimeoutMs,
       protocolTimeout: fingerprint.protocolTimeoutMs
     });
@@ -1335,6 +1393,7 @@ async function launchBrowser(fingerprint) {
           args: stripBeginFrameFlags([...fingerprint.args]),
           defaultViewport: null,
           executablePath: fingerprint.executablePath,
+          env,
           timeout: fingerprint.browserTimeoutMs,
           protocolTimeout: fingerprint.protocolTimeoutMs
         });
@@ -5272,7 +5331,8 @@ async function createCaptureSession(serverUrl, outputDir, options, onBeforeCaptu
     { width: options.width, height: options.height, captureMode: preMode, requiresWebGpu },
     gpuConfig
   );
-  const browserLease = await acquireBrowser(chromeArgs, config);
+  const withoutWaylandDisplay = await captureWithoutWaylandDisplay(resolvedGpuMode);
+  const browserLease = await acquireBrowser(chromeArgs, { ...config, withoutWaylandDisplay });
   return constructCaptureSessionWithRollback({
     browserLease,
     serverUrl,
@@ -8031,35 +8091,6 @@ async function runFfmpeg(args, opts) {
   });
   return toResult(await managed.wait());
 }
-async function runFfmpegPipeline(producerArgs, consumerArgs, opts) {
-  if (opts?.signal?.aborted) return { ...ABORTED_BEFORE_START };
-  const deadlineAtMs = Date.now() + (opts?.timeout ?? DEFAULT_TIMEOUT);
-  const producer = spawnFfmpeg(producerArgs);
-  const consumer = spawnFfmpeg(consumerArgs);
-  consumer.stdin?.on("error", () => {
-  });
-  for (const event of ["close", "error"]) {
-    consumer.once(event, () => producer.stdout?.destroy());
-    producer.once(event, () => consumer.stdin?.end());
-  }
-  if (consumer.stdin) producer.stdout?.pipe(consumer.stdin);
-  const settleOrder = [];
-  const outcomes = await Promise.all(
-    [producer, consumer].map(
-      (child) => new ManagedChildProcess(child, {
-        signal: opts?.signal,
-        deadlineAtMs,
-        onStderr: opts?.onStderr
-      }).wait().then((outcome) => {
-        settleOrder.push(outcome);
-        return outcome;
-      })
-    )
-  );
-  const reported = settleOrder.find((outcome) => !succeeded(outcome)) ?? outcomes[1];
-  const stderr = [...outcomes.filter((outcome) => outcome !== reported), reported].map((outcome) => outcome.stderr).join("");
-  return toResult(reported, stderr);
-}
 
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn3 } from "child_process";
@@ -11194,7 +11225,7 @@ function framePathsFromDirectory(outputDir, format, allowGaps = false) {
 // ../engine/src/services/extractionCache.ts
 var COMPLETE_SENTINEL = ".hf-complete";
 var GC_MARKER = ".hf-last-gc";
-var SCHEMA_PREFIX = "hfcache-v6-";
+var SCHEMA_PREFIX = "hfcache-v7-";
 var KEY_HEX_CHARS = 16;
 async function readContentSha256(path, signal) {
   try {
@@ -11809,55 +11840,6 @@ function chromeGuessForUntaggedMatrix(metadata) {
   const hd = metadata.height >= 720 && !CHROME_BT601_UNTAGGED_CODECS.has(metadata.videoCodec);
   return [`setparams=colorspace=${hd ? "bt709" : "smpte170m"}`];
 }
-var NUT_RAW_PIXEL_FORMATS = /* @__PURE__ */ new Set([
-  "yuv420p",
-  "yuvj420p",
-  "yuv422p",
-  "yuvj422p",
-  "yuv444p",
-  "yuvj444p",
-  "yuva420p",
-  "yuva444p",
-  "yuv440p",
-  "yuv411p",
-  "yuv410p",
-  "yuva422p",
-  "yuv420p10le",
-  "yuv422p10le",
-  "yuv444p10le",
-  "yuva420p10le",
-  "yuva444p10le",
-  "yuv420p12le",
-  "nv12",
-  "nv21",
-  "yuyv422",
-  "uyvy422",
-  "gray",
-  "gray10le",
-  "ya8",
-  "gbrp",
-  "gbrap",
-  "gbrp10le",
-  "gbrp12le",
-  "gbrap10le",
-  "rgb24",
-  "bgr24",
-  "rgba",
-  "bgra",
-  "argb",
-  "abgr",
-  "rgb48le",
-  "rgba64le"
-]);
-function restoreSourceColourFilter(metadata) {
-  const tags = [
-    ["range", metadata.colorRange],
-    ["colorspace", metadata.colorSpace?.colorSpace],
-    ["color_primaries", metadata.colorSpace?.colorPrimaries],
-    ["color_trc", metadata.colorSpace?.colorTransfer]
-  ].filter(([, value]) => value && value !== "unknown" && value !== "reserved");
-  return tags.length > 0 ? [`setparams=${tags.map(([key, value]) => `${key}=${value}`).join(":")}`] : [];
-}
 var EXTRACTION_SEGMENT_SECONDS = 120;
 var EXTRACTION_SLOTS = Math.max(1, Math.floor(cpus().length / 2));
 var inExtractionSlot = createConcurrencyLimit(EXTRACTION_SLOTS);
@@ -11964,8 +11946,8 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const isMacOS = process.platform === "darwin";
   const toneMappedToSdr = options.toneMapHdrToSdr === true && isHdr && await toneMapsWithZscale();
   const decodeWithVideoToolbox = isHdr && isMacOS && !toneMappedToSdr;
-  const sampleCfrAtOutputFps = !options.finalFrameOnly && !metadata.isVFR;
-  if (options.frameRanges && !sampleCfrAtOutputFps) {
+  const sampleAtOutputFps = !options.finalFrameOnly;
+  if (options.frameRanges && (!sampleAtOutputFps || metadata.isVFR)) {
     throw new Error("frameRanges extraction needs a constant-frame-rate source");
   }
   const args = [];
@@ -11979,14 +11961,14 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (options.finalFrameOnly) {
     args.push("-i", videoPath, "-ss", String(startTime), "-frames:v", "1");
   } else {
-    if (sampleCfrAtOutputFps) args.push("-noaccurate_seek");
+    if (sampleAtOutputFps) args.push("-noaccurate_seek");
     args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
   }
   const vfFilters = [];
   if (decodeWithVideoToolbox) {
     vfFilters.push("format=nv12");
   }
-  if (sampleCfrAtOutputFps) {
+  if (sampleAtOutputFps) {
     vfFilters.push(
       "settb=intb/2",
       "setpts=PTS-lte(TB\\,0.001)",
@@ -12011,48 +11993,25 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (format === "png") encodeArgs.push("-compression_level", "1");
   encodeArgs.push("-y", outputPattern);
   const runOptions = { signal, timeout: ffmpegProcessTimeout };
-  const resampleVfrToCfr = !options.finalFrameOnly && metadata.isVFR;
-  if (resampleVfrToCfr) args.push("-fps_mode", "cfr", "-r", ffmpegFps);
-  let processResult;
-  if (resampleVfrToCfr && vfFilters.length > 0 && !isHdr && NUT_RAW_PIXEL_FORMATS.has(metadata.pixelFormat ?? "")) {
-    processResult = await inExtractionSlot(
-      () => runFfmpegPipeline(
-        [...args, "-an", "-sn", "-dn", "-c:v", "rawvideo", "-f", "nut", "pipe:1"],
-        [
-          "-f",
-          "nut",
-          "-i",
-          "pipe:0",
-          "-vf",
-          [...restoreSourceColourFilter(metadata), ...vfFilters].join(","),
-          "-fps_mode",
-          "passthrough",
-          ...encodeArgs
-        ],
-        runOptions
-      ),
-      signal
-    );
-  } else {
-    const filterArgs = vfFilters.length > 0 ? ["-vf", vfFilters.join(",")] : [];
-    const segmentFrames = Math.round(EXTRACTION_SEGMENT_SECONDS * fps);
-    const totalFrames = extractionFrameCountForDuration(duration, normalizedFps, false);
-    processResult = sampleCfrAtOutputFps && (options.frameRanges || totalFrames > segmentFrames) ? await runSegmentedExtraction({
-      decodeArgs,
-      filterAndEncodeArgs: [...filterArgs, ...encodeArgs],
-      videoPath,
-      startTime,
-      fps,
-      segments: splitFrameRanges(
-        options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
-        segmentFrames
-      ),
-      runOptions
-    }) : await inExtractionSlot(
-      () => runFfmpeg([...args, ...filterArgs, ...encodeArgs], runOptions),
-      signal
-    );
-  }
+  const filterArgs = vfFilters.length > 0 ? ["-vf", vfFilters.join(",")] : [];
+  const segmentFrames = Math.round(EXTRACTION_SEGMENT_SECONDS * fps);
+  const totalFrames = extractionFrameCountForDuration(duration, normalizedFps, metadata.isVFR);
+  const boundVfrFrameCount = metadata.isVFR && totalFrames > 0;
+  const processResult = sampleAtOutputFps && (options.frameRanges || boundVfrFrameCount || totalFrames > segmentFrames) ? await runSegmentedExtraction({
+    decodeArgs,
+    filterAndEncodeArgs: [...filterArgs, ...encodeArgs],
+    videoPath,
+    startTime,
+    fps,
+    segments: splitFrameRanges(
+      options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
+      segmentFrames
+    ),
+    runOptions
+  }) : await inExtractionSlot(
+    () => runFfmpeg([...args, ...filterArgs, ...encodeArgs], runOptions),
+    signal
+  );
   if (processResult.failureReason === "external_interruption") {
     throw new VideoSourceExtractionError(
       "external_interruption",
@@ -14799,10 +14758,11 @@ function buildFadeFilters(track) {
   }
   return stages.length ? `,${stages.join(",")}` : "";
 }
-function buildTrackInputFilter(track, index, volumeFilter, totalDuration) {
+function buildTrackInputFilter(track, index, volumeFilter, totalDuration, padToDuration = true) {
   const delayMs = Math.round(track.start * 1e3);
   const trimDuration = track.end - track.start + (track.tailSeconds ?? 0);
-  return `[${index}:a]atrim=0:${formatFilterNumber(trimDuration)},${volumeFilter}${buildFadeFilters(track)},adelay=${delayMs}|${delayMs},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[a${index}]`;
+  const filters = `[${index}:a]atrim=0:${formatFilterNumber(trimDuration)},${volumeFilter}${buildFadeFilters(track)},adelay=${delayMs}|${delayMs}`;
+  return `${filters}${padToDuration ? `,apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}` : ""}[a${index}]`;
 }
 function missingSourceMessage(elementId, src, baseDir, resolvedPath) {
   const relativePath = relative(baseDir, resolvedPath).replace(/\\/g, "/");
@@ -15079,26 +15039,26 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
   }
   const outputDir = dirname6(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
-  const buildFilterComplex = (ignoreAutomation) => {
+  const buildFilterComplex = (ignoreAutomation, useNormalize2) => {
     const filterParts = [];
     tracks.forEach((track, i) => {
       const volumeFilter = buildVolumeExpression(track, ignoreAutomation);
-      filterParts.push(buildTrackInputFilter(track, i, volumeFilter, totalDuration));
+      filterParts.push(buildTrackInputFilter(track, i, volumeFilter, totalDuration, !useNormalize2));
     });
     const mixInputs = tracks.map((_, i) => `[a${i}]`).join("");
-    const mixFilter = `${mixInputs}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0[mixed]`;
-    const compensatedGain = masterOutputGain * tracks.length;
-    const postMixGainFilter = `[mixed]volume=${formatFilterNumber(compensatedGain)}[out]`;
+    const mixFilter = `${mixInputs}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0${useNormalize2 ? ":normalize=0" : ""}[mixed]`;
+    const gain = masterOutputGain * (useNormalize2 ? 1 : tracks.length);
+    const postMixGainFilter = useNormalize2 ? `[mixed]volume=${formatFilterNumber(gain)},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[out]` : `[mixed]volume=${formatFilterNumber(gain)}[out]`;
     return [...filterParts, mixFilter, postMixGainFilter].join(";");
   };
-  const runMix = async (ignoreAutomation) => {
+  const runMix = async (ignoreAutomation, useNormalize2) => {
     const inputs = [];
     tracks.forEach((track) => inputs.push("-i", track.srcPath));
     const scriptDir = mkdtempSync6(join13(outputDir, ".filter-complex-"));
     const scriptPath = join13(scriptDir, "graph.txt");
     const fd = openSync4(scriptPath, "wx", 384);
     try {
-      writeFileSync6(fd, buildFilterComplex(ignoreAutomation));
+      writeFileSync6(fd, buildFilterComplex(ignoreAutomation, useNormalize2));
     } finally {
       closeSync4(fd);
     }
@@ -15126,11 +15086,16 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
       rmSync7(scriptDir, { recursive: true, force: true });
     }
   };
-  let result = await runMix(false);
+  let useNormalize = true;
+  let result = await runMix(false, useNormalize);
+  if (!result.success && result.failureReason !== "external_interruption" && !signal?.aborted && groupNormalizeOptionUnsupported(result.stderr)) {
+    useNormalize = false;
+    result = await runMix(false, useNormalize);
+  }
   let degradedAutomation = false;
   const hasAutomation = tracks.some((track) => (track.volumeKeyframes?.length ?? 0) > 0);
   if (!result.success && result.failureReason !== "external_interruption" && !signal?.aborted && hasAutomation) {
-    const retry = await runMix(true);
+    const retry = await runMix(true, useNormalize);
     if (retry.success) {
       result = retry;
       degradedAutomation = true;
@@ -16645,9 +16610,6 @@ function verifyGpuParity(a, b, options = {}) {
 }
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
-import { join as join17 } from "path";
-import { homedir as homedir2 } from "os";
 var PQ_M1 = 0.1593017578125;
 var PQ_M2 = 78.84375;
 var PQ_C1 = 0.8359375;
@@ -16768,39 +16730,6 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   }
   return output;
 }
-function resolveHeadedChromePath() {
-  const baseDir = join17(homedir2(), ".cache", "puppeteer", "chrome");
-  if (!existsSync12(baseDir)) return void 0;
-  const versions = readdirSync7(baseDir).sort().reverse();
-  for (const version of versions) {
-    const candidates = [
-      join17(
-        baseDir,
-        version,
-        "chrome-mac-arm64",
-        "Google Chrome for Testing.app",
-        "Contents",
-        "MacOS",
-        "Google Chrome for Testing"
-      ),
-      join17(
-        baseDir,
-        version,
-        "chrome-mac-x64",
-        "Google Chrome for Testing.app",
-        "Contents",
-        "MacOS",
-        "Google Chrome for Testing"
-      ),
-      join17(baseDir, version, "chrome-linux64", "chrome"),
-      join17(baseDir, version, "chrome-win64", "chrome.exe")
-    ];
-    for (const binary of candidates) {
-      if (existsSync12(binary)) return binary;
-    }
-  }
-  return void 0;
-}
 async function launchHdrBrowser(width, height) {
   let ppt;
   try {
@@ -16815,7 +16744,7 @@ async function launchHdrBrowser(width, height) {
     ppt = mod.default;
   }
   if (!ppt) throw new Error("Neither puppeteer nor puppeteer-core found");
-  const chromePath = resolveHeadedChromePath();
+  const chromePath = resolveFullChromePath();
   if (!chromePath) {
     throw new Error(
       "[HDR] No Chrome binary found. Install: npx @puppeteer/browsers install chrome@stable"

package/dist/{chunk-BSMBAP7O.js → chunk-J6SJCYAQ.js}

@@ -6,21 +6,21 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   parakeetRunner
-} from "./chunk-6ENZIL42.js";
+} from "./chunk-7ZWOLEGS.js";
 import {
   DecodeCancelled,
   prepareSherpaWav,
   sherpaUnsupportedReason,
   transcribeWithSherpa
-} from "./chunk-PCBCTD7M.js";
+} from "./chunk-4YDQQQY6.js";
 import {
   initialModelForLanguage,
   transcribe
-} from "./chunk-RB6RHOSF.js";
+} from "./chunk-ZZ3ZWTOI.js";
 import {
   createRenderCancellationScope,
   stoppedByCancelSignal
-} from "./chunk-6UMBAJRU.js";
+} from "./chunk-T243WV6D.js";
 import {
   formatSrt,
   formatVtt,

package/dist/{chunk-TXWPPBIW.js → chunk-J7WFHOCW.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-PBN6GBJE.js";
 import {
   parseFps
-} from "./chunk-ZDEEHQ2Y.js";
+} from "./chunk-SGIZMTWO.js";
 
 // src/browser/windowsCrash.ts
 var STATUS_STACK_BUFFER_OVERRUN_DEC = "3221225595";