hyperframes 0.8.147 → 0.8.149

package/dist/chunk-LCILS4AF.js

@@ -0,0 +1,329 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  parakeetRunner
+} from "./chunk-VX4AL2FQ.js";
+import {
+  DecodeCancelled,
+  prepareSherpaWav,
+  sherpaUnsupportedReason,
+  transcribeWithSherpa
+} from "./chunk-CT6ZQRLD.js";
+import {
+  initialModelForLanguage,
+  transcribe
+} from "./chunk-KUTT3JXL.js";
+import {
+  createRenderCancellationScope,
+  stoppedByCancelSignal
+} from "./chunk-P7NTODQE.js";
+import {
+  formatSrt,
+  formatVtt,
+  loadTranscript,
+  patchCaptionHtml
+} from "./chunk-VHZ6DL3M.js";
+import {
+  DEFAULT_MODEL,
+  isWhisperUnavailable
+} from "./chunk-CZQLCBWY.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import {
+  PARAKEET_INSTALL_COMMAND,
+  PARAKEET_LANGUAGES,
+  parakeetSpeaks,
+  transcribeWithParakeet
+} from "./chunk-JZIEZCQM.js";
+import {
+  TRANSCRIPT_FILE
+} from "./chunk-IR35BCLK.js";
+
+// src/api/transcribe.ts
+import { existsSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, extname, join, resolve } from "path";
+var MIN_TIMEOUT_MS = 5e3;
+var TranscribeError = class extends Error {
+  code;
+  /** whisper_unavailable: the command that installs Parakeet, when Parakeet would cover this run. */
+  install;
+  /** caption_write_failed after transcribing: the transcript, which was saved. */
+  transcriptPath;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "TranscribeError";
+    this.code = code;
+    if (options.install !== void 0) this.install = options.install;
+    if (options.transcriptPath !== void 0) this.transcriptPath = options.transcriptPath;
+  }
+};
+async function runTranscribe(options) {
+  if (options.signal?.aborted) {
+    throw new TranscribeError("cancelled", "Transcription cancelled", {
+      cause: options.signal.reason
+    });
+  }
+  const inputPath = resolve(options.input);
+  if (!existsSync(inputPath)) {
+    throw new TranscribeError("input_not_found", `File not found: ${options.input}`);
+  }
+  const dir = resolve(options.dir ?? dirname(inputPath));
+  const ext = extname(inputPath).toLowerCase();
+  const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
+  const sidecar = parseSidecar(options.captions, inputPath, dir);
+  if (sidecar && isImport) return exportTranscript(inputPath, sidecar);
+  if (isImport) return importTranscript(inputPath, dir);
+  const { timeoutMs } = options;
+  if (timeoutMs !== void 0 && !(Number.isInteger(timeoutMs) && timeoutMs >= MIN_TIMEOUT_MS)) {
+    throw new TranscribeError(
+      "invalid_timeout",
+      `Invalid timeoutMs: ${timeoutMs}. Must be an integer >= ${MIN_TIMEOUT_MS} (ms).`
+    );
+  }
+  return transcribeAudio(inputPath, dir, sidecar, options);
+}
+function parseExportFormat(value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "srt" || normalized === "vtt") return normalized;
+  throw new TranscribeError(
+    "invalid_option",
+    `Unsupported caption export format: ${value}. Use srt or vtt.`
+  );
+}
+function parseSidecar(captions, inputPath, dir) {
+  const to = parseExportFormat(captions?.format);
+  if (!to) return void 0;
+  const output = captions?.outputPath;
+  const outPath = resolve(output ?? join(dir, `transcript.${to}`));
+  const keep = [inputPath, join(dir, TRANSCRIPT_FILE)];
+  const problem = output !== void 0 && outputProblem(output, outPath, to) || overwriteProblem(outPath, keep);
+  if (problem) throw new TranscribeError("invalid_option", problem);
+  return { to, outPath, preserveCues: captions?.preserveCues === true, keep };
+}
+function outputProblem(output, outPath, to) {
+  if (!output) return "--output needs a file path";
+  const folder = dirname(outPath);
+  if (!existsSync(folder) || !statSync(folder).isDirectory()) {
+    return `Output folder not found: ${folder}`;
+  }
+  if (/[\\/]$/.test(output) || existsSync(outPath) && statSync(outPath).isDirectory()) {
+    return `--output is a folder; give a file path such as ${join(outPath, `transcript.${to}`)}`;
+  }
+  return void 0;
+}
+function overwriteProblem(outPath, keep) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  return hit && `The caption file would overwrite ${hit}; choose another file with --output`;
+}
+function sameFile(out, file) {
+  if (existsSync(out) && existsSync(file)) {
+    const [a, b] = [statSync(out, { bigint: true }), statSync(file, { bigint: true })];
+    if (a.ino !== 0n && b.ino !== 0n) return a.dev === b.dev && a.ino === b.ino;
+    return realpathSync.native(out) === realpathSync.native(file);
+  }
+  const realDir = (p) => existsSync(dirname(p)) ? realpathSync.native(dirname(p)) : dirname(p);
+  return realDir(out) === realDir(file) && basename(out).toLowerCase() === basename(file).toLowerCase();
+}
+function readTranscript(inputPath) {
+  let transcript;
+  try {
+    transcript = loadTranscript(inputPath);
+  } catch (err) {
+    throw new TranscribeError("invalid_transcript", normalizeErrorMessage(err), { cause: err });
+  }
+  if (transcript.words.length === 0) {
+    throw new TranscribeError("no_words", "No words found in transcript.");
+  }
+  return transcript;
+}
+function importTranscript(inputPath, dir) {
+  const { words, format } = readTranscript(inputPath);
+  const transcriptPath = join(dir, TRANSCRIPT_FILE);
+  writeFileSync(transcriptPath, JSON.stringify(words, null, 2));
+  patchCaptionHtml(dir, words);
+  return { kind: "imported", format, wordCount: words.length, transcriptPath };
+}
+function exportTranscript(inputPath, sidecar) {
+  const { words, format } = readTranscript(inputPath);
+  try {
+    writeCaptionSidecar(words, sidecar, format === "srt" || format === "vtt" || void 0);
+  } catch (err) {
+    throw new TranscribeError(
+      "caption_write_failed",
+      `The caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`,
+      { cause: err }
+    );
+  }
+  return {
+    kind: "exported",
+    format: sidecar.to,
+    wordCount: words.length,
+    outputPath: sidecar.outPath
+  };
+}
+function writeCaptionSidecar(words, { to, outPath, preserveCues, keep }, phraseLevelSource) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  if (hit) throw new Error(`it is the same file as ${hit}`);
+  const preGrouped = preserveCues || phraseLevelSource;
+  const content = to === "srt" ? formatSrt(words, { preGrouped }) : formatVtt(words, { preGrouped });
+  writeFileSync(outPath, content);
+}
+function pickRunner(engine, parakeet, language) {
+  if (engine === "whisper" || !parakeetSpeaks(language)) return "whisper";
+  return parakeet() ?? "whisper";
+}
+var parakeetFallsBack = (engine) => engine === "auto";
+function withoutTrailingDots(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === ".") end--;
+  return text.slice(0, end);
+}
+var engineOf = (runner) => runner === "whisper" ? "whisper" : "parakeet";
+function failureMessage(err) {
+  const base = err instanceof Error ? err.message : String(err);
+  const stderr = err && typeof err === "object" && "stderr" in err && err.stderr ? String(err.stderr).trim().split("\n").slice(-3).filter((line) => !base.includes(line)).join("\n") : "";
+  return stderr ? `${base}
+${stderr}` : base;
+}
+async function transcribeAudio(inputPath, dir, sidecar, options) {
+  const engine = (options.engine ?? "auto").toLowerCase();
+  if (engine !== "auto" && engine !== "parakeet" && engine !== "whisper") {
+    throw new TranscribeError(
+      "invalid_option",
+      `Unknown --engine: ${options.engine}. Use auto, parakeet, or whisper.`
+    );
+  }
+  const unsupported = sherpaUnsupportedReason();
+  let runner = pickRunner(engine, () => parakeetRunner({ unsupported }), options.language);
+  if (engine === "parakeet" && runner === "whisper") {
+    throw new TranscribeError(
+      "parakeet_unavailable",
+      !parakeetSpeaks(options.language) ? `Parakeet does not transcribe --language ${options.language}; it covers ${PARAKEET_LANGUAGES.split(" ").join(", ")}. Use --engine whisper.` : unsupported ?? `Parakeet is not installed. Install it with: ${PARAKEET_INSTALL_COMMAND} (or use --engine whisper)`
+    );
+  }
+  const model = options.model ?? DEFAULT_MODEL;
+  const whisperModel = initialModelForLanguage(model, options.language);
+  options.onEngine?.({ runner, engine: engineOf(runner), model: whisperModel });
+  const { onStatus, onProgress } = options;
+  const startScope = () => options.stopOnProcessSignals ? createRenderCancellationScope() : { signal: options.signal ?? new AbortController().signal, dispose: () => {
+  } };
+  let wavPath = inputPath;
+  let cancellation = runner === "sherpa" || !options.stopOnProcessSignals ? startScope() : null;
+  const librarySignal = options.stopOnProcessSignals ? void 0 : cancellation?.signal;
+  const run = (r) => {
+    switch (r) {
+      case "sherpa":
+        return transcribeWithSherpa(wavPath, dir, {
+          onProgress: onStatus,
+          onEvent: onProgress,
+          signal: cancellation.signal
+        });
+      case "parakeet-mlx":
+        return transcribeWithParakeet(wavPath, dir, {
+          onProgress: onStatus,
+          onEvent: onProgress,
+          signal: librarySignal
+        });
+      case "whisper":
+        return transcribe(wavPath, dir, {
+          model,
+          language: options.language,
+          onProgress: onStatus,
+          onEvent: onProgress,
+          timeoutMs: options.timeoutMs,
+          installRuntime: options.installRuntime,
+          signal: librarySignal,
+          startCancellation: () => (cancellation ??= startScope()).signal
+        });
+      default: {
+        const unreachable = r;
+        throw new Error(`Unknown transcription runner: ${unreachable}`);
+      }
+    }
+  };
+  try {
+    if (runner === "sherpa") {
+      wavPath = await prepareSherpaWav(inputPath, onStatus, librarySignal);
+    }
+    let result;
+    try {
+      result = await run(runner);
+    } catch (err) {
+      if (runner !== "sherpa" || err instanceof DecodeCancelled) throw err;
+      const reason = withoutTrailingDots(normalizeErrorMessage(err));
+      const parakeetError = `Parakeet failed: ${reason}. To repair it, run: ${PARAKEET_INSTALL_COMMAND}`;
+      if (!parakeetFallsBack(engine)) throw new Error(parakeetError);
+      runner = pickRunner(
+        engine,
+        () => parakeetRunner({ unsupported, skipSherpa: true }),
+        options.language
+      );
+      options.onEngine?.({
+        runner,
+        engine: engineOf(runner),
+        model: whisperModel,
+        fallbackReason: parakeetError
+      });
+      try {
+        result = await run(runner);
+      } catch (fallbackErr) {
+        if (stoppedByCancelSignal(fallbackErr)) {
+          throw new DecodeCancelled("Transcription cancelled");
+        }
+        const why = normalizeErrorMessage(fallbackErr);
+        throw new Error(`${parakeetError}. The ${runner} fallback failed too: ${why}`);
+      }
+    }
+    const { words } = loadTranscript(result.transcriptPath);
+    writeFileSync(result.transcriptPath, JSON.stringify(words, null, 2));
+    patchCaptionHtml(dir, words);
+    if (sidecar) {
+      try {
+        writeCaptionSidecar(words, sidecar, false);
+      } catch (err) {
+        throw new TranscribeError(
+          "caption_write_failed",
+          `Transcript saved to ${result.transcriptPath}, but the caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`,
+          { cause: err, transcriptPath: result.transcriptPath }
+        );
+      }
+    }
+    return {
+      kind: "transcribed",
+      engine: engineOf(runner),
+      model: result.model,
+      detectedLanguage: result.detectedLanguage,
+      wordCount: words.length,
+      durationSeconds: result.durationSeconds,
+      speechOnsetSeconds: result.speechOnsetSeconds,
+      transcriptPath: result.transcriptPath,
+      ...sidecar && { captions: { format: sidecar.to, outputPath: sidecar.outPath } }
+    };
+  } catch (err) {
+    if (err instanceof TranscribeError) throw err;
+    if (err instanceof DecodeCancelled || cancellation?.signal.aborted) {
+      throw new TranscribeError("cancelled", "Transcription cancelled", { cause: err });
+    }
+    const message = failureMessage(err);
+    if (isWhisperUnavailable(err)) {
+      const install = engine === "auto" && parakeetSpeaks(options.language) && !unsupported ? PARAKEET_INSTALL_COMMAND : void 0;
+      throw new TranscribeError("whisper_unavailable", message, { cause: err, install });
+    }
+    throw new TranscribeError("failed", message, { cause: err });
+  } finally {
+    cancellation?.dispose();
+    if (wavPath !== inputPath) rmSync(wavPath, { force: true });
+  }
+}
+
+export {
+  MIN_TIMEOUT_MS,
+  TranscribeError,
+  runTranscribe
+};

