@hyperframes/studio-server 0.8.201 → 0.8.202

package/dist/{chunk-HZCA2O76.js → chunk-2MJKVMZU.js}

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

package/dist/{chunk-5UEDEOD2.js → chunk-RX6VALW3.js}

@@ -11,23 +11,19 @@ import {
 
 // src/helpers/proxyTranscoder.ts
 import { spawn } from "child_process";
-import { createHash, randomUUID } from "crypto";
+import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync4,
   mkdtempSync,
   renameSync,
-  rmSync,
-  statSync as statSync2,
+  rmSync as rmSync2,
   unlinkSync as unlinkSync2,
   utimesSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import { availableParallelism, tmpdir, totalmem } from "os";
-import { basename, dirname, extname as extname2, isAbsolute, join as join2, relative, resolve, sep } from "path";
-import {
-  formatPreviewProxyBox,
-  hdrToSdrToneMapFilter
-} from "@hyperframes/core";
+import { basename as basename3, dirname as dirname3, extname as extname3, isAbsolute, join as join4, relative, resolve, sep } from "path";
+import { hdrToSdrToneMapFilter } from "@hyperframes/core";
 import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
 import { alphaDecoderFor } from "@hyperframes/parsers/media-alpha";
 
@@ -143,6 +139,136 @@ function cleanupProxyCache(cacheDir, options = {}) {
   };
 }
 
