hyperframes 0.8.183 → 0.8.185

package/dist/{chunk-4UFJWRHG.js → chunk-IVEFOUZI.js}

@@ -8,7 +8,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-ATMDOUNN.js";
+} from "./chunk-K73RJB23.js";
 import {
   GENERIC_FAMILIES,
   collectFontFamilyCustomProperties,
@@ -16,7 +16,7 @@ import {
   iterateFontFamilyDeclarations,
   normalizeSystemFontPrimaryFamilies,
   resolveFontFamilyDeclarationFamilies
-} from "./chunk-QGOYNPQT.js";
+} from "./chunk-LLFQA7XF.js";
 import {
   parseEncoderOptions
 } from "./chunk-KLIKCX6Q.js";
@@ -154,7 +154,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-73LTCCZI.js";
+} from "./chunk-I3IH5MV5.js";
 import {
   DISTRIBUTED_FPS,
   HF_VFX_ATTR,
@@ -169,7 +169,7 @@ import {
   parseVfxChain,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-KROXPHXX.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -182,7 +182,7 @@ import {
   isTemplateEntry,
   parsesAsScript,
   prepareFlattenedInnerRoot
-} from "./chunk-WT4PYV2J.js";
+} from "./chunk-Q47FAYYK.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -210,7 +210,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-GMNHAOMJ.js";
+} from "./chunk-3NPOFC43.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-UJKQWGFF.js";
@@ -224,7 +224,7 @@ import {
   isAspectAgnosticResolutionAlias,
   normalizeResolutionFlag,
   suggestMatchingPreset
-} from "./chunk-YMS5FOMC.js";
+} from "./chunk-B2A56S5C.js";
 import {
   TRANSITIONS,
   convertTransfer,
@@ -240,7 +240,7 @@ import {
 import {
   lintHyperframeHtml,
   resolveReferencedStart
-} from "./chunk-ADDHW2FS.js";
+} from "./chunk-Q447CX26.js";
 import {
   isUnresolvedAssetPlaceholder,
   readProjectFile,
@@ -6604,7 +6604,7 @@ async function readLocalFont(absPath) {
   return { kind: "inline", buffer: Buffer.concat(chunks, totalBytes) };
 }
 async function embedLocalFontFaces(html, projectDir) {
-  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-JFLSSKRB.js");
+  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-EGAAE7QL.js");
   const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
   const fontFaceRe = /@font-face\s*\{([^}]*)\}/gi;
   let result = html;
@@ -8623,6 +8623,7 @@ async function runCaptureStage(input) {
           if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
           return;
         }
+        if (progress.landedFrame) input.onFrameLanded?.(progress.landedFrame);
         job.framesRendered = progress.capturedFrames;
         checkDiskProjection(progress.capturedFrames);
         const frameProgress = progress.capturedFrames / progress.totalFrames;
@@ -9769,6 +9770,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync4
 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
 import { dirname as dirname7, join as join23 } from "path";
 
 // ../producer/src/services/render/stages/gifEncodeArgs.ts
@@ -9900,6 +9902,124 @@ function startEncodeProgress(job, stage, onProgress) {
   });
   return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);
 }