package/dist/{chunk-6BSIQJPW.js → chunk-LTJDUBSQ.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   VERSION
-} from "./chunk-QTTDKWSM.js";
+} from "./chunk-OMBSUO4T.js";
 
 // src/registry/compatibility.ts
 import { compareVersions } from "compare-versions";

package/dist/{chunk-66SAATRI.js → chunk-M5B42RL5.js}

@@ -4,23 +4,23 @@ import { dirname as __hf_dirname } from "node:path";
 var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
-import {
-  chromeDepsInstallCommand,
-  detectLinuxDistro,
-  distroLabel,
-  getFFmpegInstallHint,
-  parseLddMissingLibs
-} from "./chunk-SYUGVPYH.js";
 import {
   getFreeDiskMb
 } from "./chunk-XBSPQ52S.js";
 import {
   ensureBrowser,
   findBrowser
-} from "./chunk-A6S35NYA.js";
+} from "./chunk-7IEGPJ4P.js";
+import {
+  chromeDepsInstallCommand,
+  detectLinuxDistro,
+  distroLabel,
+  getFFmpegInstallHint,
+  parseLddMissingLibs
+} from "./chunk-DUUFDLC4.js";
 import {
   runCancellableProcess
-} from "./chunk-BYSBRF24.js";
+} from "./chunk-XPQSL5VS.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,