+// src/helpers/proxyCacheKey.ts
+import { createHash } from "crypto";
+import {
+  closeSync,
+  createReadStream,
+  existsSync as existsSync2,
+  fstatSync,
+  openSync,
+  readFileSync,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import { basename, dirname, extname as extname2, join as join2 } from "path";
+import { formatPreviewProxyBox } from "@hyperframes/core";
+var SMALL_FILE_BYTES = 16 * 1024 * 1024;
+var COPY_NAME = /^[0-9a-f]{64}\.(?:mp4|webm)$/;
+function digest(...parts) {
+  return createHash("sha256").update(parts.join("\0")).digest("hex");
+}
+function boxPart(box) {
+  return box ? formatPreviewProxyBox(box) : "";
+}
+function fastCopyKey(sourcePath, version, variant, box) {
+  const stat = statSync2(sourcePath);
+  return digest(
+    sourcePath,
+    String(stat.mtimeMs),
+    String(stat.size),
+    version,
+    variant,
+    boxPart(box)
+  );
+}
+async function contentCopyKey(sourcePath, version, variant, box, signal) {
+  const hash = createHash("sha256");
+  const fd = openSync(sourcePath, "r");
+  try {
+    if (fstatSync(fd).size <= SMALL_FILE_BYTES) hash.update(readFileSync(fd));
+    else
+      for await (const chunk of createReadStream(sourcePath, { fd, autoClose: false, signal }))
+        hash.update(chunk);
+  } finally {
+    closeSync(fd);
+  }
+  return digest(hash.digest("hex"), version, variant, boxPart(box));
+}
+function fastIndexPath(cachePath) {
+  return join2(dirname(cachePath), `.fast-${basename(cachePath, extname2(cachePath))}`);
+}
+function contentIndexPath(cacheDir, contentKey) {
+  return join2(cacheDir, `.content-${contentKey}`);
+}
+function readCopyIndex(indexPath) {
+  try {
+    const name = readFileSync(indexPath, "utf8").trim();
+    const target = join2(dirname(indexPath), name);
+    return COPY_NAME.test(name) && existsSync2(target) ? target : null;
+  } catch {
+    return null;
+  }
+}
+function writeCopyIndex(indexPath, copyPath) {
+  writeFileSync(indexPath, basename(copyPath));
+}
+
+// src/helpers/proxyLock.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync3,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync as statSync3,
+  writeSync
+} from "fs";
+import { basename as basename2, dirname as dirname2, join as join3 } from "path";
+var POLL_MS = 500;
+var UNREADABLE_LOCK_MS = 1e4;
+function lockPathFor(cachePath) {
+  return join3(dirname2(cachePath), `.lock-${basename2(cachePath)}`);
+}
+function ownerIsAlive(lockPath) {
+  try {
+    const pid = Number(readFileSync2(lockPath, "utf8"));
+    if (!Number.isInteger(pid) || pid <= 0) {
+      return Date.now() - statSync3(lockPath).mtimeMs < UNREADABLE_LOCK_MS;
+    }
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      return err.code === "EPERM";
+    }
+  } catch {
+    return false;
+  }
+}
+function pause(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function acquireCopyLock(cachePath, signal) {
+  const lockPath = lockPathFor(cachePath);
+  for (; ; ) {
+    signal.throwIfAborted();
+    if (existsSync3(cachePath)) return null;
+    try {
+      const fd = openSync2(lockPath, "wx");
+      writeSync(fd, String(process.pid));
+      closeSync2(fd);
+      if (!existsSync3(cachePath)) return () => rmSync(lockPath, { force: true });
+      rmSync(lockPath, { force: true });
+      return null;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    if (ownerIsAlive(lockPath)) await pause(POLL_MS, signal);
+    else rmSync(lockPath, { force: true });
+  }
+}
+
 // src/helpers/proxyTranscoder.ts
 var PROXY_PARAMS_VERSION = "v7";
 var CACHE_DIR_NAME = ".transcode-cache";
@@ -235,33 +361,16 @@ function canonicalizeProxySource(projectDir, absoluteSourcePath) {
   if (requestedRelativePath === ".." || requestedRelativePath.startsWith(`..${sep}`) || isAbsolute(requestedRelativePath)) {
     throw new ProxySourceOutsideProjectError();
   }
-  const canonicalProjectDir = realProjectRoot(projectDir);
-  const canonicalSourcePath = realpath(absoluteSourcePath);
-  const canonicalRelativePath = relative(canonicalProjectDir, canonicalSourcePath);
-  const sourceIsInsideCanonicalProject = canonicalRelativePath !== ".." && !canonicalRelativePath.startsWith(`..${sep}`) && !isAbsolute(canonicalRelativePath);
-  return {
-    projectDir: canonicalProjectDir,
-    sourcePath: canonicalSourcePath,
-    relativePath: requestedRelativePath.normalize("NFC"),
-    // An external target needs a stable identity in addition to its project-local
-    // symlink path, otherwise retargeting the link can reuse an unrelated proxy.
-    cacheIdentity: (sourceIsInsideCanonicalProject ? canonicalRelativePath : canonicalSourcePath).normalize("NFC")
-  };
-}
-function buildProxyCacheKey(source, variant, box) {
-  const stat = statSync2(source.sourcePath);
-  const size = box ? `\0${formatPreviewProxyBox(box)}` : "";
-  return createHash("sha256").update(
-    `${source.relativePath}\0${source.cacheIdentity}\0${stat.mtimeMs}\0${stat.size}\0${PROXY_PARAMS_VERSION}\0${variant}${size}`
-  ).digest("hex");
+  return { projectDir: realProjectRoot(projectDir), sourcePath: realpath(absoluteSourcePath) };
 }
 function getCanonicalProxyCachePath(source, variant, box) {
-  const key = buildProxyCacheKey(source, variant, box);
-  return join2(
+  const key = fastCopyKey(source.sourcePath, PROXY_PARAMS_VERSION, variant, box);
+  const made = join4(
     source.projectDir,
     CACHE_DIR_NAME,
     `${key}${PROXY_VARIANT_CONFIG[variant].extension}`
   );
+  return existsSync4(made) ? made : readCopyIndex(fastIndexPath(made)) ?? made;
 }
 function getProxyCachePath(projectDir, absoluteSourcePath, variant = "h264", box) {
   return getCanonicalProxyCachePath(
@@ -456,9 +565,9 @@ function createPieceGate(size) {
 }
 async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat, signal, gate, onDone = () => {
 }) {
-  const extension = extname2(tempPath);
+  const extension = extname3(tempPath);
   const pieces = ranges.map((_, index) => `${chunkPrefix}${index}${extension}`);
-  const pending = ranges.flatMap((_, index) => existsSync2(pieces[index]) ? [] : [index]);
+  const pending = ranges.flatMap((_, index) => existsSync4(pieces[index]) ? [] : [index]);
   let doneSeconds = 0;
   for (const [index, range] of ranges.entries()) {
     if (!pending.includes(index)) doneSeconds += range.lengthSeconds;
@@ -477,7 +586,7 @@ async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat, sig
         const index = pending[cursor++];
         const range = ranges[index];
         const piece = pieces[index];
-        const pieceTemp = join2(dirname(piece), `.tmp-${randomUUID()}-${basename(piece)}`);
+        const pieceTemp = join4(dirname3(piece), `.tmp-${randomUUID()}-${basename3(piece)}`);
         try {
           await encode(pieceTemp, range, pieceSignal, (encodedSeconds) => {
             inFlight2.set(index, encodedSeconds);
@@ -488,7 +597,7 @@ async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat, sig
           doneSeconds += range.lengthSeconds;
           onDone(doneSeconds);
         } finally {
-          if (existsSync2(pieceTemp)) unlinkSync2(pieceTemp);
+          if (existsSync4(pieceTemp)) unlinkSync2(pieceTemp);
         }
       } finally {
         gate.release();
@@ -505,19 +614,19 @@ async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat, sig
     )
   );
   if (failure !== void 0) throw failure;
-  const listDir = mkdtempSync(join2(tmpdir(), "hf-proxy-join-"));
+  const listDir = mkdtempSync(join4(tmpdir(), "hf-proxy-join-"));
   try {
-    const listPath = join2(listDir, "pieces.txt");
-    writeFileSync(
+    const listPath = join4(listDir, "pieces.txt");
+    writeFileSync2(
       listPath,
       pieces.map((piece) => `file '${piece.replace(/\\/g, "/").replace(/'/g, "'\\''")}'
 `).join("")
     );
     await concat(listPath, tempPath);
   } finally {
-    rmSync(listDir, { recursive: true, force: true });
+    rmSync2(listDir, { recursive: true, force: true });
   }
-  for (const piece of pieces) if (existsSync2(piece)) unlinkSync2(piece);
+  for (const piece of pieces) if (existsSync4(piece)) unlinkSync2(piece);
 }
 var KEYFRAME_EVERY_SECOND_ARGS = ["-force_key_frames", "expr:gte(t,n_forced*1)"];
 var H264_ARGS = [
@@ -737,14 +846,31 @@ function spawnFfmpeg(ffmpegPath, args, stallMs, signal, onProgress) {
 async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath, variant, box) {
   await acquireSlot(job);
   try {
-    if (existsSync2(cachePath)) return cachePath;
-    const cacheDir = dirname(cachePath);
+    if (existsSync4(cachePath)) return cachePath;
+    const cacheDir = dirname3(cachePath);
     mkdirWithinProject(projectDir, cacheDir);
-    const tempPath = join2(cacheDir, `.tmp-${randomUUID()}-${basename(cachePath)}`);
+    const contentIndex = contentIndexPath(
+      cacheDir,
+      await contentCopyKey(
+        absoluteSourcePath,
+        PROXY_PARAMS_VERSION,
+        variant,
+        box,
+        job.abandoned.signal
+      )
+    );
+    const sameContent = readCopyIndex(contentIndex);
+    if (sameContent) {
+      writeCopyIndex(fastIndexPath(cachePath), sameContent);
+      return sameContent;
+    }
+    const release = await acquireCopyLock(cachePath, job.abandoned.signal);
+    if (!release) return cachePath;
+    const tempPath = join4(cacheDir, `.tmp-${randomUUID()}-${basename3(cachePath)}`);
     try {
-      const chunkPrefix = join2(
+      const chunkPrefix = join4(
         cacheDir,
-        `${CHUNK_PREFIX}${basename(cachePath, extname2(cachePath))}-`
+        `${CHUNK_PREFIX}${basename3(cachePath, extname3(cachePath))}-`
       );
       await runFfmpeg(
         absoluteSourcePath,
@@ -756,10 +882,12 @@ async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath,
         (progress) => reportProgress(job, progress)
       );
       renameSync(tempPath, cachePath);
+      writeCopyIndex(contentIndex, cachePath);
       maintainProxyCache(cacheDir);
       return cachePath;
     } finally {
-      if (existsSync2(tempPath)) unlinkSync2(tempPath);
+      if (existsSync4(tempPath)) unlinkSync2(tempPath);
+      release();
     }
   } finally {
     releaseSlot();
@@ -767,8 +895,8 @@ async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath,
 }
 var proxyActivity = 0;
 function proxyActivityMark(projectDir) {
-  if (!existsSync2(projectDir)) return String(proxyActivity);
-  const cacheDir = join2(realpath(projectDir), CACHE_DIR_NAME) + sep;
+  if (!existsSync4(projectDir)) return String(proxyActivity);
+  const cacheDir = join4(realpath(projectDir), CACHE_DIR_NAME) + sep;
   for (const cachePath of inFlight.keys()) if (cachePath.startsWith(cacheDir)) return null;
   return String(proxyActivity);
 }
@@ -776,9 +904,9 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", bo
   options.signal?.throwIfAborted();
   const source = canonicalizeProxySource(projectDir, absoluteSourcePath);
   const cachePath = getCanonicalProxyCachePath(source, variant, box);
-  if (existsSync2(cachePath)) {
+  if (existsSync4(cachePath)) {
     markCacheEntryUsed(cachePath);
-    maintainProxyCache(dirname(cachePath));
+    maintainProxyCache(dirname3(cachePath));
     return cachePath;
   }
   const rememberedFailure = failedTranscodes.get(cachePath);
@@ -835,7 +963,7 @@ async function resolveProxies(projectDir, sources, onSettled = () => {
   const first = sources[0];
   if (first) {
     maintainProxyCache(
-      dirname(getProxyCachePath(projectDir, first.sourcePath, first.variant)),
+      dirname3(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

package/dist/helpers/mediaProxyPreview.js

@@ -4,8 +4,8 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "../chunk-HZCA2O76.js";
-import "../chunk-5UEDEOD2.js";
+} from "../chunk-2MJKVMZU.js";
+import "../chunk-RX6VALW3.js";
 import "../chunk-C2RFW2FX.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";

package/dist/helpers/proxyTranscoder.js

@@ -17,7 +17,7 @@ import {
   resolveProxies,
   resolveProxy,
   waitForProxy
-} from "../chunk-5UEDEOD2.js";
+} from "../chunk-RX6VALW3.js";
 import "../chunk-C2RFW2FX.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";

package/dist/index.js

@@ -82,7 +82,7 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "./chunk-HZCA2O76.js";
+} from "./chunk-2MJKVMZU.js";
 import {
   CACHE_DIR_NAME,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
@@ -93,7 +93,7 @@ import {
   proxyActivityMark,
   resolveProxy,
   waitForProxy
-} from "./chunk-5UEDEOD2.js";
+} from "./chunk-RX6VALW3.js";
 import {
   PROXY_VARIANT_CONFIG,
   decideMediaProxyEligibility,

package/package.json

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