hyperframes 0.8.148 → 0.8.149

package/dist/{chunk-OLENCLFE.js → chunk-L274XRWA.js}

@@ -8,14 +8,13 @@ import {
   loadOptionalPackage
 } from "./chunk-3DKN5WKL.js";
 import {
-  ensureModel,
-  selectProviders
-} from "./chunk-SQLK7SJL.js";
+  downloadFile
+} from "./chunk-PO2SDVQA.js";
 import {
   findFFmpeg,
   findFFprobe,
   getFFmpegInstallHint
-} from "./chunk-SYUGVPYH.js";
+} from "./chunk-DUUFDLC4.js";
 import {
   DEFAULT_VP9_CPU_USED,
   SDR_RGB_TO_BT709_FILTER,
@@ -26,7 +25,74 @@ import {
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
 import { renameSync, rmSync } from "fs";
-import { basename, dirname, extname, join } from "path";
+import { basename, dirname, extname, join as join2 } from "path";
+
+// src/background-removal/manager.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir, platform, arch } from "os";
+import { join } from "path";
+var MODELS_DIR = join(homedir(), ".cache", "hyperframes", "background-removal", "models");
+var DEFAULT_MODEL = "u2net_human_seg";
+var MODEL_URLS = {
+  u2net_human_seg: "https://github.com/danielgatis/rembg/releases/download/v0.0.0/u2net_human_seg.onnx"
+};
+var MODEL_MEMORY_MB = {
+  u2net_human_seg: 1500
+};
+var DEVICES = ["auto", "cpu", "coreml", "cuda"];
+function isDevice(value) {
+  return typeof value === "string" && DEVICES.includes(value);
+}
+function selectProviders(device = "auto") {
+  if (device === "cpu") return { providers: ["cpu"], label: "CPU" };
+  const available = listAvailableProviders();
+  const hasCoreML = available.includes("coreml");
+  const hasCUDA = available.includes("cuda");
+  if (device === "coreml") {
+    if (!hasCoreML) {
+      throw new Error(
+        "CoreML execution provider not available. Install onnxruntime-node on Apple Silicon, or use --device cpu."
+      );
+    }
+    return { providers: ["coreml", "cpu"], label: "CoreML" };
+  }
+  if (device === "cuda") {
+    if (!hasCUDA) {
+      throw new Error(
+        "CUDA execution provider not available. Use --device cpu or install an onnxruntime-node build with CUDA support."
+      );
+    }
+    return { providers: ["cuda", "cpu"], label: "CUDA" };
+  }
+  if (hasCoreML && platform() === "darwin" && arch() === "arm64") {
+    return { providers: ["coreml", "cpu"], label: "CoreML" };
+  }
+  if (hasCUDA) return { providers: ["cuda", "cpu"], label: "CUDA" };
+  return { providers: ["cpu"], label: "CPU" };
+}
+var _cachedProviders;
+function listAvailableProviders() {
+  if (_cachedProviders) return _cachedProviders;
+  const out = ["cpu"];
+  if (platform() === "darwin" && arch() === "arm64") out.push("coreml");
+  if (process.env["HYPERFRAMES_CUDA"] === "1") out.push("cuda");
+  _cachedProviders = out;
+  return out;
+}
+function modelPath(model = DEFAULT_MODEL) {
+  return join(MODELS_DIR, `${model}.onnx`);
+}
+async function ensureModel(model = DEFAULT_MODEL, options) {
+  const dest = modelPath(model);
+  if (existsSync(dest)) return dest;
+  mkdirSync(MODELS_DIR, { recursive: true });
+  options?.onProgress?.(`Downloading ${model} weights (~168 MB)...`);
+  await downloadFile(MODEL_URLS[model], dest);
+  if (!existsSync(dest)) {
+    throw new Error(`Model download failed: ${model}`);
+  }
+  return dest;
+}
 
 // src/background-removal/inference.ts
 var INPUT_SIZE = 320;
@@ -374,7 +440,7 @@ async function render(options) {
   }
 }
 function tempBeside(path) {
-  return join(dirname(path), `.tmp-${randomUUID()}-${basename(path)}`);
+  return join2(dirname(path), `.tmp-${randomUUID()}-${basename(path)}`);
 }
 var RECENT_WINDOW = 30;
 function spawnFfmpeg(ffmpegPath, args, label, stdio) {
@@ -484,6 +550,13 @@ function waitForExit(proc, label, getStderr) {
 }
 
 export {
+  DEFAULT_MODEL,
+  MODEL_MEMORY_MB,
+  DEVICES,
+  isDevice,
+  selectProviders,
+  listAvailableProviders,
+  modelPath,
   QUALITIES,
   DEFAULT_QUALITY,
   isQuality,

package/dist/{chunk-QX26JK43.js → chunk-LACFOFWX.js}

@@ -14,13 +14,8 @@ import {
   getInvocationId
 } from "./chunk-54HJ63Q2.js";
 import {
-  CANARIES,
-  canaryEnvVar,
-  canaryFeatureProperties,
-  evaluateCanary,
-  findCanary,
-  parseCanaryOverride
-} from "./chunk-FXMKHHPO.js";
+  c
+} from "./chunk-ZTZA4UWZ.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";
@@ -34,10 +29,15 @@ import {
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-KQESKXAC.js";
+} from "./chunk-OMBSUO4T.js";
 import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
+  CANARIES,
+  canaryEnvVar,
+  canaryFeatureProperties,
+  evaluateCanary,
+  findCanary,
+  parseCanaryOverride
+} from "./chunk-FXMKHHPO.js";
 
 // src/telemetry/transport.ts
 import { spawn } from "child_process";

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-ELACLQPC.js → chunk-LTJDUBSQ.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   VERSION
-} from "./chunk-KQESKXAC.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-YQK445YQ.js → chunk-MI6U3OIN.js}

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

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

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

package/dist/{chunk-KQESKXAC.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.148" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.148" : "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-UTBQSOEC.js → chunk-P7NTODQE.js}

@@ -11,10 +11,10 @@ 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-NT7EK6ET.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-33GOPHSS.js");
+        const { trackCommandFailure } = await import("./events-6C3ZG7LS.js");
         trackCommandFailure(
           command,
           err,

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

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

package/dist/{chunk-74JDPWQ3.js → chunk-TPIG7ZBX.js}

@@ -19,6 +19,9 @@ import {
   resolveLocalBrowserGpuMode,
   resolveLocalWebGpu
 } from "./chunk-QIJLIULK.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
 import {
   assertWebGpuAdapterAvailable,
   compositionRequiresWebGpu
@@ -26,9 +29,6 @@ import {
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
-import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
 
 // src/capture/captureCompositionFrame.ts
 import { spawn } from "child_process";
@@ -104,7 +104,7 @@ 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-VMTHSARJ.js");