package/dist/{chunk-6WD636E5.js → chunk-MI6U3OIN.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-55RZG5SQ.js";
+} from "./chunk-Y475GD4L.js";
 import {
   shouldTrack
-} from "./chunk-3PPO64IB.js";
+} from "./chunk-LACFOFWX.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS

package/dist/{chunk-YCGU3UNU.js → chunk-MXB6CWVH.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   updateNoticesSuppressed
-} from "./chunk-3YUFN37G.js";
+} from "./chunk-GESJSXFH.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";

package/dist/{chunk-Z5C4LEAD.js → chunk-NKM53WMI.js}

@@ -21,7 +21,7 @@ import {
   splitElementInHtml,
   unwrapElementsFromHtml,
   wrapElementsInHtml
-} from "./chunk-A72OAGNB.js";
+} from "./chunk-2HWB4TCI.js";
 import {
   MAX_WINDOW_IDLE_MS,
   STUDIO_SIGNATURE_MANIFEST_PATHS,
@@ -65,7 +65,7 @@ import {
   scanProjectMediaCodecMap,
   shouldPrewarmProxy,
   waitForProxy
-} from "./chunk-MOL32UKR.js";
+} from "./chunk-KMJLHHBF.js";
 import {
   STUDIO_MOTION_PATH,
   createStudioMotionRenderBodyScript,
@@ -77,11 +77,6 @@ import {
   resolveWithinProject,
   walkDir
 } from "./chunk-AIJS74LG.js";
-import {
-  atomicTempPath,
-  createFileAtomically,
-  replaceFileAtomically
-} from "./chunk-EOVYQ3IG.js";
 import {
   findTimelineScript,
   parseGsapScriptAcorn
@@ -96,9 +91,14 @@ import {
   getSystemProfilerFamilies,
   locateSystemFont
 } from "./chunk-TJSTGSAW.js";
+import {
+  atomicTempPath,
+  createFileAtomically,
+  replaceFileAtomically
+} from "./chunk-EOVYQ3IG.js";
 import {
   addScenePartsManifest
-} from "./chunk-JBQJKC23.js";
+} from "./chunk-62RUQJ5J.js";
 import {
   ensureHfIds
 } from "./chunk-NE55C6S5.js";
@@ -111,7 +111,7 @@ import {
   parseFps,
   parsePreviewProxyBox,
   sameInstant
-} from "./chunk-BAKPN2D2.js";
+} from "./chunk-AHBYQRGI.js";
 import {
   AFTER_FONTS_SCRIPT_TYPE,
   RUNTIME_BOOTSTRAP_ATTR,
@@ -125,7 +125,7 @@ import {
   resolveRateSpec,
   sourceTimeAt,
   stripEmbeddedRuntimeScripts
-} from "./chunk-Z6FLHIDV.js";
+} from "./chunk-3WD4JNMU.js";
 import {
   HTML_ATTRIBUTE_ENTITIES,
   MagicString,
@@ -5446,7 +5446,7 @@ async function prepareGsapMutationScript(c, res, firstMutation) {
   let block = extractGsapScriptBlock(html);
   if (!block && (firstMutation.type === "add" || firstMutation.type === "add-with-keyframes")) {
     const compId = html.match(/data-composition-id="([^"]+)"/)?.[1] ?? "main";
-    const { GSAP_CDN } = await import("./dist-GPDOV3IQ.js");
+    const { GSAP_CDN } = await import("./dist-CUIR3GFX.js");
     const bootstrap = [
       `<script src="${GSAP_CDN}"></script>`,
       "<script>",

package/dist/{chunk-QTTDKWSM.js → chunk-OMBSUO4T.js}

@@ -6,8 +6,8 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 
 // src/version.ts
-var VERSION = true ? "0.8.147" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.147" : "0.0.0-dev";
+var VERSION = true ? "0.8.149" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.149" : "0.0.0-dev";
 
 export {
   VERSION,

package/dist/{chunk-AL2YEVOT.js → chunk-P7NTODQE.js}

@@ -6,15 +6,15 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   setHostHandlesSigint
-} from "./chunk-JF5L5SQ6.js";
+} from "./chunk-VC7JBNPS.js";
 import {
   processAncestorSnapshot,
   processIdentity,
   processParentPid
-} from "./chunk-A4Q7W4LV.js";
+} from "./chunk-B3XLIBFL.js";
 import {
   processIsAlive
-} from "./chunk-BYSBRF24.js";
+} from "./chunk-KGPLIH7B.js";
 
 // src/utils/renderCancellation.ts
 var RENDER_CANCELLATION_SIGNALS = [

package/dist/{chunk-BHVFTYSI.js → chunk-PO2SDVQA.js}

@@ -46,6 +46,9 @@ function measureDownload(options, contentLength) {
   });
   return { stream, complete: () => options.onProgress?.(receivedBytes, totalBytes) };
 }
