@hyperframes/studio-server 0.8.188 → 0.8.189

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

@@ -1,14 +1,14 @@
 import {
   PROXY_PARAMS_VERSION,
   resolveProxy
-} from "./chunk-25IT6FMR.js";
+} from "./chunk-N2HH4SGD.js";
 import {
   createMediaCodecProbeCache,
   proxyVariantFor,
   recordProxyPrewarm,
   scanProjectMediaCodecMap,
   shouldPrewarmProxy
-} from "./chunk-OVOXGASQ.js";
+} from "./chunk-XMNHDWQI.js";
 
 // src/helpers/mediaProxyPreview.ts
 import { resolve } from "path";
@@ -24,7 +24,7 @@ function proxyEtagSalt(raw, box) {
   if (raw === void 0) return "";
   return `:proxy:${raw}:${PROXY_PARAMS_VERSION}${box ? `:${formatPreviewProxyBox(box)}` : ""}`;
 }
-async function injectMediaCodecMapIntoHtml(html, projectDir, htmlSources, probeCache, prewarm = true, signal) {
+async function injectMediaCodecMapIntoHtml(html, projectDir, htmlSources, probeCache, prewarm = true, signal, box) {
   let map;
   try {
     map = await scanProjectMediaCodecMap(
@@ -43,7 +43,7 @@ async function injectMediaCodecMapIntoHtml(html, projectDir, htmlSources, probeC
       projectDir,
       resolve(projectDir, rootRelativePathname.replace(/^\/+/, "")),
       proxyVariantFor(facts),
-      void 0,
+      box,
       { signal }
     ).catch(() => {
     });

package/dist/{chunk-25IT6FMR.js → chunk-N2HH4SGD.js}

@@ -2,7 +2,7 @@ import {
   PROXY_VARIANT_CONFIG,
   probeFirstFrameColour,
   probeMediaMetadata
-} from "./chunk-OVOXGASQ.js";
+} from "./chunk-XMNHDWQI.js";
 import {
   mkdirWithinProject,
   realProjectRoot,
@@ -12,8 +12,18 @@ import {
 // src/helpers/proxyTranscoder.ts
 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 } 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 } from "path";
 import {
   formatPreviewProxyBox,
   hdrToSdrToneMapFilter
@@ -31,7 +41,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]);
@@ -54,6 +66,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 = [];
@@ -67,8 +88,10 @@ 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);
+    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(extname(dirent.name))) {
       entries.push(entry);
     }
