@hyperframes/studio-server 0.8.207 → 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-OSZE5WT3.js → chunk-BWZMWYB2.js}

@@ -20,7 +20,7 @@ import {
 } from "fs";
 import { homedir } from "os";
 import { dirname as dirname5, isAbsolute as isAbsolute5, join as join8, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
-import { replaceFileAtomically as replaceFileAtomically5 } from "@hyperframes/core/atomic-file";
+import { replaceFileAtomically as replaceFileAtomically6 } from "@hyperframes/core/atomic-file";
 
 // src/helpers/fileVersion.ts
 import { createHash, randomUUID } from "crypto";
@@ -103,22 +103,15 @@ var consumeFileWriteReceipt = identifyFileWrite;
 // src/helpers/renderOutputs.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { isAbsolute, relative, resolve, sep } from "path";
-import { replaceFileAtomically } from "@hyperframes/core/atomic-file";
+import { replaceFileAtomically as replaceFileAtomically2 } from "@hyperframes/core/atomic-file";
 
 // src/history/ownerLock.ts
 import { spawnSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import {
-  linkSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync
-} from "fs";
+import { linkSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { uptime } from "os";
 import { join } from "path";
+import { replaceFileAtomically } from "@hyperframes/core/atomic-file";
 var HistoryBusyError = class extends Error {
   constructor(pid, url) {
     super(`This project's history is open in another process (pid ${pid}).`);
@@ -211,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 });
   }
@@ -226,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;
@@ -258,9 +260,7 @@ function evictDeadOwner(file) {
 }
 function advertise(urlFile, url) {
   if (!url) return rmSync(urlFile, { force: true });
-  const draft = `${urlFile}-${process.pid}-${randomUUID2()}.tmp`;
-  writeFileSync(draft, JSON.stringify({ pid: process.pid, url }));
-  renameSync(draft, urlFile);
+  replaceFileAtomically(urlFile, JSON.stringify({ pid: process.pid, url }));
 }
 function servedBy(file, urlFile, pid) {
   try {
@@ -294,7 +294,12 @@ async function takeHistoryOwnership(home, waitMs, url) {
     if (next === "claimed") break;
     if (next === "wait") await new Promise((settle) => setTimeout(settle, 50));
   }
-  advertise(urlFile, url);
+  try {
+    advertise(urlFile, url);
+  } catch (error) {
+    releaseOwn(file);
+    throw error;
+  }
   let held = true;
   return () => {
     if (held && servedBy(file, urlFile, process.pid)) rmSync(urlFile, { force: true });
@@ -344,7 +349,7 @@ async function registerRenderOutput(projectDir, output) {
   const release = await takeHistoryOwnership(lock, 5e3);
   try {
     const paths = [.../* @__PURE__ */ new Set([...readRenderOutputs(projectDir), path])].sort();
-    replaceFileAtomically(registry, JSON.stringify({ version: 1, paths }) + "\n", 420);
+    replaceFileAtomically2(registry, JSON.stringify({ version: 1, paths }) + "\n", 420);
   } finally {
     release();
   }
@@ -528,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 as renameSync2 } 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.");
@@ -558,7 +564,7 @@ async function cloneOrCopy(from, to, beforeReplace) {
   try {
     await copyFile(from, temp, constants.COPYFILE_FICLONE);
     beforeReplace?.();
-    renameSync2(temp, to);
+    renameWithRetry(temp, to);
   } catch (error) {
     await rm(temp, { force: true });
     throw error;
@@ -614,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;
@@ -638,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
       );
@@ -648,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]));
@@ -703,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 renameSync3, 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";
@@ -712,7 +718,7 @@ import { dirname as dirname2, join as join4 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 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";
+import { replaceFileAtomically as replaceFileAtomically3 } from "@hyperframes/core/atomic-file";
 var ID_PATH = join3(".hyperframes", "history-id");
 var ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var isHistoryId = (name) => ID_SHAPE.test(name);
@@ -775,7 +781,7 @@ var HistoryIdError = class extends Error {
 function recordProject(historyDir, dir, folder) {
   const record = { dir, ino: folder.ino, born: folder.birthtimeMs, dev: folder.dev };
   mkdirSync2(historyDir, { recursive: true });
-  replaceFileAtomically2(join3(historyDir, "project.json"), JSON.stringify(record), 420);
+  replaceFileAtomically3(join3(historyDir, "project.json"), JSON.stringify(record), 420);
 }
 
 // src/history/pruneHistories.ts
@@ -867,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()}`);
-  renameSync3(home, trash);
+  renameSync(home, trash);
   return { projectDir, trash };
 }
 function abandonedProject(home, id, now, tempDir) {
@@ -926,9 +932,9 @@ 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 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 replaceFileAtomically3 } from "@hyperframes/core/atomic-file";
+import { replaceFileAtomically as replaceFileAtomically4 } from "@hyperframes/core/atomic-file";
 
 // src/history/artifactCleanup.ts
 import { createHash as createHash4 } from "crypto";
@@ -1327,11 +1333,11 @@ async function updateState(dir, update) {
       state = readState(dir);
     } catch (error) {
       if (!(error instanceof SyntaxError)) throw error;
-      renameSync4(statePath(dir), `${statePath(dir)}.invalid-${randomUUID6()}`);
+      renameSync2(statePath(dir), `${statePath(dir)}.invalid-${randomUUID6()}`);
       state = emptyState();
     }
     update(state);
-    replaceFileAtomically3(statePath(dir), JSON.stringify(state, null, 2) + "\n", 420);
+    replaceFileAtomically4(statePath(dir), JSON.stringify(state, null, 2) + "\n", 420);
   } finally {
     release();
   }
@@ -1534,7 +1540,7 @@ async function finishSnapshotRun(projectDir, path) {
 // src/history/historyLog.ts
 import { closeSync as closeSync3, constants as constants4, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync9, writeSync as writeSync2 } from "fs";
 import { dirname as dirname4 } from "path";
-import { replaceFileAtomically as replaceFileAtomically4 } from "@hyperframes/core/atomic-file";
+import { replaceFileAtomically as replaceFileAtomically5 } from "@hyperframes/core/atomic-file";
 var START = "start";
 function parseRecord(line) {
   try {
@@ -1596,7 +1602,7 @@ function writeLog(file, log) {
     ...[...log.pins].map((id) => ({ type: "pin", id, pinned: true }))
   ];
   mkdirSync4(dirname4(file), { recursive: true });
-  replaceFileAtomically4(file, records2.map((r) => `${JSON.stringify(r)}
+  replaceFileAtomically5(file, records2.map((r) => `${JSON.stringify(r)}
 `).join(""), 420);
 }
 function applyEntry(manifest2, entry, side) {
@@ -1966,7 +1972,7 @@ var Engine = class {
     const file = join8(this.home, "adopting.json");
     if (!this.adopting.size) return rmSync3(file, { force: true });
     mkdirSync5(this.home, { recursive: true });
-    replaceFileAtomically5(file, JSON.stringify([...this.adopting.keys()]), 420);
+    replaceFileAtomically6(file, JSON.stringify([...this.adopting.keys()]), 420);
   }
   async adopt(file, sweptAt) {
     try {
@@ -2018,7 +2024,7 @@ var Engine = class {
   saveStatCache() {
     const files = JSON.stringify(Object.fromEntries(this.tracked));
     mkdirSync5(this.home, { recursive: true });
-    replaceFileAtomically5(join8(this.home, "stat.json"), files, 420);
+    replaceFileAtomically6(join8(this.home, "stat.json"), files, 420);
   }
   /**
    * Takes in every write since the last sweep and files each change to its writer. ponytail: always the whole

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-OSZE5WT3.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-OSZE5WT3.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" };
     }
@@ -3902,8 +3941,50 @@ import {
   normalizeGsapBaseUrl,
   normalizeGsapLocalRoot
 } from "@hyperframes/core/gsap-cdn";
-import { findStartTags as findStartTags3, injectTagsAtHeadStart } from "@hyperframes/core/compiler/html-document";
+import { findStartTags as findStartTags4, injectTagsAtHeadStart as injectTagsAtHeadStart2 } from "@hyperframes/core/compiler/html-document";
 import { isWithinProjectRoot } from "@hyperframes/parsers/asset-resolution";
+
+// src/helpers/rootImportMap.ts
+import { findStartTags as findStartTags2, injectTagsAtHeadStart } from "@hyperframes/core/compiler/html-document";
+var IMPORT_MAP_TYPE = /\btype\s*=\s*["']?importmap["']?(?=[\s/>])/i;
+function findImportMap(html) {
+  for (const at of findStartTags2(html, "script")) {
+    const open2 = /^<script\b[^>]*>/i.exec(html.slice(at));
+    if (!open2 || !IMPORT_MAP_TYPE.test(open2[0])) continue;
+    const start = at + open2[0].length;
+    const end = html.toLowerCase().indexOf("</script", start);
+    if (end !== -1) return { start, end, json: html.slice(start, end) };
+  }
+  return null;
+}
+function withRootImportMap(html, base) {
+  const ours = { "/": base, [base]: base };
+  const own = findImportMap(html);
+  if (!own)
+    return injectTagsAtHeadStart(
+      html,
+      `<script type="importmap">${JSON.stringify({ imports: ours })}</script>`
+    );
+  let map;
+  try {
+    map = JSON.parse(own.json);
+  } catch {
+    return html;
+  }
+  if (!map || typeof map !== "object") return html;
+  const under = (path) => underBase(path, base);
+  const moved = (entries = {}) => Object.fromEntries(
+    Object.entries(entries).map(([key, target]) => [key, under(String(target))])
+  );
+  const merged = { ...map, imports: { ...ours, ...moved(map.imports) } };
+  if (map.scopes)
+    merged.scopes = Object.fromEntries(
+      Object.entries(map.scopes).map(([scope, entries]) => [under(scope), moved(entries)])
+    );
+  return html.slice(0, own.start) + JSON.stringify(merged) + html.slice(own.end);
+}
+
+// src/routes/preview.ts
 import { ensureHfIds as ensureHfIds2 } from "@hyperframes/parsers/hf-ids";
 
 // src/helpers/previewReads.ts
@@ -4037,7 +4118,7 @@ function injectPreviewVariables(html, values) {
 }
 
 // src/helpers/lazyPreviewImages.ts
-import { findStartTags as findStartTags2 } from "@hyperframes/core/compiler/html-document";
+import { findStartTags as findStartTags3 } from "@hyperframes/core/compiler/html-document";
 import { parseHTML as parseHTML6 } from "linkedom";
 import { STUDIO_PREVIEW_LAZY_ATTR } from "@hyperframes/core/studio-preview-mark";
 function startsAfterZero(el) {
@@ -4050,7 +4131,7 @@ var hasLoading = (img) => Array.from(img.attributes).some((attr) => attr.name.to
 function lazyPreviewImages(html) {
   if (!/<!doctype|<html[\s>]/i.test(html)) return html;
   const images = [...parseHTML6(html).document.querySelectorAll("img")];
-  const tags = findStartTags2(html, "img");
+  const tags = findStartTags3(html, "img");
   if (tags.length !== images.length) return html;
   const parts = [];
   let from = 0;
@@ -4136,7 +4217,7 @@ function injectMotionPathPluginIfNeeded(html, baseUrl) {
 }
 function findGsapCoreScript(html) {
   const scripts = [...parseHTML7(html).document.querySelectorAll("script")];
-  const starts = findStartTags3(html, "script");
+  const starts = findStartTags4(html, "script");
   if (starts.length !== scripts.length) return null;
   const at = scripts.findIndex(
     (script) => isGsapCoreUrl(lowerCaseAttributes(script).get("src") ?? "")
@@ -4242,16 +4323,16 @@ var PREVIEW_CAPTURE_PARAM = "hf-capture";
 var EARLY_ERRORS_SCRIPT = `<script>(function(){var seen=window.${STUDIO_PREVIEW_ERRORS}=[];
 addEventListener("error",function(e){seen.push(e.message||String(e))});})();</script>`;
 function injectStudioPreviewAugmentations(html, adapter, projectDir, activeCompositionPath, options) {
-  const marked = options.capture ? injectTagsAtHeadStart(
+  const marked = options.capture ? injectTagsAtHeadStart2(
     html,
     `<meta name="${STUDIO_PREVIEW_MARK_META}" content="${STUDIO_PREVIEW_CAPTURE_MODE}">`
-  ) : injectTagsAtHeadStart(
+  ) : injectTagsAtHeadStart2(
     lazyPreviewImages(html),
     `<meta name="${STUDIO_PREVIEW_MARK_META}">${EARLY_ERRORS_SCRIPT}`
   );
   const withFallback = injectGsapCdnFallback(
     injectProjectSignature(
-      injectTagsAtHeadStart(
+      injectTagsAtHeadStart2(
         marked,
         `<meta name="${GSAP_BASE_URL_META}" content="${escapeGsapUrl(options.gsapBaseUrl)}">`
       ),
@@ -4307,7 +4388,11 @@ var PREVIEW_BUNDLE_OPTIONS = {
   sceneParts: true
 };
 var previewBaseHref = (projectId) => `/api/projects/${encodeURIComponent(projectId)}/preview/`;
-var withPreviewBase = (html, projectId) => hasBaseElement(html) ? html : injectTagsAtHeadStart(html, `<base href="${previewBaseHref(projectId)}">`);
+var withPreviewBase = (html, projectId) => {
+  const base = previewBaseHref(projectId);
+  const mapped = withRootImportMap(withRootPathsRelative(html, base), base);
+  return hasBaseElement(mapped) ? mapped : injectTagsAtHeadStart2(mapped, `<base href="${base}">`);
+};
 function resolvePreviewGsapBaseUrl(adapter) {
   const configured = process.env.HYPERFRAMES_GSAP_BASE_URL;
   if (configured?.trim() || !adapter.gsapLocalRoot) {
@@ -4350,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,
@@ -4378,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),
@@ -4482,6 +4566,7 @@ ${etag}`;
       gsapBaseUrl
     );
     if (!html) return c.text("not found", 404);
+    html = withRootImportMap(html, baseHref);
     recordPreviewReferences(project.dir, html);
     html = ensureHfIds2(await transformPreviewHtml(html, adapter, project, compPath));
     html = injectStudioPreviewAugmentations(html, adapter, project.dir, compPath, {
@@ -5825,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 {
@@ -5864,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",
@@ -5896,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.207",
+  "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.207",
-    "@hyperframes/parsers": "0.8.207"
+    "@hyperframes/core": "0.8.209",
+    "@hyperframes/parsers": "0.8.209"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",