+function getUrl(url, signal, onResponse) {
+  return signal ? httpsGet(url, { signal }, onResponse) : httpsGet(url, onResponse);
+}
 function downloadFile(url, dest, options = {}) {
   const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
   const timeoutMs = options.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
@@ -57,7 +60,7 @@ function downloadFile(url, dest, options = {}) {
       let requestError;
       let request;
       try {
-        request = httpsGet(u, (res) => {
+        request = getUrl(u, options.signal, (res) => {
           activeResponse = res;
           if (res.statusCode && REDIRECT_CODES.has(res.statusCode)) {
             const location = res.headers.location;

package/dist/{chunk-DDNS2674.js → chunk-PR7QQBSC.js}

@@ -8,7 +8,7 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemManifest,
   fetchRegistryManifest
-} from "./chunk-XVIYZU3D.js";
+} from "./chunk-K35E45SI.js";
 
 // src/registry/resolver.ts
 function defaultWarn(message) {

package/dist/{chunk-FDL4HV44.js → chunk-Q2Y5OZCY.js}

@@ -8,14 +8,14 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-XVIYZU3D.js";
+} from "./chunk-K35E45SI.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-BAKPN2D2.js";
+} from "./chunk-AHBYQRGI.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-P6HELLPU.js → chunk-QIJLIULK.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   resolveConfig,
   usesSoftwareWebGpu
-} from "./chunk-JF5L5SQ6.js";
+} from "./chunk-VC7JBNPS.js";
 
 // src/browser/gpuPolicy.ts
 function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCER_BROWSER_GPU_MODE) {
@@ -17,7 +17,7 @@ function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCE
   return "auto";
 }
 async function resolveCaptureBrowserGpuMode(requestedMode, chromePath) {
-  const { resolveBrowserGpuMode } = await import("./src-2GMPFYHL.js");
+  const { resolveBrowserGpuMode } = await import("./src-VMTHSARJ.js");
   return resolveBrowserGpuMode(requestedMode, { chromePath });
 }
 function resolveLocalWebGpu(browserGpuMode, requiresWebGpu) {

package/dist/{chunk-5OKZLMQK.js → chunk-RMIFSBRV.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-FKOIB3R3.js");
+        const { trackCommandFailure } = await import("./events-6C3ZG7LS.js");
         trackCommandFailure(
           command,
           err,

package/dist/{chunk-AFIATIKS.js → chunk-SFUBSJFP.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-K2FLNJVB.js";
 import {
   trackCommandFailure
-} from "./chunk-55RZG5SQ.js";
+} from "./chunk-Y475GD4L.js";
 import {
   failCommand
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-LE7T4ML7.js → chunk-SP6XL3NP.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-HVW7ABXD.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-XVIYZU3D.js";
+} from "./chunk-K35E45SI.js";
 
 // src/utils/projectConfig.ts
 import { readFileSync, writeFileSync } from "fs";

package/dist/{chunk-SEABQTBP.js → chunk-TPIG7ZBX.js}

@@ -10,25 +10,25 @@ import {
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-XOJDBRNF.js";
+} from "./chunk-4S4VUXW3.js";
 import {
   resolveDiagnosticNavigationTimeoutMs,
   windowsChromeCrashRemediation
-} from "./chunk-3HSWLZ6S.js";
+} from "./chunk-KQHJKJ3V.js";
 import {
   resolveLocalBrowserGpuMode,
   resolveLocalWebGpu
-} from "./chunk-P6HELLPU.js";
+} from "./chunk-QIJLIULK.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
 import {
   assertWebGpuAdapterAvailable,
   compositionRequiresWebGpu
-} from "./chunk-JF5L5SQ6.js";
+} from "./chunk-VC7JBNPS.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
-import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
 
 // src/capture/captureCompositionFrame.ts
 import { spawn } from "child_process";
@@ -104,10 +104,10 @@ async function installPageFunctionGuard(page) {
 }
 async function openSettledCompositionPage(html, url, options) {
   const viewport = resolveCompositionViewportFromHtml(html);
-  const { ensureBrowser, findSystemBrowser } = await import("./manager-BPSR6D3V.js");
+  const { ensureBrowser, findSystemBrowser } = await import("./manager-GWU5J6RJ.js");
   const browser = await ensureBrowser();
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-2GMPFYHL.js");
+  const { buildChromeArgs } = await import("./src-VMTHSARJ.js");
   const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
   const requiresWebGpu = compositionRequiresWebGpu(html);
   let softwareWebGpu = false;