@@ -133,11 +156,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;
@@ -305,9 +332,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)}`
@@ -372,83 +399,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
@@ -467,7 +584,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
           )
@@ -492,7 +609,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;
@@ -560,13 +688,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-OVOXGASQ.js → chunk-XMNHDWQI.js}

@@ -121,7 +121,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",
       "--",
@@ -145,6 +145,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 {

package/dist/{chunk-XM2TJIF5.js → chunk-YIMSBQIO.js}

@@ -11,7 +11,7 @@ import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, writeFile } fro
 import {
   existsSync as existsSync3,
   lstatSync as lstatSync4,
-  statSync as statSync4,
+  statSync as statSync5,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync4,
   readFileSync as readFileSync10,
@@ -107,7 +107,15 @@ import { replaceFileAtomically } from "@hyperframes/core/atomic-file";
 
 // src/history/ownerLock.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { linkSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import {
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
 import { join } from "path";
 var HistoryBusyError = class extends Error {
   constructor(pid, url) {
@@ -120,6 +128,8 @@ var HistoryBusyError = class extends Error {
   url;
 };
 var WINDOWS_BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+var NO_HARD_LINKS = /* @__PURE__ */ new Set(["ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EPERM"]);
+var TAKING_MS = 2e3;
 function busyOnWindows(error) {
   return process.platform === "win32" && WINDOWS_BUSY.has(error.code ?? "");
 }
@@ -141,6 +151,17 @@ function ownerOf(file) {
     throw error;
   }
 }
+function beingTaken(file) {
+  try {
+    const { size, mtimeMs } = statSync(file);
+    return size === 0 && Date.now() - mtimeMs < TAKING_MS;
+  } catch {
+    return false;
+  }
+}
+function deadHolder(file, pid) {
+  return !alive(pid) && !beingTaken(file);
+}
 function claim(file) {
   const draft = `${file}-${process.pid}-${randomUUID2()}.tmp`;
   writeFileSync(draft, String(process.pid));
@@ -148,12 +169,23 @@ function claim(file) {
     linkSync(draft, file);
     return true;
   } catch (error) {
-    if (error.code !== "EEXIST") throw error;
-    return false;
+    const code = error.code ?? "";
+    if (code === "EEXIST") return false;
+    if (!NO_HARD_LINKS.has(code)) throw error;
+    return createExclusively(file);
   } finally {
     rmSync(draft, { force: true });
   }
 }
+function createExclusively(file) {
+  try {
+    writeFileSync(file, String(process.pid), { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    return false;
+  }
+}
 function releaseOwn(file) {
   if (ownerOf(file) === process.pid) rmSync(file, { force: true });
 }
@@ -161,12 +193,12 @@ function evictDeadOwner(file) {
   const evictor = `${file}.evict`;
   if (!claim(evictor)) {
     const holder = ownerOf(evictor);
-    if (holder !== null && !alive(holder)) rmSync(evictor, { force: true });
+    if (holder !== null && deadHolder(evictor, holder)) rmSync(evictor, { force: true });
     return false;
   }
   try {
     const pid = ownerOf(file);
-    if (pid !== null && !alive(pid)) rmSync(file, { force: true });
+    if (pid !== null && deadHolder(file, pid)) rmSync(file, { force: true });
     return true;
   } finally {
     releaseOwn(evictor);
@@ -191,7 +223,7 @@ function attemptClaim(file, urlFile, deadline) {
   if (claim(file)) return "claimed";
   const pid = ownerOf(file);
   if (pid === null) return "retry";
-  if (!alive(pid) && evictDeadOwner(file)) return "retry";
+  if (deadHolder(file, pid) && evictDeadOwner(file)) return "retry";
   if (Date.now() >= deadline) throw new HistoryBusyError(pid, servedBy(file, urlFile, pid));
   return "wait";
 }
@@ -526,14 +558,14 @@ async function openBlobStore(dir) {
 
 // src/history/pruneHistories.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
 import { lstat, readdir as readdir2, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname as dirname2, join as join4 } from "path";
 
 // src/history/historyId.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
 import { basename, join as join3, resolve as resolve3 } from "path";
 import { replaceFileAtomically as replaceFileAtomically2 } from "@hyperframes/core/atomic-file";
 var ID_PATH = join3(".hyperframes", "history-id");
@@ -566,7 +598,7 @@ function readRecord(historyDir) {
 function isCopyOf0878Folder(recordedDir, id, folder) {
   let there;
   try {
-    there = statSync(recordedDir, { throwIfNoEntry: false });
+    there = statSync2(recordedDir, { throwIfNoEntry: false });
   } catch {
     return false;
   }
@@ -574,7 +606,7 @@ function isCopyOf0878Folder(recordedDir, id, folder) {
 }
 function projectHistoryId(projectDir, historyRoot) {
   const dir = resolve3(projectDir);
-  const folder = statSync(dir);
+  const folder = statSync2(dir);
   let id = readId(dir);
   if (!id && existsSync(join3(dir, ID_PATH)))
     throw new HistoryIdError(
@@ -701,24 +733,24 @@ function abandonedProject(home, id, now, tempDir) {
   return projectGone(dir, id, record?.dev, tempDir) ? dir : null;
 }
 function projectGone(dir, id, dev, tempDir) {
-  if (!statSync2(join4(dir, ID_PATH), { throwIfNoEntry: false }))
+  if (!statSync3(join4(dir, ID_PATH), { throwIfNoEntry: false }))
     return diskStillHere(dir, dev, tempDir);
   const there = readId(dir);
   return there !== null && there !== id;
 }
 function diskStillHere(dir, dev, tempDir) {
   let at = dir;
-  let stat2 = statSync2(at, { throwIfNoEntry: false });
+  let stat2 = statSync3(at, { throwIfNoEntry: false });
   while (!stat2) {
     if (dirname2(at) === at) return false;
     at = dirname2(at);
-    stat2 = statSync2(at, { throwIfNoEntry: false });
+    stat2 = statSync3(at, { throwIfNoEntry: false });
   }
   if (typeof dev === "number") return stat2.dev === dev;
   return at === dir || isSafePath(tempDir, at);
 }
 function lastUsed(home) {
-  const mtime = (file) => statSync2(join4(home, file), { throwIfNoEntry: false })?.mtimeMs ?? 0;
+  const mtime = (file) => statSync3(join4(home, file), { throwIfNoEntry: false })?.mtimeMs ?? 0;
   return Math.max(mtime("project.json"), mtime("log.jsonl"));
 }
 async function bytesIn(dir) {
@@ -749,7 +781,7 @@ function pruneGoneProjectHistoriesDaily(historyRoot, now, { onError, budgetMs }
 
 // src/history/videoState.ts
 import { createHash as createHash5, randomUUID as randomUUID6 } from "crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync2, readFileSync as readFileSync8, renameSync as renameSync4, statSync as statSync3 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync2, readFileSync as readFileSync8, renameSync as renameSync4, statSync as statSync4 } from "fs";
 import { isAbsolute as isAbsolute4, join as join7, resolve as resolve6 } from "path";
 import { replaceFileAtomically as replaceFileAtomically3 } from "@hyperframes/core/atomic-file";
 
@@ -1320,7 +1352,7 @@ function retainRevision(retained, revision) {
   return [revision, ...retained.filter((id) => id !== revision)].slice(0, 2);
 }
 async function recordRenderSuccess(projectDir, output, status = "completed", capture) {
-  const outputFile = statSync3(output);
+  const outputFile = statSync4(output);
   if (!outputFile.isFile() && !outputFile.isDirectory() || outputFile.isFile() && outputFile.size === 0)
     throw new Error("Render output is missing or empty.");
   const after = capture ? await beginArtifactCapture(projectDir) : null;
@@ -1556,8 +1588,8 @@ function fileLeftIn(dir, at, deleted) {
   return void 0;
 }
 function ignoresCase(dir) {
-  const self = statSync4(join8(dir, ID_PATH), { throwIfNoEntry: false });
-  const other = statSync4(join8(dir, ID_PATH.toUpperCase()), { throwIfNoEntry: false });
+  const self = statSync5(join8(dir, ID_PATH), { throwIfNoEntry: false });
+  const other = statSync5(join8(dir, ID_PATH.toUpperCase()), { throwIfNoEntry: false });
   return self !== void 0 && other?.ino === self.ino && other.dev === self.dev;
 }
 var blocks = (removed, added) => added.startsWith(`${removed}/`) || removed.startsWith(`${added}/`);
@@ -1597,7 +1629,7 @@ var Engine = class {
     this.dir = resolve7(options.projectDir);
     this.home = join8(options.historyRoot, projectId);
     this.foldsCase = ignoresCase(this.dir);
-    const folder = statSync4(this.dir, { throwIfNoEntry: false });
+    const folder = statSync5(this.dir, { throwIfNoEntry: false });
     if (!folder || readId(this.dir) !== projectId || !isRecordedFolder(this.home, folder))
       throw this.replaced();
     this.folder = { dev: folder.dev, ino: folder.ino, birthtimeMs: folder.birthtimeMs };
@@ -1662,7 +1694,7 @@ var Engine = class {
   }
   /** Another project if the folder or its id changed, or the id is gone: a recreated folder may reuse the inode. */
   whereFolder() {
-    const now = statSync4(this.dir, { throwIfNoEntry: false });
+    const now = statSync5(this.dir, { throwIfNoEntry: false });
     if (!now) return "gone";
     const same = now.dev === this.folder.dev && sameFolder(now, this.folder);
     return same && readId(this.dir) === this.projectId ? "here" : "replaced";
@@ -2467,7 +2499,7 @@ async function openProjectHistory(options) {
 function readProjectHistory(options) {
   const dir = resolve7(options.projectDir);
   const id = readId(dir);
-  const home = id && isRecordedFolder(join8(options.historyRoot, id), statSync4(dir)) ? join8(options.historyRoot, id) : null;
+  const home = id && isRecordedFolder(join8(options.historyRoot, id), statSync5(dir)) ? join8(options.historyRoot, id) : null;
   const read = home && readLog(logFileIn(home), () => {
   });
   const log = withoutHiddenPaths(read || { baseline: /* @__PURE__ */ new Map(), entries: [], pins: /* @__PURE__ */ new Set() });

package/dist/helpers/mediaCodecMap.js

@@ -13,7 +13,7 @@ import {
   resolveProxyVariantRequest,
   scanProjectMediaCodecMap,
   shouldPrewarmProxy
-} from "../chunk-OVOXGASQ.js";
+} from "../chunk-XMNHDWQI.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/helpers/mediaProxyPreview.d.ts

@@ -1,5 +1,5 @@
 import '@hyperframes/core';
-export { a as PreviewApiAdapter, P as PreviewDocumentStore, i as injectMediaCodecMap, f as injectMediaCodecMapIntoHtml, g as isAutoProxyEnabled, p as proxyEtagSalt, r as resolvePreviewMediaCodecProbeCache } from '../mediaProxyPreview-B5j7l9r4.js';
+export { a as PreviewApiAdapter, P as PreviewDocumentStore, i as injectMediaCodecMap, f as injectMediaCodecMapIntoHtml, g as isAutoProxyEnabled, p as proxyEtagSalt, r as resolvePreviewMediaCodecProbeCache } from '../mediaProxyPreview-CAiGJucG.js';
 import './mediaCodecMap.js';
 import 'sharp';
 import '@hyperframes/parsers';

package/dist/helpers/mediaProxyPreview.js

@@ -4,9 +4,9 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "../chunk-T5CGF7VZ.js";
-import "../chunk-25IT6FMR.js";
-import "../chunk-OVOXGASQ.js";
+} from "../chunk-HTHV7ZM6.js";
+import "../chunk-N2HH4SGD.js";
+import "../chunk-XMNHDWQI.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/helpers/proxyTranscoder.d.ts

@@ -71,6 +71,7 @@ declare function resolveProxy(projectDir: string, absoluteSourcePath: string, va
 declare function resolveProxies(projectDir: string, sources: ReadonlyArray<{
     sourcePath: string;
     variant: ProxyVariant;
+    box?: PreviewProxyBox;
 }>, onSettled?: () => void): Promise<PromiseSettledResult<string>[]>;
 interface ResolveProxyOptions {
     priority?: boolean;

package/dist/helpers/proxyTranscoder.js

@@ -16,8 +16,8 @@ import {
   resolveProxies,
   resolveProxy,
   waitForProxy
-} from "../chunk-25IT6FMR.js";
-import "../chunk-OVOXGASQ.js";
+} from "../chunk-N2HH4SGD.js";
+import "../chunk-XMNHDWQI.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/history/index.js

@@ -20,7 +20,7 @@ import {
   recordRenderSuccess,
   registerRenderOutput,
   retainSnapshotOutput
-} from "../chunk-XM2TJIF5.js";
+} from "../chunk-YIMSBQIO.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
-import { S as StudioApiAdapter, P as PreviewDocumentStore, M as MediaProcessingJobState } from './mediaProxyPreview-B5j7l9r4.js';
-export { L as LintResult, a as PreviewApiAdapter, R as RenderJobState, b as ResolvedProject, c as StudioSelectionResponse, d as StudioSelectionSnapshot, e as StudioSelectionTextField } from './mediaProxyPreview-B5j7l9r4.js';
+import { S as StudioApiAdapter, P as PreviewDocumentStore, M as MediaProcessingJobState } from './mediaProxyPreview-CAiGJucG.js';
+export { L as LintResult, a as PreviewApiAdapter, R as RenderJobState, b as ResolvedProject, c as StudioSelectionResponse, d as StudioSelectionSnapshot, e as StudioSelectionTextField } from './mediaProxyPreview-CAiGJucG.js';
 export { C as ClosedWindow, D as DEFAULT_HISTORY_ROOT, S as HISTORY_START, H as HistoryClosedError, a as HistoryEntry, b as HistoryEntrySide, c as HistoryFileChange, d as HistoryListItem, e as HistoryResult, f as HistoryTarget, g as HistoryWho, h as HistoryWindow, M as MAX_WINDOW_IDLE_MS, P as ProjectHistory, i as ProjectHistoryOptions, j as ProjectHistoryView, U as UNDO_MODES, k as UndoMode, o as openProjectHistory, r as readProjectHistory } from './projectHistory-ByC9sa3X.js';
 export { ArtifactCapture, ArtifactInput, ArtifactRecord, HistoryBusyError, HistoryIdError, ProjectHistoryRecord, PrunedHistory, RenderRecord, VideoState, artifactDirectory, beginArtifactCapture, finishSnapshotRun, forgetRecordedArtifacts, historyCache, listProjectHistories, pruneGoneProjectHistories, recordArtifact, recordArtifacts, recordRenderSuccess, registerRenderOutput, retainSnapshotOutput } from './history/index.js';
 export { CACHE_DIR_NAME as PROXY_CACHE_DIR_NAME } from './helpers/proxyTranscoder.js';

package/dist/index.js

@@ -60,7 +60,7 @@ import {
   resolveProjectSignature,
   retainSnapshotOutput,
   settledFileTag
-} from "./chunk-XM2TJIF5.js";
+} from "./chunk-YIMSBQIO.js";
 import {
   clearElementScreenshotIsolation,
   getElementScreenshotClip
@@ -80,7 +80,7 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "./chunk-T5CGF7VZ.js";
+} from "./chunk-HTHV7ZM6.js";
 import {
   CACHE_DIR_NAME,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
@@ -91,7 +91,7 @@ import {
   proxyActivityMark,
   resolveProxy,
   waitForProxy
-} from "./chunk-25IT6FMR.js";
+} from "./chunk-N2HH4SGD.js";
 import {
   PROXY_VARIANT_CONFIG,
   decideMediaProxyEligibility,
@@ -100,7 +100,7 @@ import {
   probeMediaMetadata,
   recordProxyRequest,
   resolveProxyVariantRequest
-} from "./chunk-OVOXGASQ.js";
+} from "./chunk-XMNHDWQI.js";
 import {
   folderGone,
   isInHiddenOrVendorDir,

package/dist/{mediaProxyPreview-B5j7l9r4.d.ts → mediaProxyPreview-CAiGJucG.d.ts}

@@ -302,7 +302,7 @@ declare function proxyEtagSalt(raw: string | undefined, box?: PreviewProxyBox):
  */
 declare function injectMediaCodecMapIntoHtml(html: string, projectDir: string, htmlSources: HtmlSourceLike[], probeCache?: MediaCodecProbeCache, prewarm?: boolean, 
 /** Aborting it stops the pre-warms nobody else waits for. */
-signal?: AbortSignal): Promise<string>;
+signal?: AbortSignal, box?: PreviewProxyBox): Promise<string>;
 /**
  * Adapter-aware wrapper used by the studio preview routes: skipped entirely
  * (no scan, no injection) when auto-proxy is off for this adapter.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/studio-server",
-  "version": "0.8.188",
+  "version": "0.8.189",
   "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.188",
-    "@hyperframes/core": "0.8.188"
+    "@hyperframes/parsers": "0.8.189",
+    "@hyperframes/core": "0.8.189"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",