hyperframes 0.8.188 → 0.8.190

package/dist/{chunk-LWYZN7HS.js → chunk-BT64TTSE.js}

@@ -13,7 +13,7 @@ import {
   formatPreviewProxyBox,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-56IOFIYB.js";
 import {
   decodeAuthoredAttribute,
   scanHtmlOpeningTags
@@ -36,7 +36,7 @@ import {
   rewriteAssetPath
 } from "./chunk-BSQ7XANM.js";
 
-// ../studio-server/dist/chunk-OVOXGASQ.js
+// ../studio-server/dist/chunk-XMNHDWQI.js
 import { statSync } from "fs";
 import { sep } from "path";
 import { execFile } from "child_process";
@@ -139,7 +139,7 @@ async function probeMediaMetadata(filePath, runner = execFileRunner) {
       "-v",
       "error",
       "-show_entries",
-      "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample:stream_disposition=attached_pic:stream_tags=alpha_mode",
+      "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample:stream_disposition=attached_pic:stream_tags=alpha_mode:format=duration",
       "-of",
       "json",
       "--",
@@ -163,6 +163,8 @@ async function probeMediaMetadata(filePath, runner = execFileRunner) {
     if (kind === "video") {
       metadata.hasAudio = (parsed.streams ?? []).some((item) => item.codec_type === "audio");
       metadata.hasAlpha = stream !== void 0 && videoStreamHasAlpha(stream);
+      const duration = Number(parsed.format?.duration);
+      if (Number.isFinite(duration) && duration > 0) metadata.durationSeconds = duration;
     }
     return metadata;
   } catch {
@@ -338,13 +340,23 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
   return map;
 }
 
-// ../studio-server/dist/chunk-25IT6FMR.js
+// ../studio-server/dist/chunk-N2HH4SGD.js
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync2, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, utimesSync } from "fs";
-import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep as sep2 } from "path";
+import {
+  existsSync as existsSync2,
+  mkdtempSync,
+  renameSync,
+  rmSync,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  utimesSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, extname as extname2, isAbsolute, join as join2, relative, resolve, sep as sep2 } from "path";
 import { existsSync, readdirSync, statSync as statSync3, unlinkSync } from "fs";
-import { extname as extname2, join } from "path";
+import { extname as extname3, join } from "path";
 var DEFAULT_MAX_BYTES = 10 * 1024 * 1024 * 1024;
 var DEFAULT_STALE_TEMP_MS = 60 * 60 * 1e3;
 var DEFAULT_MIN_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
@@ -352,7 +364,9 @@ var PROXY_EXTENSIONS = new Set(
   Object.values(PROXY_VARIANT_CONFIG).map(({ extension }) => extension)
 );
 var TRANSCODER_PROXY_NAME = /^[0-9a-f]{64}\.\w+$/;
-var TRANSCODER_TEMP_NAME = /^\.tmp-[0-9a-f-]{36}-[0-9a-f]{64}\.\w+$/;
+var TRANSCODER_TEMP_NAME = /^\.tmp-[0-9a-f-]{36}-(?:\.part-[0-9a-f]{64}-\d+|[0-9a-f]{64})\.\w+$/;
+var TRANSCODER_PIECE_NAME = /^\.part-([0-9a-f]{64})-\d+(\.\w+)$/;
+var STALE_PIECE_MS = 60 * 60 * 1e3;
 var lastSweepAt = /* @__PURE__ */ new Map();
 function positiveEnvNumber(name, fallback) {
   const parsed = Number(process.env[name]);
@@ -375,6 +389,15 @@ function shouldSkipSweep(cacheDir, now, minSweepIntervalMs) {
   lastSweepAt.set(cacheDir, now);
   return false;
 }
+function isLeftoverName(name) {
+  return TRANSCODER_TEMP_NAME.test(name) || TRANSCODER_PIECE_NAME.test(name);
+}
+function leftoverIsDead(cacheDir, name, modifiedAt, protectedPaths, now, staleTempMs) {
+  const piece = TRANSCODER_PIECE_NAME.exec(name);
+  if (!piece) return now - modifiedAt >= staleTempMs;
+  const copyIsRunning = protectedPaths.has(join(cacheDir, `${piece[1]}${piece[2]}`));
+  return !copyIsRunning && now - modifiedAt >= STALE_PIECE_MS;
+}
 function readCacheInventory(cacheDir, protectedPaths, now, staleTempMs) {
   const entries = [];
   const staleTemps = [];
@@ -388,9 +411,11 @@ function readCacheInventory(cacheDir, protectedPaths, now, staleTempMs) {
       modifiedAt: stat.mtimeMs,
       protected: protectedPaths.has(path)
     };
-    if (TRANSCODER_TEMP_NAME.test(dirent.name)) {
-      if (now - stat.mtimeMs >= staleTempMs) staleTemps.push(entry);
-    } else if (TRANSCODER_PROXY_NAME.test(dirent.name) && PROXY_EXTENSIONS.has(extname2(dirent.name))) {
+    if (isLeftoverName(dirent.name)) {
+      if (leftoverIsDead(cacheDir, dirent.name, stat.mtimeMs, protectedPaths, now, staleTempMs)) {
+        staleTemps.push(entry);
+      }
+    } else if (TRANSCODER_PROXY_NAME.test(dirent.name) && PROXY_EXTENSIONS.has(extname3(dirent.name))) {
       entries.push(entry);
     }
   }
@@ -452,11 +477,15 @@ var MAX_CONCURRENT_TRANSCODES = boundedEnvInteger("HYPERFRAMES_PROXY_MAX_CONCURR
 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 CHUNK_PREFIX = ".part-";
+var CONCAT_TIMEOUT_MS = 2 * 60 * 1e3;
 var FAILURE_CACHE_TTL_MS = 60 * 1e3;
 var PROXY_PENDING_RETRY_AFTER_SECONDS = 2;
 var ENVIRONMENT_FAILURE_TTL_MS = 5 * PROXY_PENDING_RETRY_AFTER_SECONDS * 1e3;
 var MAX_FAILURE_CACHE_ENTRIES = 128;
 var DEFAULT_PROXY_WAIT_TIMEOUT_MS = 2 * 60 * 1e3;
+var UNTOUCHED_TEMP_IS_DEAD_MS = 10 * 60 * 1e3;
 var ProxyTranscodeError = class extends Error {
   exitCode;
   stderrTail;
@@ -624,9 +653,9 @@ var inFlight = /* @__PURE__ */ new Map();
 function forget(job) {
   if (inFlight.get(job.cachePath)?.job === job) inFlight.delete(job.cachePath);
 }
-function maintainProxyCache(cacheDir) {
+function maintainProxyCache(cacheDir, staleTempMs) {
   try {
-    cleanupProxyCache(cacheDir, { protectedPaths: new Set(inFlight.keys()) });
+    cleanupProxyCache(cacheDir, { protectedPaths: new Set(inFlight.keys()), staleTempMs });
   } catch (error) {
     console.warn(
       `[media-proxy] cache cleanup failed: ${error instanceof Error ? error.message : String(error)}`
@@ -688,83 +717,173 @@ function stderrReason(stderrTail) {
   const line = errorLines.at(-1) ?? lines.at(-1);
   return line ? `: ${line.replace(/[.!]+$/, "")}` : "";
 }
-async function runFfmpeg(sourcePath, outputPath, variant, box, signal) {
-  const metadata = await probeMediaMetadata(sourcePath);
-  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
-  if (!ffmpegPath) {
-    throw new FfmpegUnavailableError();
+function chunkRanges(durationSeconds) {
+  if (!durationSeconds || durationSeconds <= PROXY_CHUNK_SECONDS * 1.5) return null;
+  const count = Math.floor(durationSeconds / PROXY_CHUNK_SECONDS);
+  return Array.from({ length: count }, (_, index) => ({
+    startSeconds: index * PROXY_CHUNK_SECONDS,
+    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) {
+  const extension = extname2(tempPath);
+  const deadline = Date.now() + TRANSCODE_TIMEOUT_MS;
+  const pieces = ranges.map((_, index) => `${chunkPrefix}${index}${extension}`);
+  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);
+      renameSync(pieceTemp, piece);
+    } finally {
+      if (existsSync2(pieceTemp)) unlinkSync2(pieceTemp);
+    }
   }
-  const keepsAlpha = variant === "vp8";
+  const listDir = mkdtempSync(join2(tmpdir(), "hf-proxy-join-"));
+  try {
+    const listPath = join2(listDir, "pieces.txt");
+    writeFileSync(
+      listPath,
+      pieces.map((piece) => `file '${piece.replace(/\\/g, "/").replace(/'/g, "'\\''")}'
+`).join("")
+    );
+    await concat(listPath, tempPath);
+  } finally {
+    rmSync(listDir, { recursive: true, force: true });
+  }
+  for (const piece of pieces) if (existsSync2(piece)) unlinkSync2(piece);
+}
+var H264_ARGS = [
+  "-c:v",
+  "libx264",
+  "-profile:v",
+  "high",
+  "-pix_fmt",
+  "yuv420p",
+  "-colorspace",
+  "bt709",
+  "-color_primaries",
+  "bt709",
+  "-color_trc",
+  "bt709",
+  "-crf",
+  "18",
+  "-preset",
+  "veryfast",
+  "-c:a",
+  "aac",
+  "-movflags",
+  "+faststart"
+];
+var VP8_ARGS = [
+  "-c:v",
+  "libvpx",
+  "-b:v",
+  "0",
+  "-crf",
+  "23",
+  "-deadline",
+  "good",
+  "-pix_fmt",
+  "yuva420p",
+  "-colorspace",
+  "bt709",
+  "-color_primaries",
+  "bt709",
+  "-color_trc",
+  "bt709",
+  "-cpu-used",
+  "4",
+  "-auto-alt-ref",
+  "0",
+  "-metadata:s:v:0",
+  "alpha_mode=1",
+  "-ac",
+  "2",
+  "-c:a",
+  "libopus"
+];
+async function buildVideoFilter(ffmpegPath, sourcePath, metadata, keepsAlpha, box) {
   const { hdrTransfer } = metadata.color;
   const toneMap = (hdrTransfer === "pq" || hdrTransfer === "hlg") && !keepsAlpha;
   if (toneMap) await ensureHdrFilters(ffmpegPath);
   const firstFrame = toneMap ? await probeFirstFrameColour(sourcePath) : {};
   const evenScale = proxyScaleFilter(box);
   const pixelFormat = keepsAlpha ? "yuva420p" : "yuv420p";
-  const videoFilter = toneMap ? [
+  return toneMap ? [
     hdrToSdrToneMapFilter(metadata.color, firstFrame),
     `${evenScale}:out_color_matrix=bt709:out_range=tv`,
     `format=${pixelFormat}`
   ].join(",") : [evenScale, `format=${pixelFormat}`].join(",");
+}
+async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, signal) {
+  const metadata = await probeMediaMetadata(sourcePath);
+  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
+  if (!ffmpegPath) {
+    throw new FfmpegUnavailableError();
+  }
+  const keepsAlpha = variant === "vp8";
+  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(
+    ffmpegPath,
+    [
+      "-y",
+      ...range ? ["-ss", String(range.startSeconds)] : [],
+      ...decoderArgs,
+      "-i",
+      sourcePath,
+      ...range ? ["-t", String(range.lengthSeconds)] : [],
+      "-vf",
+      videoFilter,
+      ...variant === "vp8" ? VP8_ARGS : H264_ARGS,
+      target
+    ],
+    timeoutMs,
+    signal
+  );
+  const ranges = chunkRanges(metadata.durationSeconds);
+  if (!ranges) return encode(outputPath, TRANSCODE_TIMEOUT_MS);
+  await encodeInChunks(
+    ranges,
+    chunkPrefix,
+    outputPath,
+    encode,
+    (listPath, target) => spawnFfmpeg(ffmpegPath, concatArgs(listPath, target, variant), CONCAT_TIMEOUT_MS, signal)
+  );
+}
+function concatArgs(listPath, target, variant) {
+  return [
+    "-y",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    listPath,
+    "-c",
+    "copy",
+    ...variant === "h264" ? ["-movflags", "+faststart"] : [],
+    target
+  ];
+}
+function spawnFfmpeg(ffmpegPath, args, timeoutMs, signal) {
   return new Promise((resolvePromise, reject) => {
-    const alphaDecoder = keepsAlpha ? alphaDecoderFor(metadata.color.codecName) : null;
-    const decoderArgs = alphaDecoder ? ["-c:v", alphaDecoder] : [];
-    const commonArgs = ["-y", ...decoderArgs, "-i", sourcePath, "-vf", videoFilter];
-    const h264Args = [
-      "-c:v",
-      "libx264",
-      "-profile:v",
-      "high",
-      "-pix_fmt",
-      "yuv420p",
-      "-colorspace",
-      "bt709",
-      "-color_primaries",
-      "bt709",
-      "-color_trc",
-      "bt709",
-      "-crf",
-      "18",
-      "-preset",
-      "veryfast",
-      "-c:a",
-      "aac",
-      "-movflags",
-      "+faststart"
-    ];
-    const vp8Args = [
-      "-c:v",
-      "libvpx",
-      "-b:v",
-      "0",
-      "-crf",
-      "23",
-      "-deadline",
-      "good",
-      "-pix_fmt",
-      "yuva420p",
-      "-colorspace",
-      "bt709",
-      "-color_primaries",
-      "bt709",
-      "-color_trc",
-      "bt709",
-      "-cpu-used",
-      "4",
-      "-auto-alt-ref",
-      "0",
-      "-metadata:s:v:0",
-      "alpha_mode=1",
-      "-ac",
-      "2",
-      "-c:a",
-      "libopus"
-    ];
-    const args = [...commonArgs, ...variant === "vp8" ? vp8Args : h264Args, outputPath];
     signal.throwIfAborted();
     const proc = spawn(ffmpegPath, args, {
       stdio: ["ignore", "ignore", "pipe"],
-      timeout: TRANSCODE_TIMEOUT_MS,
+      timeout: timeoutMs,
       killSignal: "SIGKILL",
       signal,
       windowsHide: true
@@ -783,7 +902,7 @@ async function runFfmpeg(sourcePath, outputPath, variant, box, signal) {
       } else if (signal2) {
         reject(
           new ProxyTranscodeError(
-            `ffmpeg killed by ${signal2} (timeout ${TRANSCODE_TIMEOUT_MS}ms or external kill)`,
+            `ffmpeg killed by ${signal2} (timeout ${timeoutMs}ms or external kill)`,
             null,
             stderrTail
           )
@@ -808,7 +927,18 @@ async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath,
     mkdirWithinProject(projectDir, cacheDir);
     const tempPath = join2(cacheDir, `.tmp-${randomUUID()}-${basename(cachePath)}`);
     try {
-      await runFfmpeg(absoluteSourcePath, tempPath, variant, box, job.abandoned.signal);
+      const chunkPrefix = join2(
+        cacheDir,
+        `${CHUNK_PREFIX}${basename(cachePath, extname2(cachePath))}-`
+      );
+      await runFfmpeg(
+        absoluteSourcePath,
+        tempPath,
+        chunkPrefix,
+        variant,
+        box,
+        job.abandoned.signal
+      );
       renameSync(tempPath, cachePath);
       maintainProxyCache(cacheDir);
       return cachePath;
@@ -876,13 +1006,23 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", bo
 }
 async function resolveProxies(projectDir, sources, onSettled = () => {
 }) {
+  const first = sources[0];
+  if (first) {
+    maintainProxyCache(
+      dirname(getProxyCachePath(projectDir, first.sourcePath, first.variant)),
+      Math.min(
+        Number(process.env.HYPERFRAMES_PROXY_CACHE_STALE_TEMP_MS) || UNTOUCHED_TEMP_IS_DEAD_MS,
+        UNTOUCHED_TEMP_IS_DEAD_MS
+      )
+    );
+  }
   const results = [];
   let next = 0;
   const worker = async () => {
     for (let index = next++; index < sources.length; index = next++) {
-      const { sourcePath, variant } = sources[index];
+      const { sourcePath, variant, box } = sources[index];
       results[index] = await waitForProxy(
-        resolveProxy(projectDir, sourcePath, variant),
+        resolveProxy(projectDir, sourcePath, variant, box),
         TRANSCODE_TIMEOUT_MS
       ).then(
         (value) => ({ status: "fulfilled", value }),

package/dist/{chunk-ZIRIDSDB.js → chunk-BWPY64WA.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   findCompositionDimensions
-} from "./chunk-FH7WODJH.js";
+} from "./chunk-ZFFKWHXN.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";

package/dist/{chunk-MTPPEEYZ.js → chunk-CWVSJA52.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   readCompositionFps
-} from "./chunk-B2P4JRUJ.js";
+} from "./chunk-XNLYMHX2.js";
 import {
   errorBox
 } from "./chunk-K2FLNJVB.js";
@@ -16,10 +16,10 @@ import {
 import {
   DEFAULT_CONFIG,
   resolvePageNavigationTimeout
-} from "./chunk-YCW345M4.js";
+} from "./chunk-OAPYPSEB.js";
 import {
   parseFps
-} from "./chunk-YV4WT7CJ.js";
+} from "./chunk-56IOFIYB.js";
 
 // src/browser/windowsCrash.ts
 var STATUS_STACK_BUFFER_OVERRUN_DEC = "3221225595";
@@ -43,8 +43,8 @@ function windowsChromeCrashRemediation(errorMessage) {
 }
 
 // src/utils/renderArgs.ts
-import { readFileSync } from "fs";
-import { resolve, sep } from "path";
+import { readFileSync, realpathSync } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
 var MIN_PAGE_NAVIGATION_TIMEOUT_MS = 1;
 var MAX_PAGE_NAVIGATION_TIMEOUT_SECONDS = 86400;
 function parseBrowserTimeoutMsArg(raw) {
@@ -113,12 +113,13 @@ function normalizeCompositionEntryArg(raw) {
 function hasExplicitCompositionArg(raw) {
   return normalizeCompositionEntryArg(raw) !== void 0;
 }
-function parseCompositionEntryArg(raw, projectDir, stat) {
+function parseCompositionEntryArg(raw, projectDir, stat, real = realpathOrSame) {
   const trimmed = normalizeCompositionEntryArg(raw);
   if (!trimmed) return { ok: true, value: void 0 };
   const absProjectDir = resolve(projectDir);
   const entryPath = resolve(absProjectDir, trimmed);
-  if (entryPath !== absProjectDir && !entryPath.startsWith(absProjectDir + sep)) {
+  const relativeEntry = [absProjectDir, real(absProjectDir)].flatMap((root) => [entryPath, real(entryPath)].map((path) => relative(root, path))).find((rel) => rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+  if (relativeEntry === void 0) {
     return { ok: false, error: { kind: "outside-project", entryFile: trimmed } };
   }
   let entryStat;
@@ -130,7 +131,14 @@ function parseCompositionEntryArg(raw, projectDir, stat) {
   if (!entryStat.isFile()) {
     return { ok: false, error: { kind: "not-a-file", entryFile: trimmed } };
   }
-  return { ok: true, value: trimmed };
+  return { ok: true, value: relativeEntry.split(sep).join("/") };
+}
+function realpathOrSame(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
 }
 function compositionEntryErrorMessage(error) {
   switch (error.kind) {

package/dist/{chunk-BWEZDN6U.js → chunk-CWYS2UNQ.js}

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