@hyperframes/studio-server 0.8.208 → 0.8.209

package/dist/{chunk-MNJZQCBL.js → chunk-2B5SR4RJ.js}

@@ -1,8 +1,11 @@
 import {
   PROXY_VARIANT_CONFIG,
+  ffmpegHasHdrFilters
+} from "./chunk-FUTDRYQK.js";
+import {
   probeFirstFrameColour,
   probeMediaMetadata
-} from "./chunk-JKPLDWAB.js";
+} from "./chunk-X73QTST2.js";
 import {
   mkdirWithinProject,
   realProjectRoot,
@@ -479,29 +482,8 @@ function markCacheEntryUsed(cachePath) {
   }
 }
 var failedTranscodes = /* @__PURE__ */ new Map();
-var hdrFilterCheck;
-function ensureHdrFilters(ffmpegPath) {
-  if (hdrFilterCheck?.ffmpegPath === ffmpegPath) return hdrFilterCheck.promise;
-  const promise = new Promise((resolveCheck, rejectCheck) => {
-    const proc = spawn(ffmpegPath, ["-hide_banner", "-filters"], {
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.on("error", () => rejectCheck(new FfmpegMissingFilterError()));
-    proc.on("close", (code) => {
-      if (code !== 0 || !/\bzscale\b/.test(stdout) || !/\btonemap\b/.test(stdout)) {
-        rejectCheck(new FfmpegMissingFilterError());
-      } else {
-        resolveCheck();
-      }
-    });
-  });
-  hdrFilterCheck = { ffmpegPath, promise };
-  return promise;
+async function ensureHdrFilters(ffmpegPath) {
+  if (!await ffmpegHasHdrFilters(ffmpegPath)) throw new FfmpegMissingFilterError();
 }
 function rememberFailure(cachePath, error) {
   const ttlMs = error instanceof FfmpegUnavailableError || error instanceof FfmpegMissingFilterError ? ENVIRONMENT_FAILURE_TTL_MS : FAILURE_CACHE_TTL_MS;
@@ -761,6 +743,10 @@ async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, sign
   const videoFilter = await buildVideoFilter(ffmpegPath, sourcePath, metadata, keepsAlpha, box);
   const alphaDecoder = keepsAlpha ? alphaDecoderFor(metadata.color.codecName) : null;
   const decoderArgs = alphaDecoder ? ["-c:v", alphaDecoder] : [];
+  const streamArgs = [
+    ...["-map", "0:V:0"],
+    ...metadata.audioStream === void 0 ? [] : ["-map", `0:a:${metadata.audioStream}`]
+  ];
   const totalSeconds = metadata.durationSeconds;
   const gate = keepsAlpha ? ALPHA_PIECE_GATE : UNGATED;
   const vp8Threads = (pieces) => [
@@ -778,6 +764,7 @@ async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, sign
       ...decoderArgs,
       "-i",
       sourcePath,
+      ...streamArgs,
       ...range ? ["-t", String(range.lengthSeconds)] : [],
       "-vf",
       videoFilter,

package/dist/{chunk-WAMZ2Z5O.js → chunk-BWZMWYB2.js}

@@ -204,14 +204,15 @@ function claim(file) {
   const draft = `${file}-${process.pid}-${randomUUID2()}.tmp`;
   writeFileSync(draft, String(process.pid));
   try {
-    linkSync(draft, file);
-    recordStart(file);
-    return true;
-  } catch (error) {
-    const code = error.code ?? "";
-    if (code === "EEXIST") return false;
-    if (!NO_HARD_LINKS.has(code)) throw error;
-    return createExclusively(file);
+    try {
+      linkSync(draft, file);
+    } catch (error) {
+      const code = error.code ?? "";
+      if (code === "EEXIST") return false;
+      if (!NO_HARD_LINKS.has(code)) throw error;
+      return createExclusively(file);
+    }
+    return recordOwnership(file);
   } finally {
     rmSync(draft, { force: true });
   }
@@ -219,12 +220,20 @@ function claim(file) {
 function createExclusively(file) {
   try {
     writeFileSync(file, String(process.pid), { flag: "wx" });
-    recordStart(file);
-    return true;
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
     return false;
   }
+  return recordOwnership(file);
+}
+function recordOwnership(file) {
+  try {
+    recordStart(file);
+    return true;
+  } catch (error) {
+    releaseOwn(file);
+    throw error;
+  }
 }
 function releaseOwn(file) {
   if (ownerOf(file) !== process.pid) return;
@@ -524,11 +533,12 @@ function createProjectSignature(projectDir, excluding = /* @__PURE__ */ new Set(
 
 // src/history/blobStore.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
-import { constants, createReadStream, createWriteStream, renameSync } from "fs";
-import { copyFile, mkdir, readdir, readFile, rename, rm, stat } from "fs/promises";
+import { constants, createReadStream, createWriteStream } from "fs";
+import { copyFile, mkdir, readdir, readFile, rm, stat } from "fs/promises";
 import { dirname, join as join2 } from "path";
 import { pipeline } from "stream/promises";
 import { atomicTempPath } from "@hyperframes/core/atomic-file";
+import { renameWithRetry, renameWithRetryAsync } from "@hyperframes/core/rename-retry";
 var BLOB_HASH = /^[0-9a-f]{64}$/;
 function blobPath(dir, hash) {
   if (!BLOB_HASH.test(hash)) throw new Error("That is not a history blob.");
@@ -554,7 +564,7 @@ async function cloneOrCopy(from, to, beforeReplace) {
   try {
     await copyFile(from, temp, constants.COPYFILE_FICLONE);
     beforeReplace?.();
-    renameSync(temp, to);
+    renameWithRetry(temp, to);
   } catch (error) {
     await rm(temp, { force: true });
     throw error;
@@ -610,7 +620,7 @@ async function openBlobStore(dir) {
       }
       await mkdir(dirname(blobPath(dir, hash)), { recursive: true });
       const size = (await stat(temp)).size;
-      await rename(temp, blobPath(dir, hash));
+      await renameWithRetryAsync(temp, blobPath(dir, hash));
       sizes.set(hash, size);
       total += size;
       return hash;
@@ -634,7 +644,7 @@ async function openBlobStore(dir) {
       }
       const to = blobPath(asideDir, hash);
       await mkdir(dirname(to), { recursive: true });
-      const moved = remove && await rename(absPath, to).then(
+      const moved = remove && await renameWithRetryAsync(absPath, to).then(
         () => true,
         () => false
       );
@@ -644,7 +654,7 @@ async function openBlobStore(dir) {
           await rm(temp, { force: true });
           throw error;
         });
-        await rename(temp, to);
+        await renameWithRetryAsync(temp, to);
       }
       asideSizes.set(hash, (await stat(to)).size);
       holds.set(hash, /* @__PURE__ */ new Set([path]));
@@ -699,7 +709,7 @@ function uncopiedOnlyHashes(log, sizeOf) {
 
 // src/history/pruneHistories.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync2, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync, 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";
@@ -863,7 +873,7 @@ function recheckAndMoveAway(historyRoot, id, { now, dryRun, tempDir }) {
   if (projectDir === null) return null;
   if (dryRun) return { projectDir, trash: null };
   const trash = join4(historyRoot, `${PRUNED_PREFIX}${id}-${randomUUID5()}`);
-  renameSync2(home, trash);
+  renameSync(home, trash);
   return { projectDir, trash };
 }
 function abandonedProject(home, id, now, tempDir) {
@@ -922,7 +932,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 renameSync3, statSync as statSync4 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync2, readFileSync as readFileSync8, renameSync as renameSync2, statSync as statSync4 } from "fs";
 import { isAbsolute as isAbsolute4, join as join7, resolve as resolve6 } from "path";
 import { replaceFileAtomically as replaceFileAtomically4 } from "@hyperframes/core/atomic-file";
 
@@ -1323,7 +1333,7 @@ async function updateState(dir, update) {
       state = readState(dir);
     } catch (error) {
       if (!(error instanceof SyntaxError)) throw error;
-      renameSync3(statePath(dir), `${statePath(dir)}.invalid-${randomUUID6()}`);
+      renameSync2(statePath(dir), `${statePath(dir)}.invalid-${randomUUID6()}`);
       state = emptyState();
     }
     update(state);

package/dist/{chunk-OAHY2RQP.js → chunk-C3KTZ7G3.js}

@@ -1,14 +1,14 @@
 import {
   PROXY_PARAMS_VERSION,
   resolveProxy
-} from "./chunk-MNJZQCBL.js";
+} from "./chunk-2B5SR4RJ.js";
 import {
   createMediaCodecProbeCache,
   proxyVariantFor,
   recordProxyPrewarm,
   scanProjectMedia,
   shouldPrewarmProxy
-} from "./chunk-JKPLDWAB.js";
+} from "./chunk-FUTDRYQK.js";
 
 // src/helpers/mediaProxyPreview.ts
 import { resolve } from "path";

package/dist/{chunk-QZWVJKLI.js → chunk-EGNSA3MU.js}

@@ -1,3 +1,6 @@
+import {
+  probeAudioTrack
+} from "./chunk-X73QTST2.js";
 import {
   resolveWithinProject
 } from "./chunk-QF7MFJJU.js";
@@ -318,16 +321,29 @@ function updateAudioVolume(html, id, volume) {
   }
   return html.slice(0, insertion) + ` data-volume="${value}"` + html.slice(insertion);
 }
-function loudnessMeasureArgs(file, tag) {
+function loudnessMeasureArgs(file, tag, stream) {
   const args = ["-hide_banner", "-nostats"];
   if (tag.mediaStart > 0) args.push("-ss", String(tag.mediaStart));
   const sourceSpan = tag.duration === null ? null : tag.duration * (tag.playbackRate ?? 1);
   if (sourceSpan !== null && sourceSpan > 0) args.push("-t", String(sourceSpan));
-  args.push("-i", file, "-map", "0:a:0", "-vn", "-af", "ebur128=peak=true", "-f", "null", "-");
+  args.push(
+    "-i",
+    file,
+    "-map",
+    `0:a:${stream}`,
+    "-vn",
+    "-af",
+    "ebur128=peak=true",
+    "-f",
+    "null",
+    "-"
+  );
   return args;
 }
 async function measureAudio(ffmpegPath, file, tag) {
-  const result = await execFileAsync(ffmpegPath, loudnessMeasureArgs(file, tag), {
+  const track = await probeAudioTrack(file);
+  if (!track) throw new Error("no audio stream to measure");
+  const result = await execFileAsync(ffmpegPath, loudnessMeasureArgs(file, tag, track.stream), {
     encoding: "utf8",
     maxBuffer: 16 * 1024 * 1024,
     timeout: FFMPEG_TIMEOUT_MS,

package/dist/{chunk-JKPLDWAB.js → chunk-FUTDRYQK.js}

@@ -1,3 +1,6 @@
+import {
+  probeMediaMetadata
+} from "./chunk-X73QTST2.js";
 import {
   realpath
 } from "./chunk-QF7MFJJU.js";
@@ -6,6 +9,34 @@ import {
 import { scanHtmlOpeningTags, decodeAuthoredAttribute } from "@hyperframes/parsers";
 import { statSync } from "fs";
 import { sep } from "path";
+import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
+
+// src/helpers/hdrFilters.ts
+import { spawn } from "child_process";
+var checks = /* @__PURE__ */ new Map();
+function ffmpegHasHdrFilters(ffmpegPath) {
+  const known = checks.get(ffmpegPath);
+  if (known) return known;
+  const check = new Promise((resolveCheck) => {
+    const proc = spawn(ffmpegPath, ["-hide_banner", "-filters"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.on("error", () => resolveCheck(false));
+    proc.on(
+      "close",
+      (code) => resolveCheck(code === 0 && /\bzscale\b/.test(stdout) && /\btonemap\b/.test(stdout))
+    );
+  });
+  checks.set(ffmpegPath, check);
+  return check;
+}
+
+// src/helpers/mediaCodecMap.ts
 import { rewriteAssetPath } from "@hyperframes/parsers/asset-paths";
 import {
   cleanAssetUrl,
@@ -16,176 +47,6 @@ import {
 import {
   isHeavyForPreview
 } from "@hyperframes/core";
-
-// src/helpers/mediaMetadata.ts
-import { execFile } from "child_process";
-import { extname } from "path";
-import {
-  firstFrameColourArgs,
-  parseFirstFrameColour
-} from "@hyperframes/core";
-import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
-import { videoStreamHasAlpha } from "@hyperframes/parsers/media-alpha";
-var execFileRunner = (command, args, options) => new Promise((resolvePromise) => {
-  execFile(
-    command,
-    args,
-    { timeout: options?.timeout, maxBuffer: options?.maxBuffer, windowsHide: true },
-    (error, stdout, stderr) => {
-      if (error && error.code === "ENOENT") {
-        resolvePromise({ status: null, stdout: "", stderr: "", error });
-        return;
-      }
-      if (error) {
-        const status = typeof error.code === "number" ? error.code : 1;
-        resolvePromise({ status, stdout: stdout ?? "", stderr: stderr ?? "" });
-        return;
-      }
-      resolvePromise({ status: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
-    }
-  );
-});
-var VIDEO_EXT = /* @__PURE__ */ new Set([
-  ".mp4",
-  ".mov",
-  ".webm",
-  ".mkv",
-  ".avi",
-  ".m4v",
-  ".mxf",
-  ".mts",
-  ".m2ts",
-  ".ts"
-]);
-var IMAGE_EXT = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".avif"]);
-var AUDIO_EXT = /* @__PURE__ */ new Set([".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac"]);
-function lower(value) {
-  return value?.toLowerCase() ?? "";
-}
-function inferKindFromPath(path) {
-  const ext = extname(path).toLowerCase();
-  if (VIDEO_EXT.has(ext)) return "video";
-  if (IMAGE_EXT.has(ext)) return "image";
-  if (AUDIO_EXT.has(ext)) return "audio";
-  return "unknown";
-}
-function colorLabel(input) {
-  if (input.isHdr) {
-    if (input.hdrTransfer === "pq") return "HDR PQ";
-    if (input.hdrTransfer === "hlg") return "HDR HLG";
-    return "HDR";
-  }
-  if (input.colorPrimaries.includes("bt709") || input.colorSpace.includes("bt709") || input.colorTransfer.includes("bt709")) {
-    return "SDR Rec.709";
-  }
-  return "SDR/unknown";
-}
-function classifyMediaColor(stream) {
-  const colorPrimaries = lower(stream?.color_primaries);
-  const colorSpace = lower(stream?.color_space);
-  const colorTransfer = lower(stream?.color_transfer);
-  const isHdr = colorPrimaries.includes("bt2020") || colorSpace.includes("bt2020") || colorTransfer === "smpte2084" || colorTransfer === "arib-std-b67";
-  const hdrTransfer = isHdr ? colorTransfer === "smpte2084" ? "pq" : colorTransfer === "arib-std-b67" ? "hlg" : "unknown" : null;
-  return {
-    dynamicRange: stream ? isHdr ? "hdr" : "sdr" : "unknown",
-    hdrTransfer,
-    label: stream ? colorLabel({ isHdr, hdrTransfer, colorPrimaries, colorSpace, colorTransfer }) : "Unknown",
-    isHdr,
-    codecName: stream?.codec_name,
-    profile: stream?.profile,
-    pixelFormat: stream?.pix_fmt,
-    colorSpace: stream?.color_space,
-    colorTransfer: stream?.color_transfer,
-    colorPrimaries: stream?.color_primaries,
-    bitsPerRawSample: stream?.bits_per_raw_sample
-  };
-}
-async function probeFirstFrameColour(filePath, runner = execFileRunner) {
-  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true }) ?? (runner === execFileRunner ? void 0 : "ffmpeg");
-  if (!ffmpegPath) return {};
-  const result = await runner(ffmpegPath, firstFrameColourArgs(filePath), {
-    timeout: 15e3,
-    maxBuffer: 1024 * 1024
-  });
-  return result.status === 0 ? parseFirstFrameColour(String(result.stderr)) : {};
-}
-function bitDepthOf(stream) {
-  const raw = Number(stream.bits_per_raw_sample);
-  if (Number.isFinite(raw) && raw > 0) return raw;
-  const suffixed = /(\d{1,3})(?:le|be)$/.exec(stream.pix_fmt ?? "");
-  return suffixed ? Number(suffixed[1]) : 8;
-}
-function sourceFactsOf(stream, formatBitrate) {
-  if (!stream?.width || !stream.height) return void 0;
-  const bitrate = Number(stream.bit_rate ?? formatBitrate);
-  return {
-    width: stream.width,
-    height: stream.height,
-    bitDepth: bitDepthOf(stream),
-    bitrate: Number.isFinite(bitrate) ? bitrate : 0
-  };
-}
-var STREAM_SUMMARY_MAX = 12;
-function summarizeStream(stream) {
-  const flags = Object.entries(stream.disposition ?? {}).filter(([, on]) => on === 1).map(([name]) => name);
-  return `${stream.codec_type ?? "?"}:${stream.codec_name ?? "?"}[${flags.join(",")}]`;
-}
-function metadataFromProbe(kind, parsed) {
-  const stream = parsed.streams?.find((item) => {
-    if (kind === "image") return item.codec_type === "video";
-    return item.codec_type === kind && item.disposition?.attached_pic !== 1;
-  });
-  const metadata = {
-    kind,
-    color: classifyMediaColor(stream),
-    streams: (parsed.streams ?? []).slice(0, STREAM_SUMMARY_MAX).map(summarizeStream)
-  };
-  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;
-    metadata.source = sourceFactsOf(stream, parsed.format?.bit_rate);
-  }
-  return metadata;
-}
-async function probeMediaMetadata(filePath, runner = execFileRunner) {
-  const kind = inferKindFromPath(filePath);
-  if (kind === "audio" || kind === "unknown") {
-    return { kind, color: classifyMediaColor(null) };
-  }
-  const ffprobePath = findFfBinary("ffprobe", { configuredMustExist: true }) ?? (runner === execFileRunner ? void 0 : "ffprobe");
-  if (!ffprobePath) {
-    return { kind, color: classifyMediaColor(null), probeError: "ffprobe unavailable" };
-  }
-  const result = await runner(
-    ffprobePath,
-    [
-      "-v",
-      "error",
-      "-show_entries",
-      "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample,width,height,bit_rate:stream_disposition:stream_tags=alpha_mode:format=duration,bit_rate",
-      "-of",
-      "json",
-      "--",
-      filePath
-    ],
-    { timeout: 15e3, maxBuffer: 1024 * 1024 }
-  );
-  if (result.error?.code === "ENOENT") {
-    return { kind, color: classifyMediaColor(null), probeError: "ffprobe unavailable" };
-  }
-  if (result.status !== 0) {
-    return { kind, color: classifyMediaColor(null), probeError: "ffprobe failed" };
-  }
-  try {
-    return metadataFromProbe(kind, JSON.parse(String(result.stdout || "{}")));
-  } catch {
-    return { kind, color: classifyMediaColor(null), probeError: "ffprobe returned invalid json" };
-  }
-}
-
-// src/helpers/mediaCodecMap.ts
 var BROWSER_HOSTILE_CODECS = {
   // HEVC decode is platform-bound, not absent: macOS Chrome answers
   // canPlayType with "probably" and keeps the source, while Chrome on
@@ -258,12 +119,13 @@ function decideMediaProxyEligibility(facts, lightBox) {
   }
   return { eligible: false, reason: "browser_safe_codec" };
 }
-function codecFactsFor(codecName, hasAlpha, source) {
+function codecFactsFor(codecName, hasAlpha, source, toneMapsToSdr = false) {
   const hostile = hostileCodecEntry(codecName);
   return {
     codecName,
-    browserHostile: hostile !== void 0,
-    representativeMime: hostile?.representativeMime ?? null,
+    browserHostile: hostile !== void 0 || toneMapsToSdr,
+    // An HDR clip is never 'playable' for preview, whatever its codec: it takes the SDR copy the export uses.
+    representativeMime: toneMapsToSdr ? null : hostile?.representativeMime ?? null,
     hasAlpha,
     ...source && { source }
   };
@@ -274,7 +136,22 @@ async function probeCodecFacts(filePath, runner) {
   if (metadata.kind !== "video") return null;
   const codecName = metadata.color.codecName;
   if (!codecName) return null;
-  return codecFactsFor(codecName, metadata.hasAlpha === true, metadata.source);
+  const hasAlpha = metadata.hasAlpha === true;
+  const toneMaps = !hasAlpha && await toneMapsHdr(metadata.color.hdrTransfer);
+  return codecFactsFor(codecName, hasAlpha, metadata.source, toneMaps);
+}
+var warnedNoHdrFilters = false;
+async function toneMapsHdr(hdrTransfer) {
+  if (hdrTransfer !== "pq" && hdrTransfer !== "hlg") return false;
+  const ffmpegPath = findFfBinary("ffmpeg");
+  if (ffmpegPath && await ffmpegHasHdrFilters(ffmpegPath)) return true;
+  if (!warnedNoHdrFilters) {
+    warnedNoHdrFilters = true;
+    console.warn(
+      `[hyperframes] A video in this project is HDR, but this ffmpeg has no zscale/tonemap (libzimg), so the preview plays it as the browser shows it and will not match an SDR export. Install an ffmpeg with libzimg.`
+    );
+  }
+  return false;
 }
 function createMediaCodecProbeCache() {
   return /* @__PURE__ */ new Map();
@@ -368,8 +245,7 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
 }
 
 export {
-  probeFirstFrameColour,
-  probeMediaMetadata,
+  ffmpegHasHdrFilters,
   BROWSER_HOSTILE_CODECS,
   shouldPrewarmProxy,
   mediaProxyDemand,

package/dist/chunk-X73QTST2.js

@@ -0,0 +1,192 @@
+// src/helpers/mediaMetadata.ts
+import { execFile } from "child_process";
+import { extname } from "path";
+import {
+  firstFrameColourArgs,
+  parseFirstFrameColour
+} from "@hyperframes/core";
+import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
+import { videoStreamHasAlpha } from "@hyperframes/parsers/media-alpha";
+import { decodableAudioStream } from "@hyperframes/parsers/media-streams";
+var execFileRunner = (command, args, options) => new Promise((resolvePromise) => {
+  execFile(
+    command,
+    args,
+    { timeout: options?.timeout, maxBuffer: options?.maxBuffer, windowsHide: true },
+    (error, stdout, stderr) => {
+      if (error && error.code === "ENOENT") {
+        resolvePromise({ status: null, stdout: "", stderr: "", error });
+        return;
+      }
+      if (error) {
+        const status = typeof error.code === "number" ? error.code : 1;
+        resolvePromise({ status, stdout: stdout ?? "", stderr: stderr ?? "" });
+        return;
+      }
+      resolvePromise({ status: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
+    }
+  );
+});
+var VIDEO_EXT = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".mov",
+  ".webm",
+  ".mkv",
+  ".avi",
+  ".m4v",
+  ".mxf",
+  ".mts",
+  ".m2ts",
+  ".ts"
+]);
+var IMAGE_EXT = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".avif"]);
+var AUDIO_EXT = /* @__PURE__ */ new Set([".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac"]);
+function lower(value) {
+  return value?.toLowerCase() ?? "";
+}
+function inferKindFromPath(path) {
+  const ext = extname(path).toLowerCase();
+  if (VIDEO_EXT.has(ext)) return "video";
+  if (IMAGE_EXT.has(ext)) return "image";
+  if (AUDIO_EXT.has(ext)) return "audio";
+  return "unknown";
+}
+function colorLabel(input) {
+  if (input.isHdr) {
+    if (input.hdrTransfer === "pq") return "HDR PQ";
+    if (input.hdrTransfer === "hlg") return "HDR HLG";
+    return "HDR";
+  }
+  if (input.colorPrimaries.includes("bt709") || input.colorSpace.includes("bt709") || input.colorTransfer.includes("bt709")) {
+    return "SDR Rec.709";
+  }
+  return "SDR/unknown";
+}
+function classifyMediaColor(stream) {
+  const colorPrimaries = lower(stream?.color_primaries);
+  const colorSpace = lower(stream?.color_space);
+  const colorTransfer = lower(stream?.color_transfer);
+  const isHdr = colorPrimaries.includes("bt2020") || colorSpace.includes("bt2020") || colorTransfer === "smpte2084" || colorTransfer === "arib-std-b67";
+  const hdrTransfer = isHdr ? colorTransfer === "smpte2084" ? "pq" : colorTransfer === "arib-std-b67" ? "hlg" : "unknown" : null;
+  return {
+    dynamicRange: stream ? isHdr ? "hdr" : "sdr" : "unknown",
+    hdrTransfer,
+    label: stream ? colorLabel({ isHdr, hdrTransfer, colorPrimaries, colorSpace, colorTransfer }) : "Unknown",
+    isHdr,
+    codecName: stream?.codec_name,
+    profile: stream?.profile,
+    pixelFormat: stream?.pix_fmt,
+    colorSpace: stream?.color_space,
+    colorTransfer: stream?.color_transfer,
+    colorPrimaries: stream?.color_primaries,
+    bitsPerRawSample: stream?.bits_per_raw_sample
+  };
+}
+async function probeFirstFrameColour(filePath, runner = execFileRunner) {
+  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true }) ?? (runner === execFileRunner ? void 0 : "ffmpeg");
+  if (!ffmpegPath) return {};
+  const result = await runner(ffmpegPath, firstFrameColourArgs(filePath), {
+    timeout: 15e3,
+    maxBuffer: 1024 * 1024
+  });
+  return result.status === 0 ? parseFirstFrameColour(String(result.stderr)) : {};
+}
+function bitDepthOf(stream) {
+  const raw = Number(stream.bits_per_raw_sample);
+  if (Number.isFinite(raw) && raw > 0) return raw;
+  const suffixed = /(\d{1,3})(?:le|be)$/.exec(stream.pix_fmt ?? "");
+  return suffixed ? Number(suffixed[1]) : 8;
+}
+function sourceFactsOf(stream, formatBitrate) {
+  if (!stream?.width || !stream.height) return void 0;
+  const bitrate = Number(stream.bit_rate ?? formatBitrate);
+  return {
+    width: stream.width,
+    height: stream.height,
+    bitDepth: bitDepthOf(stream),
+    bitrate: Number.isFinite(bitrate) ? bitrate : 0
+  };
+}
+var STREAM_SUMMARY_MAX = 12;
+function summarizeStream(stream) {
+  const flags = Object.entries(stream.disposition ?? {}).filter(([, on]) => on === 1).map(([name]) => name);
+  return `${stream.codec_type ?? "?"}:${stream.codec_name ?? "?"}[${flags.join(",")}]`;
+}
+function audioOf(streams) {
+  const audioStream = decodableAudioStream(streams);
+  return audioStream === null ? { hasAudio: false } : { hasAudio: true, audioStream };
+}
+function metadataFromProbe(kind, parsed) {
+  const stream = parsed.streams?.find((item) => {
+    if (kind === "image") return item.codec_type === "video";
+    return item.codec_type === kind && item.disposition?.attached_pic !== 1;
+  });
+  const metadata = {
+    kind,
+    color: classifyMediaColor(stream),
+    streams: (parsed.streams ?? []).slice(0, STREAM_SUMMARY_MAX).map(summarizeStream)
+  };
+  if (kind === "video") {
+    Object.assign(metadata, audioOf(parsed.streams ?? []));
+    metadata.hasAlpha = stream !== void 0 && videoStreamHasAlpha(stream);
+    const duration = Number(parsed.format?.duration);
+    if (Number.isFinite(duration) && duration > 0) metadata.durationSeconds = duration;
+    metadata.source = sourceFactsOf(stream, parsed.format?.bit_rate);
+  }
+  return metadata;
+}
+async function probeAudioTrack(filePath, runner = execFileRunner) {
+  const result = await runner(
+    findFfBinary("ffprobe") ?? "ffprobe",
+    [
+      ...["-v", "error", "-select_streams", "a"],
+      ...["-show_entries", "stream=codec_type,codec_name,channels", "-of", "json", "--", filePath]
+    ],
+    { timeout: 3e4 }
+  );
+  if (result.status !== 0) return null;
+  const streams = JSON.parse(String(result.stdout || "{}")).streams ?? [];
+  const stream = decodableAudioStream(streams);
+  return stream === null ? null : { stream, channels: streams[stream]?.channels ?? 0 };
+}
+async function probeMediaMetadata(filePath, runner = execFileRunner) {
+  const kind = inferKindFromPath(filePath);
+  if (kind === "audio" || kind === "unknown") {
+    return { kind, color: classifyMediaColor(null) };
+  }
+  const ffprobePath = findFfBinary("ffprobe", { configuredMustExist: true }) ?? (runner === execFileRunner ? void 0 : "ffprobe");
+  if (!ffprobePath) {
+    return { kind, color: classifyMediaColor(null), probeError: "ffprobe unavailable" };
+  }
+  const result = await runner(
+    ffprobePath,
+    [
+      "-v",
+      "error",
+      "-show_entries",
+      "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample,width,height,bit_rate:stream_disposition:stream_tags=alpha_mode:format=duration,bit_rate",
+      "-of",
+      "json",
+      "--",
+      filePath
+    ],
+    { timeout: 15e3, maxBuffer: 1024 * 1024 }
+  );
+  if (result.error?.code === "ENOENT") {
+    return { kind, color: classifyMediaColor(null), probeError: "ffprobe unavailable" };
+  }
+  if (result.status !== 0) {
+    return { kind, color: classifyMediaColor(null), probeError: "ffprobe failed" };
+  }
+  try {
+    return metadataFromProbe(kind, JSON.parse(String(result.stdout || "{}")));
+  } catch {
+    return { kind, color: classifyMediaColor(null), probeError: "ffprobe returned invalid json" };
+  }
+}
+
+export {
+  probeFirstFrameColour,
+  probeAudioTrack,
+  probeMediaMetadata
+};

package/dist/helpers/loudness.d.ts

@@ -57,7 +57,7 @@ declare function updateAudioVolume(html: string, id: string, volume: number): st
  * -61.8 LUFS: output-side `-t 4` reported -33.8 LUFS, input-side reports -61.8,
  * the same as physically cutting the file first.
  */
-declare function loudnessMeasureArgs(file: string, tag: MeasuredWindow): string[];
+declare function loudnessMeasureArgs(file: string, tag: MeasuredWindow, stream: number): string[];
 type MeasuredWindow = Pick<AudioTag, "mediaStart" | "duration"> & Partial<Pick<AudioTag, "playbackRate">>;
 declare function measureAudio(ffmpegPath: string, file: string, tag: MeasuredWindow): Promise<LoudnessMeasurement>;
 declare function requiredFfmpeg(): string;

package/dist/helpers/loudness.js

@@ -11,7 +11,8 @@ import {
   requiredFfmpeg,
   resolveLocalAudioPath,
   updateAudioVolume
-} from "../chunk-QZWVJKLI.js";
+} from "../chunk-EGNSA3MU.js";
+import "../chunk-X73QTST2.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/helpers/mediaCodecMap.js

@@ -14,7 +14,8 @@ import {
   scanProjectMedia,
   scanProjectMediaCodecMap,
   shouldPrewarmProxy
-} from "../chunk-JKPLDWAB.js";
+} from "../chunk-FUTDRYQK.js";
+import "../chunk-X73QTST2.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/helpers/mediaProxyPreview.js

@@ -4,9 +4,10 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "../chunk-OAHY2RQP.js";
-import "../chunk-MNJZQCBL.js";
-import "../chunk-JKPLDWAB.js";
+} from "../chunk-C3KTZ7G3.js";
+import "../chunk-2B5SR4RJ.js";
+import "../chunk-FUTDRYQK.js";
+import "../chunk-X73QTST2.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/helpers/proxyTranscoder.js

@@ -20,8 +20,9 @@ import {
   retryProxyCopy,
   sourceFolderKind,
   waitForProxy
-} from "../chunk-MNJZQCBL.js";
-import "../chunk-JKPLDWAB.js";
+} from "../chunk-2B5SR4RJ.js";
+import "../chunk-FUTDRYQK.js";
+import "../chunk-X73QTST2.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/history/index.js

@@ -22,7 +22,7 @@ import {
   recordRenderSuccess,
   registerRenderOutput,
   retainSnapshotOutput
-} from "../chunk-WAMZ2Z5O.js";
+} from "../chunk-BWZMWYB2.js";
 import "../chunk-QF7MFJJU.js";
 import "../chunk-SVQFE44C.js";
 import "../chunk-L3HJVTQE.js";

package/dist/index.js

@@ -62,7 +62,7 @@ import {
   resolveProjectSignature,
   retainSnapshotOutput,
   settledFileTag
-} from "./chunk-WAMZ2Z5O.js";
+} from "./chunk-BWZMWYB2.js";
 import {
   clearElementScreenshotIsolation,
   getElementScreenshotClip
@@ -76,13 +76,13 @@ import {
   requestedProjectPath,
   requiredFfmpeg,
   resolveLocalAudioPath
-} from "./chunk-QZWVJKLI.js";
+} from "./chunk-EGNSA3MU.js";
 import {
   injectMediaCodecMap,
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "./chunk-OAHY2RQP.js";
+} from "./chunk-C3KTZ7G3.js";
 import {
   CACHE_DIR_NAME,
   PROXY_PENDING_RETRY_AFTER_SECONDS,
@@ -95,16 +95,19 @@ import {
   resolveProxy,
   retryProxyCopy,
   waitForProxy
-} from "./chunk-MNJZQCBL.js";
+} from "./chunk-2B5SR4RJ.js";
 import {
   PROXY_VARIANT_CONFIG,
   decideMediaProxyEligibility,
   isProxyVariantRequest,
   probeAssetCodec,
-  probeMediaMetadata,
   recordProxyRequest,
   resolveProxyVariantRequest
-} from "./chunk-JKPLDWAB.js";
+} from "./chunk-FUTDRYQK.js";
+import {
+  probeAudioTrack,
+  probeMediaMetadata
+} from "./chunk-X73QTST2.js";
 import {
   folderGone,
   isInHiddenOrVendorDir,
@@ -315,6 +318,33 @@ function insertGsapCoreBeforeHeadPlugin(html, coreTag) {
 ${html.slice(at)}`;
 }
 
+// src/helpers/rootPaths.ts
+import { mapStartTagsAndStyles } from "@hyperframes/core/compiler/html-document";
+var ROOT_PATH = /^\/(?!\/)/;
+var PATH_ATTR = /(\s(?:src|href|poster|xlink:href)\s*=\s*)(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi;
+var CSS_ROOT_URL = /(\burl\(\s*)(["']?)(\/(?!\/)[^"')\s]*)\2/gi;
+var projectRelative = (path, base) => ROOT_PATH.test(path) && path !== "/" && !path.startsWith(base) ? path.slice(1) : path;
+var underBase = (path, base) => {
+  const relative5 = projectRelative(path, base);
+  return relative5 === path ? path : base + relative5;
+};
+function withRootPathsRelative(html, base) {
+  const css = (text2) => text2.replace(
+    CSS_ROOT_URL,
+    (_m, open2, quote, path) => `${open2}${quote}${projectRelative(path, base)}${quote}`
+  );
+  const attrs = (tag) => tag.replace(PATH_ATTR, (whole, name, dq, sq, bare) => {
+    const path = (dq ?? sq ?? bare ?? "").trim();
+    const moved = projectRelative(path, base);
+    if (moved === path) return whole;
+    return dq !== void 0 ? `${name}"${moved}"` : sq !== void 0 ? `${name}'${moved}'` : `${name}${moved}`;
+  });
+  return mapStartTagsAndStyles(html, {
+    tag: (tag) => /^<(?:a|base)[\s/>]/i.test(tag) ? tag : css(attrs(tag)),
+    style: css
+  });
+}
+
 // src/helpers/subComposition.ts
 function rewriteRelativePaths(root, compPath, projectDir) {
   const assetExists = (path) => existsSync(join2(projectDir, path));
@@ -463,6 +493,10 @@ ${headContent}`;
   }
   if (compHeadContent) headContent += `
 ${compHeadContent}`;
+  if (baseHref) {
+    headContent = withRootPathsRelative(headContent, baseHref);
+    rewrittenContent = withRootPathsRelative(rewrittenContent, baseHref);
+  }
   headContent = stripEmbeddedRuntimeScripts(headContent);
   headContent += `
 <script ${RUNTIME_BOOTSTRAP_ATTR}="1" src="${runtimeUrl}"></script>`;
@@ -836,13 +870,17 @@ function computePeaks(floats, count) {
   const maxPeak = Math.max(...peaks, 1e-3);
   return peaks.map((p) => p / maxPeak);
 }
-function decodeAudioPeaks(audioPath) {
+async function decodeAudioPeaks(audioPath) {
+  const track = await probeAudioTrack(audioPath);
+  if (!track) throw new Error("no audio stream");
   return new Promise((resolvePromise, reject) => {
     const proc = spawn(
       findFfBinary("ffmpeg") ?? "ffmpeg",
       [
         "-i",
         audioPath,
+        "-map",
+        `0:a:${track.stream}`,
         "-af",
         "atrim=start_sample=1152",
         "-f",
@@ -917,6 +955,7 @@ import { mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeF
 import { tmpdir } from "os";
 import { basename, join as join4 } from "path";
 import { FFPROBE_PATH_ENV, findFfBinary as findFfBinary2 } from "@hyperframes/parsers/ff-binaries";
+import { decodableAudioStream } from "@hyperframes/parsers/media-streams";
 var VIDEO_EXT = /\.(mp4|webm|mov|mkv|avi|m4v|mxf|mts|m2ts|ts)$/i;
 var AUDIO_EXT = /\.(mp3|wav|ogg|m4a|aac|flac)$/i;
 var defaultRunner = spawnSync;
@@ -931,7 +970,7 @@ function validateUploadedMedia(filePath, runner = defaultRunner) {
   if (!ffprobe) return { ok: true, unchecked: FFPROBE_MISSING };
   const result = runner(
     ffprobe,
-    ["-v", "error", "-show_entries", "stream=codec_type", "-of", "json", "--", filePath],
+    ["-v", "error", "-show_entries", "stream=codec_type,codec_name", "-of", "json", "--", filePath],
     { windowsHide: true }
   );
   if (result.error && process.env[FFPROBE_PATH_ENV]?.trim()) {
@@ -953,7 +992,7 @@ function checkStreams(stdout, isVideo, isAudio) {
     const parsed = JSON.parse(stdout);
     const streams = parsed.streams ?? [];
     const hasVideo = streams.some((stream) => stream.codec_type === "video");
-    const hasAudio = streams.some((stream) => stream.codec_type === "audio");
+    const hasAudio = decodableAudioStream(streams) !== null;
     if (isVideo && !hasVideo) {
       return { ok: false, reason: "no supported video stream found" };
     }
@@ -3907,7 +3946,6 @@ import { isWithinProjectRoot } from "@hyperframes/parsers/asset-resolution";
 
 // src/helpers/rootImportMap.ts
 import { findStartTags as findStartTags2, injectTagsAtHeadStart } from "@hyperframes/core/compiler/html-document";
-var ROOT_PATH = /^\/(?!\/)/;
 var IMPORT_MAP_TYPE = /\btype\s*=\s*["']?importmap["']?(?=[\s/>])/i;
 function findImportMap(html) {
   for (const at of findStartTags2(html, "script")) {
@@ -3934,7 +3972,7 @@ function withRootImportMap(html, base) {
     return html;
   }
   if (!map || typeof map !== "object") return html;
-  const under = (path) => ROOT_PATH.test(path) && !path.startsWith(base) ? base + path.slice(1) : path;
+  const under = (path) => underBase(path, base);
   const moved = (entries = {}) => Object.fromEntries(
     Object.entries(entries).map(([key, target]) => [key, under(String(target))])
   );
@@ -4352,7 +4390,7 @@ var PREVIEW_BUNDLE_OPTIONS = {
 var previewBaseHref = (projectId) => `/api/projects/${encodeURIComponent(projectId)}/preview/`;
 var withPreviewBase = (html, projectId) => {
   const base = previewBaseHref(projectId);
-  const mapped = withRootImportMap(html, base);
+  const mapped = withRootImportMap(withRootPathsRelative(html, base), base);
   return hasBaseElement(mapped) ? mapped : injectTagsAtHeadStart2(mapped, `<base href="${base}">`);
 };
 function resolvePreviewGsapBaseUrl(adapter) {
@@ -4397,10 +4435,9 @@ function registerPreviewRoutes(api, adapter) {
         bundled = ensureHfIds2(diskMain.html);
         mainCompositionPath = diskMain.compositionPath;
       }
-      bundled = withPreviewRuntime(bundled, adapter.runtimeUrl);
+      bundled = withPreviewRuntime(withPreviewBase(bundled, project.id), adapter.runtimeUrl);
       recordPreviewReferences(project.dir, bundled);
       recordPreviewBuilt(project.dir);
-      bundled = withPreviewBase(bundled, project.id);
       bundled = injectStudioPreviewAugmentations(
         ensureHfIds2(await transformPreviewHtml(bundled, adapter, project, mainCompositionPath)),
         adapter,
@@ -4425,9 +4462,9 @@ function registerPreviewRoutes(api, adapter) {
     } catch {
       const fallback = resolveProjectMainHtml(project.dir, project.id);
       if (fallback) {
-        const fallbackHtml = withPreviewBase(
-          withPreviewRuntime(ensureHfIds2(fallback.html), adapter.runtimeUrl),
-          project.id
+        const fallbackHtml = withPreviewRuntime(
+          withPreviewBase(ensureHfIds2(fallback.html), project.id),
+          adapter.runtimeUrl
         );
         let fallbackAugmented = injectStudioPreviewAugmentations(
           await transformPreviewHtml(fallbackHtml, adapter, project, fallback.compositionPath),
@@ -5873,12 +5910,10 @@ import { join as join14, resolve as resolve6 } from "path";
 import { isWithinProjectRoot as isWithinProjectRoot3 } from "@hyperframes/parsers/asset-resolution";
 
 // src/helpers/peakMap.ts
-import { execFile as execFile2, spawn as spawn2 } from "child_process";
-import { promisify } from "util";
+import { spawn as spawn2 } from "child_process";
 import { findFfBinary as findFfBinary4 } from "@hyperframes/parsers/ff-binaries";
 var PEAK_BIN_SECONDS = 0.05;
 var PEAK_SAMPLE_RATE = 48e3;
-var execFileAsync = promisify(execFile2);
 var PEAK_MAP_CACHE_VERSION = "peaks-v2";
 function createPeakAccumulator(sampleRate = PEAK_SAMPLE_RATE, binSeconds = PEAK_BIN_SECONDS, channels = 2) {
   return {
@@ -5912,29 +5947,10 @@ function accumulatePeaks(acc, chunk) {
 function finishPeaks(acc) {
   return acc.bins.map((peak) => Number(peak.toFixed(4)));
 }
-async function probeChannels(mediaPath) {
-  const { stdout } = await execFileAsync(
-    findFfBinary4("ffprobe") ?? "ffprobe",
-    [
-      "-v",
-      "error",
-      "-select_streams",
-      "a:0",
-      "-show_entries",
-      "stream=channels",
-      "-of",
-      "csv=p=0",
-      "--",
-      mediaPath
-    ],
-    { encoding: "utf8", timeout: 3e4, windowsHide: true }
-  );
-  const channels = Number.parseInt(stdout.trim(), 10);
-  if (!Number.isFinite(channels) || channels < 1) throw new Error("no audio stream");
-  return channels;
-}
 async function decodePeakMap(mediaPath) {
-  const channels = await probeChannels(mediaPath);
+  const track = await probeAudioTrack(mediaPath);
+  if (!track || track.channels < 1) throw new Error("no audio stream");
+  const { stream, channels } = track;
   return new Promise((resolvePromise, reject) => {
     const proc = spawn2(
       findFfBinary4("ffmpeg") ?? "ffmpeg",
@@ -5944,7 +5960,7 @@ async function decodePeakMap(mediaPath) {
         "-i",
         mediaPath,
         "-map",
-        "0:a:0",
+        `0:a:${stream}`,
         "-vn",
         "-ar",
         String(PEAK_SAMPLE_RATE),

package/package.json

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