hyperframes 0.8.142 → 0.8.143

package/dist/chunk-ZLW2V65P.js

@@ -0,0 +1,209 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// ../parsers/dist/mediaDuration.js
+var COMPOSITION_ATTRIBUTES = Object.freeze({
+  start: "data-start",
+  duration: "data-duration",
+  trackIndex: "data-track-index",
+  derivedEnd: "data-end",
+  legacyTrack: "data-layer"
+});
+var CANONICAL_AUTHORED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.start,
+  COMPOSITION_ATTRIBUTES.duration,
+  COMPOSITION_ATTRIBUTES.trackIndex
+]);
+var DERIVED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd
+]);
+var LEGACY_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd,
+  COMPOSITION_ATTRIBUTES.legacyTrack
+]);
+function parseNumeric(value) {
+  if (value == null || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var nonNegative = (raw) => {
+  const value = parseNumeric(raw);
+  return value !== null && value >= 0 ? value : null;
+};
+function readMediaOffsetSeconds(getAttr) {
+  return nonNegative(getAttr("data-playback-start")) ?? nonNegative(getAttr("data-media-start")) ?? 0;
+}
+var MIN_PLAYBACK_RATE = 0.1;
+var MAX_PLAYBACK_RATE = 10;
+function clampPlaybackRate(raw) {
+  return Number.isFinite(raw) && raw > 0 ? Math.max(MIN_PLAYBACK_RATE, Math.min(MAX_PLAYBACK_RATE, raw)) : 1;
+}
+function readPlaybackRate(getAttr, fallback = 1) {
+  const authored = Number.parseFloat(getAttr("data-playback-rate") ?? "");
+  return clampPlaybackRate(Number.isFinite(authored) && authored > 0 ? authored : fallback);
+}
+function readDataDurationSeconds(getAttr) {
+  const duration = parseNumeric(getAttr("data-duration"));
+  return duration !== null && duration > 0 ? duration : null;
+}
+function readAuthoredDurationSeconds(getAttr, startSeconds) {
+  const duration = readDataDurationSeconds(getAttr);
+  if (duration !== null) return duration;
+  const end = parseNumeric(getAttr("data-end"));
+  return end !== null ? end - startSeconds : null;
+}
+var DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS = 3;
+function resolveNaturalDurationSeconds(sourceDurationSeconds, mediaStartSeconds, playbackRate) {
+  if (!Number.isFinite(sourceDurationSeconds)) return null;
+  const remaining = Math.max(0, sourceDurationSeconds - mediaStartSeconds);
+  return remaining / clampPlaybackRate(playbackRate);
+}
+function resolveMediaDuration(input) {
+  const { tag, authoredDurationSeconds, sourceDurationSeconds, mediaStartSeconds, playbackRate } = input;
+  if (authoredDurationSeconds !== null && authoredDurationSeconds > 0) {
+    return { seconds: authoredDurationSeconds, source: "authored" };
+  }
+  if (tag === "img") {
+    return { seconds: DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS, source: "default" };
+  }
+  if (sourceDurationSeconds === null) {
+    return { seconds: null, source: "pending", reason: "source duration not yet probed" };
+  }
+  const seconds = resolveNaturalDurationSeconds(
+    sourceDurationSeconds,
+    mediaStartSeconds,
+    playbackRate
+  );
+  if (seconds === null) {
+    return { seconds: null, source: "pending", reason: "source reported a non-finite duration" };
+  }
+  return { seconds, source: "media" };
+}
+
+// ../parsers/dist/assets.js
+import { isAbsolute, relative, resolve } from "path";
+import { posix } from "path";
+function decodeWellFormedEscapes(path) {
+  return path.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+    try {
+      return decodeURIComponent(run);
+    } catch {
+      return run;
+    }
+  });
+}
+function splitUrlSuffix(urlValue) {
+  const queryIdx = urlValue.indexOf("?");
+  const hashIdx = urlValue.indexOf("#");
+  if (queryIdx < 0 && hashIdx < 0) return { basePath: urlValue, suffix: "" };
+  let cutIdx = urlValue.length;
+  if (queryIdx >= 0) cutIdx = Math.min(cutIdx, queryIdx);
+  if (hashIdx >= 0) cutIdx = Math.min(cutIdx, hashIdx);
+  return { basePath: urlValue.slice(0, cutIdx), suffix: urlValue.slice(cutIdx) };
+}
+function decodedUrlPath(url) {
+  return decodeWellFormedEscapes(splitUrlSuffix(url).basePath);
+}
+function encodeUrlPath(path) {
+  return encodeURIComponent(path).replace(/%2F/g, "/").replace(/['()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function decodeCssEscapes(text) {
+  return text.replaceAll("\0", "\uFFFD").replace(
+    /\\(?:([0-9a-f]{1,6})(?:\r\n|[ \t\r\n\f])?|(\r\n|[\n\r\f])|([\s\S]))/gi,
+    (_escaped, hex, lineBreak, char) => {
+      if (hex === void 0) return lineBreak === void 0 ? char : "";
+      const code = Number.parseInt(hex, 16);
+      if (code === 0 || code > 1114111 || code >= 55296 && code <= 57343) return "\uFFFD";
+      return String.fromCodePoint(code);
+    }
+  );
+}
+var CSS_URL_RE = /\burl\(\s*(["']?)([^)"'\s](?:[^)"']*[^)"'\s])?)\1\s*\)/g;
+var PATH_ATTRS = ["src", "href"];
+function isNonRelativeUrl(val) {
+  return !val || val.startsWith("http://") || val.startsWith("https://") || val.startsWith("//") || val.startsWith("data:") || val.startsWith("#") || val.startsWith("/");
+}
+function isPathInside(childPath, parentPath) {
+  const absChild = resolve(childPath);
+  const absParent = resolve(parentPath);
+  if (absChild === absParent) return true;
+  const rel = relative(absParent, absChild);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+var { join, resolve: resolve2, dirname } = posix;
+var isAbsoluteOrSpecial = isNonRelativeUrl;
+function needsRewrite(val) {
+  return val.startsWith("../") || val === "..";
+}
+function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
+  if (isAbsoluteOrSpecial(relativePath)) return relativePath;
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return relativePath;
+  const { basePath, suffix } = splitUrlSuffix(relativePath);
+  if (!basePath) return relativePath;
+  const filePath = decodeWellFormedEscapes(basePath);
+  const sibling = resolve2("/", join(compDir, filePath)).slice(1);
+  if (!needsRewrite(filePath) && (!assetExists || !assetExists(sibling))) return relativePath;
+  return encodeUrlPath(sibling) + suffix;
+}
+function rewriteAssetPaths(elements, compSrcPath, getAttr, setAttr, assetExists) {
+  for (const el of elements) {
+    for (const attr of PATH_ATTRS) {
+      const val = (getAttr(el, attr) || "").trim();
+      const rewritten = rewriteAssetPath(compSrcPath, val, assetExists);
+      if (rewritten !== val) {
+        setAttr(el, attr, rewritten);
+      }
+    }
+  }
+}
+function rewriteInlineStyleAssetUrls(elements, compSrcPath, getStyle, setStyle, assetExists) {
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return;
+  for (const el of elements) {
+    const style = getStyle(el);
+    if (!style) continue;
+    const rewritten = rewriteCssAssetUrls(style, compSrcPath, assetExists);
+    if (rewritten !== style) {
+      setStyle(el, rewritten);
+    }
+  }
+}
+function rewriteCssAssetUrls(cssText, compSrcPath, assetExists) {
+  if (!cssText) return cssText;
+  return cssText.replace(CSS_URL_RE, (full, quote, rawUrl) => {
+    const urlValue = (rawUrl || "").trim();
+    const rewritten = rewriteAssetPath(compSrcPath, urlValue, assetExists);
+    if (rewritten === urlValue) return full;
+    return `url(${quote || ""}${rewritten}${quote || ""})`;
+  });
+}
+
+export {
+  readMediaOffsetSeconds,
+  MIN_PLAYBACK_RATE,
+  MAX_PLAYBACK_RATE,
+  clampPlaybackRate,
+  readPlaybackRate,
+  readDataDurationSeconds,
+  readAuthoredDurationSeconds,
+  resolveNaturalDurationSeconds,
+  resolveMediaDuration,
+  decodeWellFormedEscapes,
+  splitUrlSuffix,
+  decodedUrlPath,
+  encodeUrlPath,
+  decodeCssEscapes,
+  CSS_URL_RE,
+  PATH_ATTRS,
+  isNonRelativeUrl,
+  isPathInside,
+  rewriteAssetPath,
+  rewriteAssetPaths,
+  rewriteInlineStyleAssetUrls,
+  rewriteCssAssetUrls
+};

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

@@ -9,7 +9,11 @@ import {
   formatPreviewProxyBox,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-YFT3BL7N.js";
+} from "./chunk-4M4EC7JX.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-ZLW2V65P.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-6EFY2WPN.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,

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

@@ -6,28 +6,28 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   redactHome
-} from "./chunk-IXCTG2WY.js";
+} from "./chunk-BYK73CR7.js";
 import "./chunk-Z27A7NUB.js";
 import "./chunk-5ETJX6WM.js";
 import {
   loadProducer
-} from "./chunk-XTLBLWOV.js";
+} from "./chunk-QVYVUCWD.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-7UYBQ6NF.js";
+import "./chunk-UM2GRYM3.js";
 import {
   DEFAULT_HISTORY_ROOT,
   listProjectHistories,
   pruneGoneProjectHistories
 } from "./chunk-QZ3AZTXI.js";
-import "./chunk-U7E736AJ.js";
+import "./chunk-BFDJ63J5.js";
 import {
   CACHE_DIR_NAME,
   cleanupProxyCache
-} from "./chunk-6UM3R7PP.js";
+} from "./chunk-ZQQ3SEIE.js";
 import "./chunk-G75ENCEZ.js";
 import "./chunk-EOVYQ3IG.js";
 import "./chunk-KOEWEFHK.js";
@@ -49,39 +49,40 @@ import {
   directorySizeBytes,
   gcExtractionCache,
   resolveExtractCacheDir
-} from "./chunk-IDX52YJN.js";
-import "./chunk-DPHJKWP5.js";
-import "./chunk-A4KQZXZI.js";
+} from "./chunk-33RZPZ4K.js";
+import "./chunk-F26LCYRY.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-4M4EC7JX.js";
+import "./chunk-6TPZSTCL.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-TWWSYAKJ.js";
-import "./chunk-IW2CKH6A.js";
-import "./chunk-JFKL3WAE.js";
-import "./chunk-HBBJFK6I.js";
+import "./chunk-XONFUK3M.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-ZLW2V65P.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-Y6QL2LGO.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-DZEVA7DI.js";
+import "./chunk-W35EKBS6.js";
 import "./chunk-KNU5COPB.js";
 import "./chunk-3GXQPCJC.js";
 import {