+function resolveEngineConfig(input) {
+  return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();
+}
+function videoEncoderOptions(input, engineCfg) {
+  const { job, preset } = input;
+  return {
+    fps: job.config.fps,
+    width: input.width,
+    height: input.height,
+    codec: preset.codec,
+    preset: preset.preset,
+    quality: input.effectiveQuality,
+    bitrate: input.effectiveBitrate,
+    pixelFormat: preset.pixelFormat,
+    vp9CpuUsed: engineCfg.vp9CpuUsed,
+    useGpu: job.config.useGpu,
+    hdr: preset.hdr,
+    // Distributed chunk renders pass these so the encoder writes closed-GOP
+    // keyframes that survive `-f concat -c copy` at assemble time. In-process
+    // renders leave both undefined → preserves the existing open-GOP output.
+    lockGopForChunkConcat: input.lockGopForChunkConcat === true,
+    gopSize: input.gopSize
+  };
+}
+function canEncodeWhileCapturing(input, workerCount, cpuCount) {
+  return workerCount > 1 && workerCount < cpuCount && !input.isPngSequence && !input.isGif && !input.enableChunkedEncode && input.preset.codec === "h264" && !input.preset.hdr && input.job.config.useGpu !== true && input.captureImageFormat === "jpeg" && input.lockGopForChunkConcat !== true;
+}
+async function readLandedFrame(workerPath, mergedPath) {
+  if (workerPath !== void 0) {
+    try {
+      return await readFile2(workerPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  return readFile2(mergedPath);
+}
+function encodeWhileCapturing(input, totalFrames) {
+  const engineCfg = resolveEngineConfig(input);
+  const stop = new AbortController();
+  const signal = input.abortSignal ? AbortSignal.any([input.abortSignal, stop.signal]) : stop.signal;
+  const landed = /* @__PURE__ */ new Map();
+  let captureDone = false;
+  let framesFed = 0;
+  let wake = null;
+  const nudge = () => {
+    wake?.();
+    wake = null;
+  };
+  signal.addEventListener("abort", nudge, { once: true });
+  let reportFed = null;
+  const encoder = spawnStreamingEncoder(
+    input.videoOnlyPath,
+    { ...videoEncoderOptions(input, engineCfg), imageFormat: "jpeg" },
+    signal,
+    engineCfg
+  );
+  const fed = (async () => {
+    const stream = await encoder;
+    for (let next = 0; next < totalFrames; next++) {
+      while (!landed.has(next) && !captureDone && !signal.aborted) {
+        await new Promise((resolve11) => wake = resolve11);
+      }
+      if (signal.aborted) return;
+      const mergedPath = join23(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const frame = await readLandedFrame(landed.get(next), mergedPath);
+      landed.delete(next);
+      if (!await stream.writeFrame(frame)) {
+        throw new Error(stream.getExitError() ?? "encoder exited before the last frame");
+      }
+      framesFed++;
+      reportFed?.(framesFed);
+    }
+  })().then(
+    () => void 0,
+    (error) => error ?? new Error("encode failed")
+  );
+  const closeEncoder = async () => (await encoder.catch(() => null))?.close();
+  return {
+    onFrameLanded: (frame) => {
+      landed.set(frame.index, frame.path);
+      nudge();
+    },
+    finish: async () => {
+      const start = Date.now();
+      captureDone = true;
+      input.log.info("[Render] Encoded frames while capturing", {
+        framesFed,
+        totalFrames
+      });
+      const encoded = startEncodeProgress(input.job, "Encoding video", input.onProgress);
+      reportFed = encoded;
+      nudge();
+      const failure = await fed;
+      const result = await closeEncoder();
+      input.assertNotAborted();
+      if (failure === void 0 && result?.success) {
+        encoded();
+        return { encodeMs: Date.now() - start };
+      }
+      input.log.warn(
+        "[Render] Encoding while capturing failed; encoding the frames after capture",
+        {
+          error: String(failure ?? result?.error)
+        }
+      );
+      return runEncodeStage(input);
+    },
+    abort: async () => {
+      stop.abort();
+      await fed;
+      await closeEncoder();
+    },
+    get framesFed() {
+      return framesFed;
+    }
+  };
+}
 async function runEncodeStage(input) {
   const {
     job,
@@ -9907,16 +10027,11 @@ async function runEncodeStage(input) {
     outputPath,
     framesDir,
     videoOnlyPath,
-    width,
-    height,
     needsAlpha,
     hasAudio,
     audioOutputPath,
     isPngSequence,
     isGif,
-    preset,
-    effectiveQuality,
-    effectiveBitrate,
     enableChunkedEncode,
     chunkedEncodeSize,
     abortSignal,
@@ -9946,7 +10061,7 @@ async function runEncodeStage(input) {
     encoded();
     return { encodeMs: Date.now() - stage5Start };
   }
-  const engineCfg = input.engineConfig ?? job.config.producerConfig ?? resolveConfig();
+  const engineCfg = resolveEngineConfig(input);
   if (isGif) {
     const encoded = startEncodeProgress(job, "Encoding GIF", onProgress);
     if (hasAudio) {
@@ -9976,24 +10091,7 @@ async function runEncodeStage(input) {
   const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
   const frameExt = frameFileExtension(input.captureImageFormat);
   const framePattern = `frame_%06d.${frameExt}`;
-  const encoderOpts = {
-    fps: job.config.fps,
-    width,
-    height,
-    codec: preset.codec,
-    preset: preset.preset,
-    quality: effectiveQuality,
-    bitrate: effectiveBitrate,
-    pixelFormat: preset.pixelFormat,
-    vp9CpuUsed: engineCfg.vp9CpuUsed,
-    useGpu: job.config.useGpu,
-    hdr: preset.hdr,
-    // Distributed chunk renders pass these so the encoder writes closed-GOP
-    // keyframes that survive `-f concat -c copy` at assemble time. In-process
-    // renders leave both undefined → preserves the existing open-GOP output.
-    lockGopForChunkConcat: input.lockGopForChunkConcat === true,
-    gopSize: input.gopSize
-  };
+  const encoderOpts = videoEncoderOptions(input, engineCfg);
   const encodeResult = enableChunkedEncode ? await encodeFramesChunkedConcat(
     framesDir,
     framePattern,
@@ -10259,7 +10357,6 @@ async function enforceAacTruePeak(input) {
   try {
     scratchDir = mkdtempSync3(join24(dirname8(input.audioPath), ".true-peak-"));
     const correctedPath = join24(scratchDir, "audio.m4a");
-    const correctionTargetDbfs = AAC_DELIVERY_TRUE_PEAK_DBFS - AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB;
     const measurements = [];
     let attenuationDb = 0;
     let measuredPath = input.audioPath;
@@ -10277,7 +10374,8 @@ async function enforceAacTruePeak(input) {
         return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
-      attenuationDb += correctionTargetDbfs - truePeakDbfs;
+      const headroomDb = AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB * 2 ** pass;
+      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - truePeakDbfs;
       const result = await input.encode(
         input.audioPath,
         correctedPath,
@@ -12901,6 +12999,34 @@ async function executeRenderPipeline(input) {
           throw new Error(`Disk capture requires sdr_disk plan; got ${capturePlan.kind}`);
         }
         resetCaptureAttemptProgress(job);
+        const encodeInput = {
+          job,
+          log,
+          outputPath: stagedOutputPath,
+          framesDir,
+          videoOnlyPath,
+          width,
+          height,
+          needsAlpha,
+          captureImageFormat: captureOptions.format ?? "jpeg",
+          hasAudio,
+          audioOutputPath,
+          isPngSequence,
+          isGif,
+          preset,
+          effectiveQuality,
+          effectiveBitrate,
+          enableChunkedEncode,
+          chunkedEncodeSize,
+          engineConfig: cfg,
+          // Same value the streaming encoder above spreads — the disk and
+          // chunked-concat encoders need an identical GOP lock for HLS.
+          ...hlsEncoderGopLock,
+          abortSignal: executionSignal,
+          assertNotAborted,
+          onProgress
+        };
+        const overlap = !cfg.useDrawElement && workerSizing !== void 0 && canEncodeWhileCapturing(encodeInput, capturePlan.workerCount, workerSizing.cpuCount) ? encodeWhileCapturing(encodeInput, totalFrames) : null;
         const captureFrameStart = Date.now();
         const invokeDiskCapture = (diskPlan) => observeRenderStage(
           observability,
@@ -12922,13 +13048,15 @@ async function executeRenderPipeline(input) {
             createRenderVideoFrameInjector,
             abortSignal: executionSignal,
             assertNotAborted,
-            onProgress
+            onProgress,
+            onFrameLanded: (frame) => overlap?.onFrameLanded(frame)
           })
         );
         let captureRes;
         try {
           captureRes = await invokeDiskCapture(capturePlan);
         } catch (err) {
+          await overlap?.abort();
           if (!isDrawElementVerificationError(err) && !isDrawElementCaptureError(err) || err instanceof RenderCancelledError || executionSignal?.aborted === true) {
             throw err;
           }
@@ -12997,33 +13125,7 @@ async function executeRenderPipeline(input) {
             isGif,
             chunkedEncode: enableChunkedEncode
           }),
-          () => runEncodeStage({
-            job,
-            log,
-            outputPath: stagedOutputPath,
-            framesDir,
-            videoOnlyPath,
-            width,
-            height,
-            needsAlpha,
-            captureImageFormat: captureOptions.format ?? "jpeg",
-            hasAudio,
-            audioOutputPath,
-            isPngSequence,
-            isGif,
-            preset,
-            effectiveQuality,
-            effectiveBitrate,
-            enableChunkedEncode,
-            chunkedEncodeSize,
-            engineConfig: cfg,
-            // Same value the streaming encoder above spreads — the disk and
-            // chunked-concat encoders need an identical GOP lock for HLS.
-            ...hlsEncoderGopLock,
-            abortSignal: executionSignal,
-            assertNotAborted,
-            onProgress
-          })
+          () => overlap ? overlap.finish() : runEncodeStage(encodeInput)
         );
         perfStages.encodeMs = encodeRes.encodeMs;
       }
@@ -13585,7 +13687,14 @@ var RenderChunkValidationError = class extends Error {
   }
 };
 function createChunkVideoFrameInjectorFactory(frameLookup) {
-  return () => createVideoFrameInjector(frameLookup);
+  if (!(frameLookup instanceof Promise)) return () => createVideoFrameInjector(frameLookup);
+  return () => {
+    let hook;
+    return async (page, time, heldVideoTime) => {
+      hook ??= createVideoFrameInjector(await frameLookup);
+      await hook?.(page, time, heldVideoTime);
+    };
+  };
 }
 function frameNumberFromFileName(name) {
   const match = /(\d+)(?=\.[^.]+$)/.exec(name);
@@ -15361,7 +15470,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-EL6HGIS4.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-RZ574OKP.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -16576,9 +16685,6 @@ function validateOutputResolutionOverride(body) {
   if (body.outputResolution.trim().length > 0 && normalized === void 0) {
     return `Invalid outputResolution "${body.outputResolution}". Must be one of: landscape, portrait, landscape-4k, portrait-4k, square, square-4k (aliases: 1080p, 4k, \u2026).`;
   }
-  if (normalized !== void 0 && (body.format === "webm" || body.format === "mov")) {
-    return `outputResolution is not supported with format "${body.format}": the alpha (webm/mov) capture path can't supersample. Use format "mp4", or omit outputResolution to render at the composition's native dimensions.`;
-  }
   return void 0;
 }
 function prepareProjectDirectory(projectDir, options) {
@@ -17024,7 +17130,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-EL6HGIS4.js");
+    const { drainBrowserPool } = await import("./src-RZ574OKP.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -18266,6 +18372,12 @@ function validatePlanVideosForChunk(value) {
     );
   }
 }
+var MIN_FRAMES_PER_CHUNK_BROWSER = 20;
+function resolveChunkCaptureWorkers(framesInChunk, machineSized, maxCaptureWorkers) {
+  if (maxCaptureWorkers === void 0) return machineSized;
+  const byFrames = Math.floor(framesInChunk / MIN_FRAMES_PER_CHUNK_BROWSER);
+  return Math.max(machineSized, Math.floor(Math.min(maxCaptureWorkers, byFrames)));
+}
 function resolveChunkFrameRange(slice, chunkIndex, frameRange) {
   if (frameRange === void 0) return { startFrame: slice.startFrame, endFrame: slice.endFrame };
   const { startFrame, endFrame } = frameRange;
@@ -18502,7 +18614,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         deferredVideos.filter((video) => remoteVideoIds.has(video.videoId))
       )
     });
-    const chunkWorkerCount = calculateOptimalWorkers(framesInChunk, void 0, cfg);
+    const chunkWorkerCount = resolveChunkCaptureWorkers(
+      framesInChunk,
+      calculateOptimalWorkers(framesInChunk, void 0, cfg),
+      options?.maxCaptureWorkers
+    );
     let session = null;
     let outputKind;
     let framesEncoded = 0;
@@ -18514,6 +18630,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     const captureAttempts = [];
     let forceScreenshotForChunk = encoder.forceScreenshot;
     let shownBoxes;
+    let extraction;
     try {
       if (chunkWorkerCount === 1 || !forceScreenshotForChunk) {
         const bootStarted = Date.now();
@@ -18570,7 +18687,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           session = null;
         }
       }
-      const deferredVideoFrames = planVideos ? await extractDeferredVideoFramesForChunk({
+      const deferredVideoFrames = planVideos ? extractDeferredVideoFramesForChunk({
         planDir,
         planVideos,
         frames: chunkFrameNumbers,
@@ -18579,19 +18696,24 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         cfg,
         remoteSources,
         shownBoxes
-      }) : [];
-      const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable(
-        planVideos.videos,
-        [
-          ...rebuildExtractedFramesFromPlanDir(
-            planDir,
-            planVideos.extracted.filter((video) => !video.deferredRange),
-            v2Manifest === null ? "dense-v1" : "sparse-v2"
-          ),
-          ...deferredVideoFrames
-        ],
-        resolveRenderFpsConfig(job.config.fps).value
+      }) : Promise.resolve([]);
+      extraction = deferredVideoFrames;
+      const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? deferredVideoFrames.then(
+        (deferred) => createFrameLookupTable(
+          planVideos.videos,
+          [
+            ...rebuildExtractedFramesFromPlanDir(
+              planDir,
+              planVideos.extracted.filter((video) => !video.deferredRange),
+              v2Manifest === null ? "dense-v1" : "sparse-v2"
+            ),
+            ...deferred
+          ],
+          resolveRenderFpsConfig(job.config.fps).value
+        )
       ) : null;
+      videoFrameLookup?.catch(() => {
+      });
       const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
@@ -18674,7 +18796,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             }
           );
         }
+      }).catch(async (captureError) => {
+        await deferredVideoFrames;
+        throw captureError;
       });
+      await deferredVideoFrames;
       captureStageMs = Date.now() - captureStarted;
       applyRenderWarningPolicy(
         job,
@@ -18753,6 +18879,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
+      await extraction?.catch(() => {
+      });
       if (session) {
         try {
           await closeCaptureSession(session);

package/dist/chunk-IZCW2NKT.js

@@ -0,0 +1,29 @@
+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);
+
+// ../parsers/dist/mediaAlpha.js
+var ALPHA_PIX_FMT_RE = /^(?:yuva|rgba|argb|bgra|abgr|gbrap|ya|ayuv)/i;
+function pixelFormatHasAlpha(pixFmt) {
+  return pixFmt !== void 0 && ALPHA_PIX_FMT_RE.test(pixFmt);
+}
+function videoStreamHasAlpha(stream) {
+  if (pixelFormatHasAlpha(stream.pix_fmt)) return true;
+  return Object.entries(stream.tags ?? {}).some(
+    ([key, value]) => key.toLowerCase() === "alpha_mode" && value === "1"
+  );
+}
+function alphaDecoderFor(codecName) {
+  const codec = codecName?.toLowerCase();
+  if (codec === "vp9") return "libvpx-vp9";
+  if (codec === "vp8") return "libvpx";
+  return null;
+}
+
+export {
+  videoStreamHasAlpha,
+  alphaDecoderFor
+};

package/dist/{chunk-X3IA5RYH.js → chunk-J36JVBLR.js}

@@ -112,12 +112,18 @@ function wrapWith401Retry(client) {
 
 // src/cloud/errors.ts
 var ERROR_CODE_HINTS = {
-  hyperframes_project_too_large: "The zip exceeded the 200 MB limit. Run `hyperframes cloud render --dry-run`, then add only verified-unneeded paths to `.hyperframesignore` or pre-host required large media.",
+  hyperframes_project_too_large: "The zip exceeded the 200 MB limit. Run `hyperframes cloud render --dry-run` to see what stays in it, then add only verified-unneeded paths to `.hyperframesignore`.",
   hyperframes_render_not_found: "The render_id no longer exists \u2014 either soft-deleted or never created.",
   invalid_parameter: "Check the listed parameter against `hyperframes cloud render --help` for the accepted values.",
   authentication_failed: "Run `hyperframes auth status` to confirm your credential; `hyperframes auth login` to re-auth.",
   rate_limit_exceeded: "Retry after the duration in the Retry-After header."
 };
+function hintCode(err) {
+  if (err.code === "invalid_parameter" && /^File too large\b/.test(err.message)) {
+    return "hyperframes_project_too_large";
+  }
+  return err.code;
+}
 function reportApiError(stage, err, options = {}) {
   const hints = { ...ERROR_CODE_HINTS, ...options.extraHints };
   if (err instanceof HyperframesApiError) {
@@ -125,7 +131,8 @@ function reportApiError(stage, err, options = {}) {
       errorBox("Not found", options.notFound);
       failCommand();
     }
-    const hint = err.code ? hints[err.code] : void 0;
+    const code = hintCode(err);
+    const hint = code ? hints[code] : void 0;
     const title = `${stage} (HTTP ${err.status})`;
     if (hint) {
       errorBox(title, err.message, hint);

package/dist/{chunk-Z4R35NJS.js → chunk-J5XEZ24I.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   getMimeType,
   injectMediaCodecMapIntoHtml
-} from "./chunk-NZ3BE2QE.js";
+} from "./chunk-KQ4JEJLF.js";
 import {
   PROXY_VARIANT_CONFIG,
   ProxyCapacityError,
@@ -18,10 +18,10 @@ import {
   recordProxyRequest,
   resolveProxy,
   resolveProxyVariantRequest
-} from "./chunk-GPE3WWTO.js";
+} from "./chunk-6GPR3G3C.js";
 import {
   resolveAutoProxy
-} from "./chunk-K2Z5DZBS.js";
+} from "./chunk-HDIRZGK4.js";
 import {
   decodeWellFormedEscapes
 } from "./chunk-BSQ7XANM.js";

package/dist/{chunk-OH56PXFH.js → chunk-K2ZKXTVL.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   detectGpuEncoder
-} from "./chunk-73LTCCZI.js";
+} from "./chunk-I3IH5MV5.js";
 import {
   runCancellableProcess
 } from "./chunk-DYAPHNV6.js";

package/dist/{chunk-ATMDOUNN.js → chunk-K73RJB23.js}

@@ -8,10 +8,10 @@ import {
   DEFAULT_VP9_CPU_USED,
   isHttpUrl,
   runFfmpeg
-} from "./chunk-73LTCCZI.js";
+} from "./chunk-I3IH5MV5.js";
 import {
   parseAnimatedGifMetadata
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-KROXPHXX.js";
 import {
   parseHTML
 } from "./chunk-SDYDNHEE.js";