hyperframes 0.8.183 → 0.8.184

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

@@ -8,7 +8,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-ATMDOUNN.js";
+} from "./chunk-TE427YID.js";
 import {
   GENERIC_FAMILIES,
   collectFontFamilyCustomProperties,
@@ -16,7 +16,7 @@ import {
   iterateFontFamilyDeclarations,
   normalizeSystemFontPrimaryFamilies,
   resolveFontFamilyDeclarationFamilies
-} from "./chunk-QGOYNPQT.js";
+} from "./chunk-OLZENUPI.js";
 import {
   parseEncoderOptions
 } from "./chunk-KLIKCX6Q.js";
@@ -154,7 +154,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-73LTCCZI.js";
+} from "./chunk-RGXVEYHI.js";
 import {
   DISTRIBUTED_FPS,
   HF_VFX_ATTR,
@@ -169,7 +169,7 @@ import {
   parseVfxChain,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -182,7 +182,7 @@ import {
   isTemplateEntry,
   parsesAsScript,
   prepareFlattenedInnerRoot
-} from "./chunk-WT4PYV2J.js";
+} from "./chunk-YALM6XN4.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -210,7 +210,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-GMNHAOMJ.js";
+} from "./chunk-R2SQBPMH.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-UJKQWGFF.js";
@@ -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-VQ5UBMXY.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,
@@ -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;
       }
@@ -15361,7 +15463,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-4UYM2K3S.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -17024,7 +17126,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-4UYM2K3S.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -18266,6 +18368,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 +18610,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;

package/dist/{chunk-NZ3BE2QE.js → chunk-3QVMJ7GX.js}

