hyperframes 0.8.142 → 0.8.144

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

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

package/dist/{chunk-6UM3R7PP.js → chunk-ZOA2SC4P.js}

@@ -9,7 +9,11 @@ import {
   formatPreviewProxyBox,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-YFT3BL7N.js";
+} from "./chunk-3VYNNWVA.js";
+import {
+  decodeAuthoredAttribute,
+  scanHtmlOpeningTags
+} from "./chunk-MQZVBHEY.js";
 import {
   mkdirWithinProject,
   realProjectRoot,
@@ -19,19 +23,18 @@ import {
   cleanAssetUrl,
   isRemoteOrInlineUrl,
   isUnresolvedAssetPlaceholder,
-  maskNonScannableRanges,
-  resolveLocalAssetCandidates
-} from "./chunk-JFKL3WAE.js";
+  resolveExistingLocalAsset
+} from "./chunk-IWFLMU2N.js";
 import {
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";
 import {
   rewriteAssetPath
-} from "./chunk-TQFG7HTI.js";
+} from "./chunk-BSQ7XANM.js";
 
-// ../studio-server/dist/chunk-74JVVCWL.js
-import { existsSync, statSync } from "fs";
-import { relative, resolve, sep } from "path";
+// ../studio-server/dist/chunk-RN33UALN.js
+import { statSync } from "fs";
+import { sep } from "path";
 import { execFile } from "child_process";
 import { extname } from "path";
 var execFileRunner = (command, args, options) => new Promise((resolvePromise) => {
@@ -279,29 +282,27 @@ async function probeAssetCodec(filePath, runner, cache = defaultProbeCache) {
   rememberProbeResult(cache, filePath, { target, mtimeMs: stat.mtimeMs, size: stat.size, facts });
   return facts;
 }
-var VIDEO_SRC_RE = /<video\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>/gi;
-function resolveExistingLocalAsset(projectDir, url) {
-  const projectRoot = resolve(projectDir);
-  const resolvedPath = resolveLocalAssetCandidates(projectRoot, url).find(
-    (candidate) => existsSync(candidate)
-  );
-  if (!resolvedPath) return null;
-  const rootRelative = relative(projectRoot, resolvedPath).split(sep).join("/");
-  return { resolvedPath, rootRelativePathname: `/${rootRelative}` };
+function resolveExistingLocalAsset2(projectDir, url) {
+  const asset = resolveExistingLocalAsset(projectDir, url);
+  if (!asset) return null;
+  return {
+    resolvedPath: asset.resolved,
+    rootRelativePathname: `/${asset.rootRelativePath.split(sep).join("/")}`
+  };
 }
 function collectLocalVideoAssets(projectDir, htmlSources) {
   const candidates = /* @__PURE__ */ new Map();
   for (const { html, compSrcPath } of htmlSources) {
-    const scannable = maskNonScannableRanges(html);
-    const re = new RegExp(VIDEO_SRC_RE.source, VIDEO_SRC_RE.flags);
-    let match;
-    while ((match = re.exec(scannable)) !== null) {
-      const rawSrc = match[1] ?? "";
+    for (const tag of scanHtmlOpeningTags(html)) {
+      if (tag.name !== "video" || !tag.closed) continue;
+      const attribute = tag.attributes.find((attr) => attr.name === "src");
+      if (attribute?.kind !== "value") continue;
+      const rawSrc = decodeAuthoredAttribute(attribute.value);
       if (isUnresolvedAssetPlaceholder(rawSrc)) continue;
       const src = cleanAssetUrl(rawSrc);
       if (!src || isRemoteOrInlineUrl(src)) continue;
       const rootRelativeSrc = compSrcPath ? rewriteAssetPath(compSrcPath, src) : src;
-      const resolved = resolveExistingLocalAsset(projectDir, rootRelativeSrc);
+      const resolved = resolveExistingLocalAsset2(projectDir, rootRelativeSrc);
       if (!resolved) continue;
       candidates.set(resolved.resolvedPath, resolved.rootRelativePathname);
     }
@@ -335,12 +336,12 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
   return map;
 }
 
-// ../studio-server/dist/chunk-QP7LKFU2.js
+// ../studio-server/dist/chunk-AZBGTB3N.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 as relative2, resolve as resolve2, sep as sep2 } from "path";
-import { existsSync as existsSync3, readdirSync, statSync as statSync3, unlinkSync } from "fs";
+import { basename, dirname, 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";
 var DEFAULT_MAX_BYTES = 10 * 1024 * 1024 * 1024;
 var DEFAULT_STALE_TEMP_MS = 60 * 60 * 1e3;
@@ -413,7 +414,7 @@ function evictCacheEntries(entries, staleTemps, now, maxIdleMs, maxBytes, dryRun
   }
   for (const entry of kept) {
     if (bytesAfter <= maxBytes) break;
-    if (!entry.protected && existsSync3(entry.path)) remove(entry, true);
+    if (!entry.protected && existsSync(entry.path)) remove(entry, true);
   }
   return { removed, bytesBefore, bytesAfter };
 }
@@ -424,7 +425,7 @@ function cleanupProxyCache(cacheDir, options = {}) {
   if (shouldSkipSweep(cacheDir, now, minSweepIntervalMs)) {
     return { removed: [], bytesBefore: 0, bytesAfter: 0, skipped: true };
   }
-  if (!existsSync3(cacheDir)) {
+  if (!existsSync(cacheDir)) {
     return { removed: [], bytesBefore: 0, bytesAfter: 0, skipped: false };
   }
   const maxBytes = options.maxBytes ?? defaults.maxBytes;
@@ -512,15 +513,15 @@ async function waitForProxy(promise, timeoutMs = DEFAULT_PROXY_WAIT_TIMEOUT_MS)
   }
 }
 function canonicalizeProxySource(projectDir, absoluteSourcePath) {
-  const requestedProjectDir = resolve2(projectDir);
-  const requestedSourcePath = resolve2(absoluteSourcePath);
-  const requestedRelativePath = relative2(requestedProjectDir, requestedSourcePath);
+  const requestedProjectDir = resolve(projectDir);
+  const requestedSourcePath = resolve(absoluteSourcePath);
+  const requestedRelativePath = relative(requestedProjectDir, requestedSourcePath);
   if (requestedRelativePath === ".." || requestedRelativePath.startsWith(`..${sep2}`) || isAbsolute(requestedRelativePath)) {
     throw new ProxySourceOutsideProjectError();
   }
   const canonicalProjectDir = realProjectRoot(projectDir);
   const canonicalSourcePath = realpath(absoluteSourcePath);
-  const canonicalRelativePath = relative2(canonicalProjectDir, canonicalSourcePath);
+  const canonicalRelativePath = relative(canonicalProjectDir, canonicalSourcePath);
   const sourceIsInsideCanonicalProject = canonicalRelativePath !== ".." && !canonicalRelativePath.startsWith(`..${sep2}`) && !isAbsolute(canonicalRelativePath);
   return {
     projectDir: canonicalProjectDir,
@@ -546,31 +547,67 @@ function getCanonicalProxyCachePath(source, variant, box) {
     `${key}${PROXY_VARIANT_CONFIG[variant].extension}`
   );
 }
+var ProxyDroppedError = class extends ProxyTranscodeError {
+  constructor() {
+    super("media proxy copy dropped: every caller left before it started", null, "");
+    this.name = "ProxyDroppedError";
+  }
+};
 var activeTranscodes = 0;
 var waitQueue = [];
-function acquireSlot() {
+function enqueue(job) {
+  const firstNormal = job.priority ? waitQueue.findIndex((queued) => !queued.priority) : -1;
+  if (firstNormal === -1) waitQueue.push(job);
+  else waitQueue.splice(firstNormal, 0, job);
+}
+function dequeue(job) {
+  const index = waitQueue.indexOf(job);
+  if (index !== -1) waitQueue.splice(index, 1);
+}
+function acquireSlot(job) {
+  if (activeTranscodes < MAX_CONCURRENT_TRANSCODES) {
+    activeTranscodes++;
+    return Promise.resolve();
+  }
   return new Promise((resolveSlot, reject) => {
-    const tryAcquire = () => {
-      if (activeTranscodes < MAX_CONCURRENT_TRANSCODES) {
+    job.queued = {
+      start: () => {
+        job.queued = void 0;
         activeTranscodes++;
         resolveSlot();
-      } else {
-        if (waitQueue.length >= MAX_QUEUED_TRANSCODES) {
-          reject(new ProxyCapacityError());
-          return;
-        }
-        waitQueue.push(tryAcquire);
+      },
+      drop: () => {
+        job.queued = void 0;
+        dequeue(job);
+        forget(job);
+        reject(new ProxyDroppedError());
       }
     };
-    tryAcquire();
+    enqueue(job);
   });
 }
+function queueIsFull() {
+  return activeTranscodes >= MAX_CONCURRENT_TRANSCODES && waitQueue.length >= MAX_QUEUED_TRANSCODES;
+}
 function releaseSlot() {
   activeTranscodes--;
-  const next = waitQueue.shift();
-  if (next) next();
+  waitQueue.shift()?.queued?.start();
+}
+function prioritize(job) {
+  if (job.priority) return;
+  job.priority = true;
+  if (!job.queued) return;
+  dequeue(job);
+  enqueue(job);
+}
+function leave(job) {
+  job.callers--;
+  if (job.callers === 0) job.queued?.drop();
 }
 var inFlight = /* @__PURE__ */ new Map();
+function forget(job) {
+  if (inFlight.get(job.cachePath)?.job === job) inFlight.delete(job.cachePath);
+}
 function maintainProxyCache(cacheDir) {
   try {
     cleanupProxyCache(cacheDir, { protectedPaths: new Set(inFlight.keys()) });
@@ -729,8 +766,8 @@ async function runFfmpeg(sourcePath, outputPath, variant, box) {
     });
   });
 }
-async function transcodeToCache(projectDir, absoluteSourcePath, cachePath, variant, box) {
-  await acquireSlot();
+async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath, variant, box) {
+  await acquireSlot(job);
   try {
     if (existsSync2(cachePath)) return cachePath;
     const cacheDir = dirname(cachePath);
@@ -748,14 +785,15 @@ async function transcodeToCache(projectDir, absoluteSourcePath, cachePath, varia
     releaseSlot();
   }
 }
-var settledProxyCount = 0;
+var proxyActivity = 0;
 function proxyActivityMark(projectDir) {
-  if (!existsSync2(projectDir)) return String(settledProxyCount);
+  if (!existsSync2(projectDir)) return String(proxyActivity);
   const cacheDir = join2(realpath(projectDir), CACHE_DIR_NAME) + sep2;
   for (const cachePath of inFlight.keys()) if (cachePath.startsWith(cacheDir)) return null;
-  return String(settledProxyCount);
+  return String(proxyActivity);
 }
-async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", box) {
+async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", box, options = {}) {
+  options.signal?.throwIfAborted();
   const source = canonicalizeProxySource(projectDir, absoluteSourcePath);
   const cachePath = getCanonicalProxyCachePath(source, variant, box);
   if (existsSync2(cachePath)) {
@@ -768,17 +806,48 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", bo
     if (rememberedFailure.expiresAt > Date.now()) throw rememberedFailure.error;
     failedTranscodes.delete(cachePath);
   }
-  const existing = inFlight.get(cachePath);
-  if (existing) return existing;
-  const promise = transcodeToCache(source.projectDir, source.sourcePath, cachePath, variant, box).catch((err) => {
-    if (!(err instanceof ProxyCapacityError)) rememberFailure(cachePath, err);
-    throw err;
-  }).finally(() => {
-    inFlight.delete(cachePath);
-    settledProxyCount += 1;
+  let entry = inFlight.get(cachePath);
+  if (!entry) {
+    if (!options.priority && queueIsFull()) {
+      proxyActivity += 1;
+      throw new ProxyCapacityError();
+    }
+    const job = {
+      cachePath,
+      priority: options.priority === true,
+      callers: 0
+    };
+    const promise = transcodeToCache(
+      job,
+      source.projectDir,
+      source.sourcePath,
+      cachePath,
+      variant,
+      box
+    ).catch((err) => {
+      if (!(err instanceof ProxyDroppedError)) rememberFailure(cachePath, err);
+      throw err;
+    }).finally(() => {
+      forget(job);
+      proxyActivity += 1;
+    });
+    entry = { promise, job };
+    inFlight.set(cachePath, entry);
+  }
+  if (options.priority) prioritize(entry.job);
+  return joinJob(entry.promise, entry.job, options.signal);
+}
+function joinJob(promise, job, signal) {
+  job.callers++;
+  if (!signal) return promise;
+  return new Promise((resolveJoin, rejectJoin) => {
+    const onAbort = () => {
+      leave(job);
+      rejectJoin(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.finally(() => signal.removeEventListener("abort", onAbort)).then(resolveJoin, rejectJoin);
   });
-  inFlight.set(cachePath, promise);
-  return promise;
 }
 
 export {

package/dist/{clean-KTHTV5G5.js → clean-KPX27IKJ.js}

@@ -6,33 +6,33 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   redactHome
-} from "./chunk-IXCTG2WY.js";
+} from "./chunk-VYSUZEJG.js";
 import "./chunk-Z27A7NUB.js";
 import "./chunk-5ETJX6WM.js";
 import {
   loadProducer
-} from "./chunk-XTLBLWOV.js";
+} from "./chunk-GEWKFRFI.js";
 import "./chunk-3DKN5WKL.js";
 import {
   formatBytes
-} from "./chunk-IHFUKJOR.js";
-import "./chunk-YHRZQJXH.js";
-import "./chunk-OKCR3JTO.js";
+} from "./chunk-K2FLNJVB.js";
+import "./chunk-XGFHYAYN.js";
+import "./chunk-YJXHMIZA.js";
 import {
   DEFAULT_HISTORY_ROOT,
   listProjectHistories,
   pruneGoneProjectHistories
 } from "./chunk-QZ3AZTXI.js";
-import "./chunk-U7E736AJ.js";
+import "./chunk-DDIVWXN7.js";
 import {
   CACHE_DIR_NAME,
   cleanupProxyCache
-} from "./chunk-6UM3R7PP.js";
+} from "./chunk-ZOA2SC4P.js";
 import "./chunk-G75ENCEZ.js";
 import "./chunk-EOVYQ3IG.js";
-import "./chunk-KOEWEFHK.js";
+import "./chunk-DIRJ322I.js";
 import "./chunk-6BEFEWFB.js";
-import "./chunk-TVCRUG2S.js";
+import "./chunk-ZEUONDQG.js";
 import "./chunk-374QQGBQ.js";
 import "./chunk-GQJZORQP.js";
 import "./chunk-AMKC3AXA.js";
@@ -49,39 +49,40 @@ import {
   directorySizeBytes,
   gcExtractionCache,
   resolveExtractCacheDir
-} from "./chunk-IDX52YJN.js";
-import "./chunk-DPHJKWP5.js";
-import "./chunk-A4KQZXZI.js";
+} from "./chunk-5VMR4WBS.js";
+import "./chunk-OUSLVRO4.js";
+import "./chunk-NE55C6S5.js";
 import "./chunk-USDEMXXL.js";
-import "./chunk-YFT3BL7N.js";
-import "./chunk-OZUQF4NB.js";
-import "./chunk-DPVXBVLL.js";
-import "./chunk-J4UX3RS3.js";
+import "./chunk-3VYNNWVA.js";
+import "./chunk-WJB7WI4J.js";
 import "./chunk-VC76R6W2.js";
 import "./chunk-YA62XGXS.js";
+import "./chunk-MQZVBHEY.js";
 import "./chunk-OFQWTKPW.js";
+import "./chunk-DPVXBVLL.js";
 import "./chunk-T76PLPD6.js";
 import "./chunk-FXMKHHPO.js";
 import "./chunk-RQVDTPGD.js";
-import "./chunk-4PFZPP2N.js";
-import "./chunk-LCSMOLGX.js";
+import "./chunk-A6S35NYA.js";
+import "./chunk-BYSBRF24.js";
 import "./chunk-TWWSYAKJ.js";
-import "./chunk-IW2CKH6A.js";
-import "./chunk-JFKL3WAE.js";
-import "./chunk-HBBJFK6I.js";
+import "./chunk-IEIJRMLZ.js";
+import "./chunk-IWFLMU2N.js";
+import "./chunk-APDLWWFG.js";
 import "./chunk-PJ3HDUCY.js";
-import "./chunk-TQFG7HTI.js";
-import "./chunk-GK4AIFIH.js";
+import "./chunk-3RM2ETQT.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
 import "./chunk-2PSPARWP.js";
-import "./chunk-PMRBLBUP.js";
+import "./chunk-T42U2W2R.js";
 import {
   withMeta
-} from "./chunk-JLKMWY2T.js";
+} from "./chunk-P6WH6QTV.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-DZEVA7DI.js";
+import "./chunk-4OC7MQNB.js";
 import "./chunk-KNU5COPB.js";
 import "./chunk-3GXQPCJC.js";
 import {