@hyperframes/studio-server 0.8.198 → 0.8.200

package/dist/{chunk-N2HH4SGD.js → chunk-URMIRXBS.js}

@@ -22,7 +22,7 @@ import {
   utimesSync,
   writeFileSync
 } from "fs";
-import { tmpdir } from "os";
+import { availableParallelism, tmpdir } from "os";
 import { basename, dirname, extname as extname2, isAbsolute, join as join2, relative, resolve, sep } from "path";
 import {
   formatPreviewProxyBox,
@@ -144,7 +144,7 @@ function cleanupProxyCache(cacheDir, options = {}) {
 }
 
 // src/helpers/proxyTranscoder.ts
-var PROXY_PARAMS_VERSION = "v5";
+var PROXY_PARAMS_VERSION = "v6";
 var CACHE_DIR_NAME = ".transcode-cache";
 function boundedEnvInteger(name, fallback, min, max) {
   const raw = process.env[name]?.trim();
@@ -155,8 +155,13 @@ function boundedEnvInteger(name, fallback, min, max) {
 var MAX_CONCURRENT_TRANSCODES = boundedEnvInteger("HYPERFRAMES_PROXY_MAX_CONCURRENCY", 2, 1, 16);
 var MAX_QUEUED_TRANSCODES = boundedEnvInteger("HYPERFRAMES_PROXY_MAX_QUEUE", 8, 0, 256);
 var STDERR_TAIL_MAX_CHARS = 4e3;
-var TRANSCODE_TIMEOUT_MS = 15 * 60 * 1e3;
-var PROXY_CHUNK_SECONDS = 60;
+var TRANSCODE_STALL_MS = boundedEnvInteger(
+  "HYPERFRAMES_PROXY_STALL_MS",
+  3 * 60 * 1e3,
+  1e4,
+  60 * 60 * 1e3
+);
+var PROXY_CHUNK_SECONDS = 15;
 var CHUNK_PREFIX = ".part-";
 var CONCAT_TIMEOUT_MS = 2 * 60 * 1e3;
 var FAILURE_CACHE_TTL_MS = 60 * 1e3;
@@ -265,6 +270,10 @@ function getProxyCachePath(projectDir, absoluteSourcePath, variant = "h264", box
     box
   );
 }
+function reportProgress(job, progress) {
+  job.lastProgress = progress;
+  for (const listener of job.progress) listener(progress);
+}
 var ProxyDroppedError = class extends ProxyTranscodeError {
   constructor() {
     super("media proxy copy dropped: every caller left", null, "");
@@ -386,11 +395,15 @@ function rememberFailure(cachePath, error) {
 function clearFailedTranscodesForTest() {
   failedTranscodes.clear();
 }
-function proxyScaleFilter(box) {
-  if (!box) return "scale=trunc(iw/2)*2:trunc(ih/2)*2";
+function proxyScaleSize(box) {
+  if (!box) return { width: "trunc(iw/2)*2", height: "trunc(ih/2)*2" };
   const factor = `min(1\\,max(${box.width}/iw\\,${box.height}/ih))`;
   const side = (d) => `min(trunc(${d}/2)*2\\,ceil(${d}*${factor}/2)*2)`;
-  return `scale=${side("iw")}:${side("ih")}`;
+  return { width: side("iw"), height: side("ih") };
+}
+function proxyScaleFilter(box) {
+  const { width, height } = proxyScaleSize(box);
+  return `scale=${width}:${height}`;
 }
 var STDERR_ERROR_LINE = /error|invalid|denied|no space|not found|unknown/i;
 function stderrReason(stderrTail) {
@@ -407,26 +420,24 @@ function chunkRanges(durationSeconds) {
     lengthSeconds: index === count - 1 ? durationSeconds - index * PROXY_CHUNK_SECONDS : PROXY_CHUNK_SECONDS
   }));
 }
-function ffmpegBudgetError(chunksKept, chunkCount) {
-  return new ProxyTranscodeError(
-    `ffmpeg ran out of its ${TRANSCODE_TIMEOUT_MS}ms budget with ${chunksKept}/${chunkCount} pieces done; the finished pieces are kept and the next attempt continues from them`,
-    null,
-    ""
-  );
-}
-async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat) {
+async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat, onDone = () => {
+}) {
   const extension = extname2(tempPath);
-  const deadline = Date.now() + TRANSCODE_TIMEOUT_MS;
   const pieces = ranges.map((_, index) => `${chunkPrefix}${index}${extension}`);
+  let doneSeconds = 0;
+  for (const [index, range] of ranges.entries()) {
+    if (existsSync2(pieces[index])) doneSeconds += range.lengthSeconds;
+  }
+  if (doneSeconds) onDone(doneSeconds);
   for (const [index, range] of ranges.entries()) {
     const piece = pieces[index];
     if (existsSync2(piece)) continue;
-    const timeoutMs = deadline - Date.now();
-    if (timeoutMs <= 0) throw ffmpegBudgetError(index, ranges.length);
     const pieceTemp = join2(dirname(piece), `.tmp-${randomUUID()}-${basename(piece)}`);
     try {
-      await encode(pieceTemp, timeoutMs, range);
+      await encode(pieceTemp, range);
       renameSync(pieceTemp, piece);
+      doneSeconds += range.lengthSeconds;
+      onDone(doneSeconds);
     } finally {
       if (existsSync2(pieceTemp)) unlinkSync2(pieceTemp);
     }
@@ -467,6 +478,7 @@ var H264_ARGS = [
   "-movflags",
   "+faststart"
 ];
+var VP8_THREADS = String(Math.min(4, availableParallelism()));
 var VP8_ARGS = [
   "-c:v",
   "libvpx",
@@ -486,6 +498,8 @@ var VP8_ARGS = [
   "bt709",
   "-cpu-used",
   "4",
+  "-threads",
+  VP8_THREADS,
   "-auto-alt-ref",
   "0",
   "-metadata:s:v:0",
@@ -503,12 +517,12 @@ async function buildVideoFilter(ffmpegPath, sourcePath, metadata, keepsAlpha, bo
   const evenScale = proxyScaleFilter(box);
   const pixelFormat = keepsAlpha ? "yuva420p" : "yuv420p";
   return toneMap ? [
-    hdrToSdrToneMapFilter(metadata.color, firstFrame),
+    hdrToSdrToneMapFilter(metadata.color, firstFrame, box && proxyScaleSize(box)),
     `${evenScale}:out_color_matrix=bt709:out_range=tv`,
     `format=${pixelFormat}`
   ].join(",") : [evenScale, `format=${pixelFormat}`].join(",");
 }
-async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, signal) {
+async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, signal, onProgress) {
   const metadata = await probeMediaMetadata(sourcePath);
   const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
   if (!ffmpegPath) {
@@ -518,10 +532,14 @@ async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, sign
   const videoFilter = await buildVideoFilter(ffmpegPath, sourcePath, metadata, keepsAlpha, box);
   const alphaDecoder = keepsAlpha ? alphaDecoderFor(metadata.color.codecName) : null;
   const decoderArgs = alphaDecoder ? ["-c:v", alphaDecoder] : [];
-  const encode = (target, timeoutMs, range) => spawnFfmpeg(
+  const totalSeconds = metadata.durationSeconds;
+  const encode = (target, range) => spawnFfmpeg(
     ffmpegPath,
     [
       "-y",
+      "-progress",
+      "pipe:1",
+      "-nostats",
       ...range ? ["-ss", String(range.startSeconds)] : [],
       ...decoderArgs,
       "-i",
@@ -532,17 +550,19 @@ async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, sign
       ...variant === "vp8" ? VP8_ARGS : H264_ARGS,
       target
     ],
-    timeoutMs,
-    signal
+    TRANSCODE_STALL_MS,
+    signal,
+    (encodedSeconds) => onProgress({ doneSeconds: (range?.startSeconds ?? 0) + encodedSeconds, totalSeconds })
   );
-  const ranges = chunkRanges(metadata.durationSeconds);
-  if (!ranges) return encode(outputPath, TRANSCODE_TIMEOUT_MS);
+  const ranges = chunkRanges(totalSeconds);
+  if (!ranges) return encode(outputPath);
   await encodeInChunks(
     ranges,
     chunkPrefix,
     outputPath,
     encode,
-    (listPath, target) => spawnFfmpeg(ffmpegPath, concatArgs(listPath, target, variant), CONCAT_TIMEOUT_MS, signal)
+    (listPath, target) => spawnFfmpeg(ffmpegPath, concatArgs(listPath, target, variant), CONCAT_TIMEOUT_MS, signal),
+    (doneSeconds) => onProgress({ doneSeconds, totalSeconds })
   );
 }
 function concatArgs(listPath, target, variant) {
@@ -560,35 +580,67 @@ function concatArgs(listPath, target, variant) {
     target
   ];
 }
-function spawnFfmpeg(ffmpegPath, args, timeoutMs, signal) {
+var OUT_TIME = /^out_time_(?:us|ms)=(\d+)$/;
+function spawnFfmpeg(ffmpegPath, args, stallMs, signal, onProgress) {
   return new Promise((resolvePromise, reject) => {
     signal.throwIfAborted();
     const proc = spawn(ffmpegPath, args, {
-      stdio: ["ignore", "ignore", "pipe"],
-      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "pipe"],
       killSignal: "SIGKILL",
       signal,
       windowsHide: true
     });
+    let stalled = false;
+    let timer;
+    const armStall = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stalled = true;
+        proc.kill("SIGKILL");
+      }, stallMs);
+      timer.unref();
+    };
+    armStall();
+    let furthest = 0;
+    let lineTail = "";
+    proc.stdout?.on("data", (chunk) => {
+      const lines = (lineTail + chunk.toString()).split("\n");
+      lineTail = lines.pop() ?? "";
+      for (const line of lines) {
+        const reached = OUT_TIME.exec(line.trim());
+        if (!reached) continue;
+        const seconds = Number(reached[1]) / 1e6;
+        if (seconds <= furthest) continue;
+        furthest = seconds;
+        armStall();
+        onProgress?.(seconds);
+      }
+    });
     let stderrTail = "";
     proc.stderr?.on("data", (chunk) => {
       stderrTail = (stderrTail + chunk.toString()).slice(-STDERR_TAIL_MAX_CHARS);
     });
     proc.on("error", (err) => {
+      clearTimeout(timer);
       if (signal.aborted) return;
       reject(new FfmpegUnavailableError(`failed to spawn ffmpeg: ${err.message}`, stderrTail));
     });
-    proc.on("close", (code, signal2) => {
+    proc.on("close", (code, killedBy) => {
+      clearTimeout(timer);
       if (code === 0) {
         resolvePromise();
-      } else if (signal2) {
+      } else if (stalled) {
         reject(
           new ProxyTranscodeError(
-            `ffmpeg killed by ${signal2} (timeout ${timeoutMs}ms or external kill)`,
+            `ffmpeg made no progress for ${Math.round(stallMs / 1e3)}s and was ended; finished pieces are kept for the next attempt`,
             null,
             stderrTail
           )
         );
+      } else if (killedBy) {
+        reject(
+          new ProxyTranscodeError(`ffmpeg killed by ${killedBy} (external kill)`, null, stderrTail)
+        );
       } else {
         reject(
           new ProxyTranscodeError(
@@ -619,7 +671,8 @@ async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath,
         chunkPrefix,
         variant,
         box,
-        job.abandoned.signal
+        job.abandoned.signal,
+        (progress) => reportProgress(job, progress)
       );
       renameSync(tempPath, cachePath);
       maintainProxyCache(cacheDir);
@@ -662,7 +715,8 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", bo
       cachePath,
       priority: options.priority === true,
       callers: 0,
-      abandoned: new AbortController()
+      abandoned: new AbortController(),
+      progress: /* @__PURE__ */ new Set()
     };
     const promise = transcodeToCache(
       job,
@@ -684,10 +738,19 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", bo
     inFlight.set(cachePath, entry);
   }
   if (options.priority) prioritize(entry.job);
-  return joinJob(entry.promise, entry.job, options.signal);
+  const listener = options.onProgress;
+  const joined = joinJob(entry.promise, entry.job, options.signal);
+  if (listener) {
+    entry.job.progress.add(listener);
+    if (entry.job.lastProgress) listener(entry.job.lastProgress);
+    const stop = () => void entry.job.progress.delete(listener);
+    joined.then(stop, stop);
+  }
+  return joined;
 }
 async function resolveProxies(projectDir, sources, onSettled = () => {
-}) {
+}, onProgress = () => {
+}, signal) {
   const first = sources[0];
   if (first) {
     maintainProxyCache(
@@ -703,14 +766,14 @@ async function resolveProxies(projectDir, sources, onSettled = () => {
   const worker = async () => {
     for (let index = next++; index < sources.length; index = next++) {
       const { sourcePath, variant, box } = sources[index];
-      results[index] = await waitForProxy(
-        resolveProxy(projectDir, sourcePath, variant, box),
-        TRANSCODE_TIMEOUT_MS
-      ).then(
+      results[index] = await resolveProxy(projectDir, sourcePath, variant, box, {
+        onProgress: (progress) => onProgress(index, progress),
+        signal
+      }).then(
         (value) => ({ status: "fulfilled", value }),
         (reason) => ({ status: "rejected", reason })
       );
-      onSettled();
+      onSettled(index);
     }
   };
   const workers = Math.min(MAX_CONCURRENT_TRANSCODES, sources.length);
@@ -734,7 +797,8 @@ export {
   cleanupProxyCache,
   PROXY_PARAMS_VERSION,
   CACHE_DIR_NAME,
-  TRANSCODE_TIMEOUT_MS,
+  TRANSCODE_STALL_MS,
+  PROXY_CHUNK_SECONDS,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
   DEFAULT_PROXY_WAIT_TIMEOUT_MS,
   ProxyTranscodeError,

package/dist/{chunk-HTHV7ZM6.js → chunk-ZCCJNXS7.js}

@@ -1,7 +1,7 @@
 import {
   PROXY_PARAMS_VERSION,
   resolveProxy
-} from "./chunk-N2HH4SGD.js";
+} from "./chunk-URMIRXBS.js";
 import {
   createMediaCodecProbeCache,
   proxyVariantFor,

package/dist/helpers/mediaProxyPreview.js

@@ -4,8 +4,8 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "../chunk-HTHV7ZM6.js";
-import "../chunk-N2HH4SGD.js";
+} from "../chunk-ZCCJNXS7.js";
+import "../chunk-URMIRXBS.js";
 import "../chunk-XMNHDWQI.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";

package/dist/helpers/proxyTranscoder.d.ts

@@ -11,9 +11,12 @@ import { ProxyVariant } from './mediaCodecMap.js';
  * caller's `signal` detaches that caller; once no caller is left, the copy is
  * dropped from the queue or its ffmpeg is killed.
  */
-declare const PROXY_PARAMS_VERSION = "v5";
+declare const PROXY_PARAMS_VERSION = "v6";
 declare const CACHE_DIR_NAME = ".transcode-cache";
-declare const TRANSCODE_TIMEOUT_MS: number;
+/** A copy that makes no progress this long is ended: a hung encode, not a slow one. */
+declare const TRANSCODE_STALL_MS: number;
+/** A longer source is copied in pieces this long; a stopped copy keeps its finished pieces and loses at most one. */
+declare const PROXY_CHUNK_SECONDS = 15;
 declare const PROXY_PENDING_RETRY_AFTER_SECONDS = 2;
 declare const DEFAULT_PROXY_WAIT_TIMEOUT_MS: number;
 declare class ProxyTranscodeError extends Error {
@@ -48,6 +51,11 @@ declare function waitForProxy<T>(promise: Promise<T>, timeoutMs?: number): Promi
  * preview box (`hf-proxy-box`) to name a boxed copy.
  */
 declare function getProxyCachePath(projectDir: string, absoluteSourcePath: string, variant?: ProxyVariant, box?: PreviewProxyBox): string;
+/** How far a copy has got: seconds of the source done, out of its length when that is known. */
+interface ProxyProgress {
+    doneSeconds: number;
+    totalSeconds?: number;
+}
 /** Test hook: forget remembered transcode failures (module state persists
  * across tests that don't reload the module). */
 declare function clearFailedTranscodesForTest(): void;
@@ -67,15 +75,18 @@ declare function proxyActivityMark(projectDir: string): string | null;
  */
 declare function resolveProxy(projectDir: string, absoluteSourcePath: string, variant?: ProxyVariant, box?: PreviewProxyBox, options?: ResolveProxyOptions): Promise<string>;
 /** Batch resolve for check and publish: at most MAX_CONCURRENT_TRANSCODES of its own requests in
- * flight (other callers can still fill the queue); each waits at most TRANSCODE_TIMEOUT_MS. */
+ * flight (other callers can still fill the queue). A copy is ended only when it stops making
+ * progress (TRANSCODE_STALL_MS), so a long source that keeps moving is never cut by a clock. */
 declare function resolveProxies(projectDir: string, sources: ReadonlyArray<{
     sourcePath: string;
     variant: ProxyVariant;
     box?: PreviewProxyBox;
-}>, onSettled?: () => void): Promise<PromiseSettledResult<string>[]>;
+}>, onSettled?: (index: number) => void, onProgress?: (index: number, progress: ProxyProgress) => void, signal?: AbortSignal): Promise<PromiseSettledResult<string>[]>;
 interface ResolveProxyOptions {
     priority?: boolean;
     signal?: AbortSignal;
+    /** Hears how far the shared copy has got, from the first caller's start to the copy's end. */
+    onProgress?: (progress: ProxyProgress) => void;
 }
 
-export { CACHE_DIR_NAME, DEFAULT_PROXY_WAIT_TIMEOUT_MS, FfmpegMissingFilterError, FfmpegUnavailableError, PROXY_PARAMS_VERSION, PROXY_PENDING_RETRY_AFTER_SECONDS, ProxyCapacityError, ProxySourceOutsideProjectError, ProxyTranscodeError, ProxyWaitTimeoutError, type ResolveProxyOptions, TRANSCODE_TIMEOUT_MS, clearFailedTranscodesForTest, getProxyCachePath, proxyActivityMark, resolveProxies, resolveProxy, waitForProxy };
+export { CACHE_DIR_NAME, DEFAULT_PROXY_WAIT_TIMEOUT_MS, FfmpegMissingFilterError, FfmpegUnavailableError, PROXY_CHUNK_SECONDS, PROXY_PARAMS_VERSION, PROXY_PENDING_RETRY_AFTER_SECONDS, ProxyCapacityError, type ProxyProgress, ProxySourceOutsideProjectError, ProxyTranscodeError, ProxyWaitTimeoutError, type ResolveProxyOptions, TRANSCODE_STALL_MS, clearFailedTranscodesForTest, getProxyCachePath, proxyActivityMark, resolveProxies, resolveProxy, waitForProxy };

package/dist/helpers/proxyTranscoder.js

@@ -3,20 +3,21 @@ import {
   DEFAULT_PROXY_WAIT_TIMEOUT_MS,
   FfmpegMissingFilterError,
   FfmpegUnavailableError,
+  PROXY_CHUNK_SECONDS,
   PROXY_PARAMS_VERSION,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
   ProxyCapacityError,
   ProxySourceOutsideProjectError,
   ProxyTranscodeError,
   ProxyWaitTimeoutError,
-  TRANSCODE_TIMEOUT_MS,
+  TRANSCODE_STALL_MS,
   clearFailedTranscodesForTest,
   getProxyCachePath,
   proxyActivityMark,
   resolveProxies,
   resolveProxy,
   waitForProxy
-} from "../chunk-N2HH4SGD.js";
+} from "../chunk-URMIRXBS.js";
 import "../chunk-XMNHDWQI.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
@@ -26,13 +27,14 @@ export {
   DEFAULT_PROXY_WAIT_TIMEOUT_MS,
   FfmpegMissingFilterError,
   FfmpegUnavailableError,
+  PROXY_CHUNK_SECONDS,
   PROXY_PARAMS_VERSION,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
   ProxyCapacityError,
   ProxySourceOutsideProjectError,
   ProxyTranscodeError,
   ProxyWaitTimeoutError,
-  TRANSCODE_TIMEOUT_MS,
+  TRANSCODE_STALL_MS,
   clearFailedTranscodesForTest,
   getProxyCachePath,
   proxyActivityMark,

package/dist/index.js

@@ -82,7 +82,7 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "./chunk-HTHV7ZM6.js";
+} from "./chunk-ZCCJNXS7.js";
 import {
   CACHE_DIR_NAME,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
@@ -93,7 +93,7 @@ import {
   proxyActivityMark,
   resolveProxy,
   waitForProxy
-} from "./chunk-N2HH4SGD.js";
+} from "./chunk-URMIRXBS.js";
 import {
   PROXY_VARIANT_CONFIG,
   decideMediaProxyEligibility,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/studio-server",
-  "version": "0.8.198",
+  "version": "0.8.200",
   "repository": {
     "type": "git",
     "url": "https://github.com/heygen-com/hyperframes",
@@ -84,8 +84,8 @@
     "linkedom": "^0.18.12",
     "postcss": "^8.5.8",
     "postcss-selector-parser": "^7.1.2",
-    "@hyperframes/parsers": "0.8.198",
-    "@hyperframes/core": "0.8.198"
+    "@hyperframes/core": "0.8.200",
+    "@hyperframes/parsers": "0.8.200"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",