@@ -19,7 +19,7 @@ import {
   splitElementInHtml,
   unwrapElementsFromHtml,
   wrapElementsInHtml
-} from "./chunk-EVAQPW6O.js";
+} from "./chunk-ZRHO6YMM.js";
 import {
   MEDIA_LINK_ATTR,
   relinkSplitHalves
@@ -68,7 +68,7 @@ import {
   scanProjectMediaCodecMap,
   shouldPrewarmProxy,
   waitForProxy
-} from "./chunk-GPE3WWTO.js";
+} from "./chunk-SN7KI5JA.js";
 import {
   STUDIO_MOTION_PATH,
   createStudioMotionRenderBodyScript,
@@ -109,12 +109,12 @@ import {
   motionPathPluginUrl,
   parseFps,
   parsePreviewProxyBox
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   addScenePartsManifest,
   ensureHfIds,
   stampHfIdsInPlace
-} from "./chunk-WT4PYV2J.js";
+} from "./chunk-YALM6XN4.js";
 import {
   AFTER_FONTS_SCRIPT_TYPE,
   RUNTIME_BOOTSTRAP_ATTR,
@@ -128,7 +128,7 @@ import {
   resolveRateSpec,
   sourceTimeAt,
   stripEmbeddedRuntimeScripts
-} from "./chunk-GMNHAOMJ.js";
+} from "./chunk-R2SQBPMH.js";
 import {
   HTML_ATTRIBUTE_ENTITIES,
   MagicString,
@@ -306,7 +306,7 @@ function clearElementScreenshotIsolation() {
   page.__hfThumbnailFaded = [];
 }
 
-// ../studio-server/dist/chunk-436CO7P5.js
+// ../studio-server/dist/chunk-T5CGF7VZ.js
 import { resolve } from "path";
 function isAutoProxyEnabled(adapter) {
   return adapter.autoProxy !== false;
@@ -5499,7 +5499,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-WRDLWRMS.js");
+    const { GSAP_CDN } = await import("./dist-DYS24AMA.js");
     const bootstrap = [
       `<script src="${GSAP_CDN}"></script>`,
       "<script>",

package/dist/{chunk-3Q47QC46.js → chunk-3TXNNBI2.js}

@@ -19,7 +19,7 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   extractCompositionMetadata
 } from "./chunk-YMS5FOMC.js";

package/dist/{chunk-Z4R35NJS.js → chunk-4KKKBEP3.js}

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

package/dist/{chunk-RZXUQR42.js → chunk-4N4P3ZWL.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.183" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.183" : "0.0.0-dev";
+var VERSION = true ? "0.8.184" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.184" : "0.0.0-dev";
 
 export {
   VERSION,

package/dist/{chunk-J4L5TPLS.js → chunk-5UDRPPN2.js}

@@ -10,12 +10,21 @@ import {
 
 // src/cloud/upload.ts
 import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { pipeline } from "stream/promises";
 var COMPLETE_MAX_RETRIES = 5;
 var COMPLETE_RETRY_BASE_MS = 500;
 var CONTENT_TYPE_ZIP = "application/zip";
 function sha256Hex(bytes) {
   return createHash("sha256").update(bytes).digest("hex");
 }
+async function sha256OfFile(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -27,15 +36,16 @@ function normalizeUploadHeaders(raw) {
   }
   return out;
 }
-async function putBytesToPresignedUrl(fetchImpl, uploadUrl, uploadHeaders, bytes, contentType) {
+async function putBytesToPresignedUrl(fetchImpl, uploadUrl, uploadHeaders, body, contentType) {
   const headers = {
     "content-type": contentType,
     ...normalizeUploadHeaders(uploadHeaders)
   };
+  if (!(body instanceof Uint8Array)) return putFileToPresignedUrl(uploadUrl, headers, body);
   const res = await fetchImpl(uploadUrl, {
     method: "PUT",
     headers,
-    body: bytes
+    body
   });
   if (!res.ok) {
     const detail = await res.text().catch(() => "");
@@ -44,6 +54,36 @@ async function putBytesToPresignedUrl(fetchImpl, uploadUrl, uploadHeaders, bytes
     );
   }
 }
+async function putFileToPresignedUrl(uploadUrl, headers, file) {
+  const send = new URL(uploadUrl).protocol === "https:" ? httpsRequest : httpRequest;
+  const req = send(uploadUrl, {
+    method: "PUT",
+    headers: { ...headers, "content-length": String(file.size) }
+  });
+  const response = new Promise((resolve, reject) => {
+    req.once("response", resolve).once("error", reject);
+  });
+  const sent = pipeline(createReadStream(file.path), req);
+  let res;
+  try {
+    res = await response;
+  } catch (err) {
+    await sent.catch(() => void 0);
+    throw err;
+  }
+  const status = res.statusCode ?? 0;
+  const ok = status >= 200 && status < 300;
+  await sent.catch((err) => {
+    if (ok) throw err;
+  });
+  let detail = "";
+  for await (const chunk of res) detail += String(chunk);
+  if (!ok) {
+    throw new Error(
+      `Direct upload PUT failed: ${status} ${res.statusMessage ?? ""}${detail ? ` \u2014 ${detail.slice(0, 300)}` : ""}`
+    );
+  }
+}
 async function completeWithRetry(client, asset_id, checksum_sha256) {
   let lastErr;
   for (let attempt = 0; attempt < COMPLETE_MAX_RETRIES; attempt++) {
@@ -65,9 +105,10 @@ async function completeWithRetry(client, asset_id, checksum_sha256) {
 }
 async function uploadAssetViaDirectUpload(opts) {
   const start = Date.now();
-  const { bytes, filename, idempotencyKey } = opts;
-  const size_bytes = bytes.byteLength;
-  const checksum_sha256 = sha256Hex(bytes);
+  const { filename, idempotencyKey } = opts;
+  const body = "bytes" in opts ? opts.bytes : { path: opts.path, size: opts.size };
+  const size_bytes = body instanceof Uint8Array ? body.byteLength : body.size;
+  const checksum_sha256 = body instanceof Uint8Array ? sha256Hex(body) : await sha256OfFile(body.path);
   const fetchImpl = opts.fetchImpl ?? fetch;
   opts.onProgress?.({ phase: "initialize" });
   const initialize = await opts.client.createAssetUpload({
@@ -79,7 +120,7 @@ async function uploadAssetViaDirectUpload(opts) {
     fetchImpl,
     initialize.upload_url,
     initialize.upload_headers,
-    bytes,
+    body,
     opts.contentType
   );
   opts.onProgress?.({ phase: "upload", percent: 100 });
@@ -87,6 +128,7 @@ async function uploadAssetViaDirectUpload(opts) {
   const completed = await completeWithRetry(opts.client, initialize.asset_id, checksum_sha256);
   return {
     asset_id: completed.asset_id,
+    url: completed.url,
     size_bytes,
     duration_ms: Date.now() - start
   };

package/dist/{chunk-XJHKJXT4.js → chunk-74JMKLVU.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-AWDFDFI3.js";
 import {
   isBlockedNetworkHost
-} from "./chunk-73LTCCZI.js";
+} from "./chunk-RGXVEYHI.js";
 import {
   DOMParser,
   parseHTML

package/dist/{chunk-OH56PXFH.js → chunk-7HJALUIO.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-RGXVEYHI.js";
 import {
   runCancellableProcess
 } from "./chunk-DYAPHNV6.js";

package/dist/{chunk-BP4VNTZL.js → chunk-7MB2ZAQF.js}

@@ -27,7 +27,7 @@ import {
 } from "./chunk-GMECXFAN.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-HLBODNGW.js → chunk-7NRI7HYX.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   sherpaParakeetInstalled,
   sherpaUnsupportedReason
-} from "./chunk-IC2WYONA.js";
+} from "./chunk-R2BFTECP.js";
 import {
   findParakeet
 } from "./chunk-JZIEZCQM.js";

package/dist/{chunk-ANR6WOC3.js → chunk-ABZYYUUH.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-ISN5GRYI.js";
 import {
   VERSION
-} from "./chunk-RZXUQR42.js";
+} from "./chunk-4N4P3ZWL.js";
 
 // src/utils/updateCheck.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-VH5KESLX.js → chunk-BCHSTE7U.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-Z5H5N5T4.js");
+  return await import("./src-6MSC62U2.js");
 }
 
 export {

package/dist/{chunk-KRFAX5JK.js → chunk-CXABAXB3.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   shouldTrack
-} from "./chunk-DEORFAWP.js";
+} from "./chunk-UKOTVJFV.js";
 
 // src/telemetry/renderObservability.ts
 function renderObservabilityTelemetryPayload(observability) {

package/dist/{chunk-LBWRQ4XA.js → chunk-DWUGKEHR.js}

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

package/dist/{chunk-MIZDJVPZ.js → chunk-E32ZQ2WO.js}

@@ -11,7 +11,7 @@ import {
   distroLabel,
   getFFmpegInstallHint,
   parseLddMissingLibs
-} from "./chunk-OH56PXFH.js";
+} from "./chunk-7HJALUIO.js";
 import {
   ensureBrowser,
   findBrowser