hyperframes 0.8.176 → 0.8.178

package/dist/{chunk-YWSXFFO3.js → chunk-VU4JLRNH.js}

@@ -29,7 +29,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-VEQ7DKPG.js";
+} from "./chunk-AHS5QYKF.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -58,18 +58,22 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-EEXE43II.js";
+} from "./chunk-PLNQW2C6.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
 } from "./chunk-UJKQWGFF.js";
 import {
-  redactTelemetryString
-} from "./chunk-T76PLPD6.js";
+  redactTelemetryString,
+  redactUrlQueryStrings
+} from "./chunk-634HSJ3J.js";
 import {
   chromeMajorCeiling,
-  exceedsChromeCeiling
-} from "./chunk-TWWSYAKJ.js";
+  compareBrowserVersionsDescending,
+  exceedsChromeCeiling,
+  isManagedChromeDir,
+  pickSharedShell
+} from "./chunk-537IYAEE.js";
 import {
   isWithinProjectRoot,
   resolveProjectRelativeSrc
@@ -948,26 +952,6 @@ async function readWebGlInfo(browser) {
     };
   });
 }
-function compareBrowserVersionsDescending(left, right) {
-  const parse = (value) => {
-    const version = value.slice(value.indexOf("-") + 1);
-    const segments = [];
-    for (const segment of version.split(".")) {
-      const parsed = Number.parseInt(segment, 10);
-      if (!Number.isFinite(parsed)) break;
-      segments.push(parsed);
-    }
-    return segments;
-  };
-  const leftSegments = parse(left);
-  const rightSegments = parse(right);
-  const length = Math.max(leftSegments.length, rightSegments.length);
-  for (let index = 0; index < length; index += 1) {
-    const difference = (rightSegments[index] ?? 0) - (leftSegments[index] ?? 0);
-    if (difference !== 0) return difference;
-  }
-  return 0;
-}
 var CACHED_HEADLESS_SHELL_EXECUTABLES = {
   "darwin/arm64": ["chrome-headless-shell-mac-arm64", "chrome-headless-shell"],
   "darwin/x64": ["chrome-headless-shell-mac-x64", "chrome-headless-shell"],
@@ -1002,6 +986,29 @@ function findCachedHeadlessShell(baseDir) {
   }
   return void 0;
 }
+function findSharedHeadlessShell(baseDir) {
+  const executable = cachedHeadlessShellExecutable();
+  if (!executable || !existsSync(baseDir)) return void 0;
+  try {
+    return pickSharedShell(readdirSync(baseDir), (version) => {
+      const binary = join2(baseDir, version, ...executable);
+      return isNonEmptyFile(binary) ? binary : void 0;
+    });
+  } catch {
+    return void 0;
+  }
+}
+function findManagedHeadlessShell(baseDir) {
+  const executable = cachedHeadlessShellExecutable();
+  if (!executable || !existsSync(baseDir)) return void 0;
+  try {
+    const version = readdirSync(baseDir).find(isManagedChromeDir);
+    const binary = version && join2(baseDir, version, ...executable);
+    return binary && isNonEmptyFile(binary) ? binary : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function resolveHeadlessShellPath(config) {
   if (config?.chromePath) {
     return config.chromePath;
@@ -1024,10 +1031,9 @@ function resolveHeadlessShellPath(config) {
     }
     return envPath;
   }
-  const home = homedir();
-  return findCachedHeadlessShell(
-    join2(home, ".cache", "hyperframes", "chrome", "chrome-headless-shell")
-  ) ?? findCachedHeadlessShell(join2(home, ".cache", "puppeteer", "chrome-headless-shell"));
+  const ours = join2(homedir(), ".cache", "hyperframes", "chrome", "chrome-headless-shell");
+  const shared = join2(homedir(), ".cache", "puppeteer", "chrome-headless-shell");
+  return findManagedHeadlessShell(ours) ?? findSharedHeadlessShell(shared) ?? findCachedHeadlessShell(ours);
 }
 function resolveFullChromePath() {
   const baseDir = join2(homedir(), ".cache", "puppeteer", "chrome");
@@ -7595,7 +7601,7 @@ function getCapturePerfSummary(session) {
 import {
   closeSync,
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   ftruncateSync,
   mkdirSync as mkdirSync2,
   mkdtempSync,
@@ -7612,8 +7618,10 @@ import { join as join5, dirname as dirname2, extname } from "path";
 import { spawn } from "child_process";
 
 // ../engine/src/utils/managedChildProcess.ts
+import { StringDecoder } from "string_decoder";
 var DEFAULT_TERMINATION_GRACE_MS = 2e3;
 var DEFAULT_STDERR_MAX_BYTES = 64 * 1024;
+var RAW_STDERR_SLACK_FACTOR = 2;
 var ManagedChildProcess = class {
   constructor(child, options = {}) {
     this.child = child;
@@ -7638,7 +7646,9 @@ var ManagedChildProcess = class {
   outcomePromise;
   resolveOutcome;
   requestedReason = null;
-  stderrTail = Buffer.alloc(0);
+  rawStderrTail = "";
+  rawStderrTailCut = false;
+  stderrDecoder = new StringDecoder("utf8");
   spawned = false;
   settled = false;
   deadlineTimer = null;
@@ -7661,13 +7671,18 @@ var ManagedChildProcess = class {
   }
   onStderr = (data) => {
     const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    const maxBytes = this.options.stderrMaxBytes ?? DEFAULT_STDERR_MAX_BYTES;
-    this.stderrTail = Buffer.concat([this.stderrTail, chunk]);
-    if (this.stderrTail.byteLength > maxBytes) {
-      this.stderrTail = this.stderrTail.subarray(this.stderrTail.byteLength - maxBytes);
-    }
+    const joined = this.rawStderrTail + this.stderrDecoder.write(chunk);
+    this.rawStderrTail = lastBytes(joined, RAW_STDERR_SLACK_FACTOR * this.maxBytes);
+    if (this.rawStderrTail !== joined) this.rawStderrTailCut = true;
     this.options.onStderr?.(chunk.toString());
   };
+  get maxBytes() {
+    return this.options.stderrMaxBytes ?? DEFAULT_STDERR_MAX_BYTES;
+  }
+  redactedStderrTail() {
+    const raw = this.rawStderrTailCut ? withoutTokenSeveredByCut(this.rawStderrTail) : this.rawStderrTail;
+    return lastBytes(redactUrlQueryStrings(raw), this.maxBytes);
+  }
   onSpawn = () => {
     this.spawned = true;
   };
@@ -7676,7 +7691,7 @@ var ManagedChildProcess = class {
       reason: this.requestedReason ?? "exit",
       exitCode,
       signal,
-      stderr: this.stderrTail.toString(),
+      stderr: this.redactedStderrTail(),
       durationMs: this.now() - this.startedAtMs
     });
   };
@@ -7686,7 +7701,7 @@ var ManagedChildProcess = class {
       reason: "spawn_error",
       exitCode: null,
       signal: null,
-      stderr: this.stderrTail.length > 0 ? this.stderrTail.toString() : error.message,
+      stderr: this.rawStderrTail.length > 0 ? this.redactedStderrTail() : error.message,
       durationMs: this.now() - this.startedAtMs,
       error
     });
@@ -7749,6 +7764,13 @@ var ManagedChildProcess = class {
     this.escalationTimer = null;
   }
 };
+function lastBytes(text, maxBytes) {
+  return Buffer.byteLength(text) > maxBytes ? Buffer.from(text).subarray(-maxBytes).toString() : text;
+}
+function withoutTokenSeveredByCut(text) {
+  const firstSpace = text.search(/\s/);
+  return firstSpace < 0 ? "" : text.slice(firstSpace);
+}
 
 // ../engine/src/utils/processTracker.ts
 var tracked = /* @__PURE__ */ new Set();
@@ -8149,8 +8171,42 @@ async function runFfmpeg(args, opts) {
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn3 } from "child_process";
 import { createReadStream, readFileSync, statSync as statSync2 } from "fs";
-import { StringDecoder } from "string_decoder";
+import { StringDecoder as StringDecoder2 } from "string_decoder";
 import { basename } from "path";
+
+// ../engine/src/utils/urlInput.ts
+import { existsSync as existsSync4 } from "fs";
+var CA_BUNDLES = [
+  "/etc/pki/tls/certs/ca-bundle.crt",
+  "/etc/ssl/certs/ca-certificates.crt",
+  "/etc/ssl/cert.pem"
+];
+var RECONNECT_ARGS = ["-rw_timeout", "30000000", "-reconnect", "1", "-reconnect_delay_max", "2"];
+function urlInputArgs(input, {
+  tool = "ffmpeg",
+  caBundles = CA_BUNDLES
+} = {}) {
+  if (!/^https:\/\//i.test(input)) return [];
+  const caFile = caBundles.find((path) => existsSync4(path));
+  if (!caFile) {
+    throw new Error(
+      `[FFmpeg] cannot verify TLS for an https input: no CA bundle at ${caBundles.join(", ")}`
+    );
+  }
+  const networkRetry = tool === "ffmpeg" ? ["-reconnect_on_network_error", "1"] : [];
+  return ["-tls_verify", "1", "-ca_file", caFile, ...RECONNECT_ARGS, ...networkRetry];
+}
+function redactUrlQueriesInError(error) {
+  if (!(error instanceof Error)) return error;
+  const fields = error;
+  for (const key of ["message", "stack", ...Object.keys(error)]) {
+    if (typeof fields[key] === "string") fields[key] = redactUrlQueryStrings(fields[key]);
+  }
+  if (error.cause !== error) redactUrlQueriesInError(error.cause);
+  return error;
+}
+
+// ../engine/src/utils/ffprobe.ts
 var FFPROBE_STDERR_MAX_BYTES = 8 * 1024;
 var FFPROBE_STDOUT_MAX_CHARS = 8e6;
 var FFPROBE_ERROR_MAX_CHARS = 4 * 1024;
@@ -8182,7 +8238,15 @@ async function runFfprobe(filePath, argsWithoutInput, signal, stdoutOptions) {
     throw new Error('[FFmpeg] Refusing to probe "-": stdin is not a supported input path.');
   }
   const command = getFfprobeBinary();
-  const proc = spawn3(command, ["-v", "error", ...argsWithoutInput, "--", filePath], {
+  const args = [
+    "-v",
+    "error",
+    ...urlInputArgs(filePath, { tool: "ffprobe" }),
+    ...argsWithoutInput,
+    "--",
+    filePath
+  ];
+  const proc = spawn3(command, args, {
     // Nothing is ever written to the child's stdin; leaving it as a pipe is
     // what lets a stdin-reading invocation block indefinitely.
     stdio: ["ignore", "pipe", "pipe"],
@@ -8190,7 +8254,7 @@ async function runFfprobe(filePath, argsWithoutInput, signal, stdoutOptions) {
     windowsHide: true
   });
   trackChildProcess(proc);
-  const decoder = new StringDecoder("utf8");
+  const decoder = new StringDecoder2("utf8");
   let stdout = "";
   let stdoutTruncated = false;
   const stdoutMaxChars = stdoutOptions?.maxChars ?? FFPROBE_STDOUT_MAX_CHARS;
@@ -8552,7 +8616,8 @@ async function extractMediaMetadata(filePath) {
     const colorTransfer = videoStream.color_transfer || "";
     const colorPrimaries = videoStream.color_primaries || "";
     const colorSpaceVal = videoStream.color_space || "";
-    const cicp = colorTransfer && colorPrimaries && colorSpaceVal ? null : stillImage()?.colorSpace;
+    const isPng = output !== null && isPngImageProbe(output);
+    const cicp = !isPng || colorTransfer && colorPrimaries && colorSpaceVal ? null : stillImage()?.colorSpace;
     const merged = {
       colorTransfer: colorTransfer || cicp?.colorTransfer || "",
       colorPrimaries: colorPrimaries || cicp?.colorPrimaries || "",
@@ -9160,7 +9225,7 @@ var secondsReader = (onSeconds) => onSeconds && ffmpegStatsReader(({ seconds })
 async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config, onFramesEncoded) {
   const startTime = Date.now();
   const outputDir = dirname2(outputPath);
-  if (!existsSync4(outputDir)) mkdirSync2(outputDir, { recursive: true });
+  if (!existsSync5(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const files = readdirSync2(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
@@ -9211,7 +9276,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
       failureReason: isExternalFfmpegInterruption(result) ? "external_interruption" : void 0
     };
   }
-  const fileSize = existsSync4(outputPath) ? statSync3(outputPath).size : 0;
+  const fileSize = existsSync5(outputPath) ? statSync3(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -9345,7 +9410,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       failureReason: concatResult.externalInterruption ? "external_interruption" : void 0
     };
   }
-  const fileSize = existsSync4(outputPath) ? statSync3(outputPath).size : 0;
+  const fileSize = existsSync5(outputPath) ? statSync3(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -9356,7 +9421,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config, fps, onSecondsWritten) {
   const outputDir = dirname2(outputPath);
-  if (!existsSync4(outputDir)) mkdirSync2(outputDir, { recursive: true });
+  if (!existsSync5(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
   const shouldCopyAudio = isWebm ? false : await shouldCopyAacSidecar(audioPath, config);
@@ -9430,7 +9495,7 @@ async function packageHls(videoPath, audioPath, outputDir, options) {
   if (outputDir.includes("%")) {
     throw new Error(`[chunkEncoder] packageHls outputDir must not contain "%": ${outputDir}`);
   }
-  if (!existsSync4(outputDir)) mkdirSync2(outputDir, { recursive: true });
+  if (!existsSync5(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const hasAudio = audioPath !== null;
   const args = hasAudio ? ["-i", videoPath, "-i", audioPath, "-map", "0:v:0", "-map", "1:a:0"] : ["-i", videoPath, "-map", "0:v:0"];
   args.push(
@@ -9577,7 +9642,7 @@ function quantizationTableError(buffer, start, end) {
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn4 } from "child_process";
 import { once } from "events";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, statSync as statSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, statSync as statSync4 } from "fs";
 import { dirname as dirname3 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
@@ -9814,7 +9879,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
   const outputDir = dirname3(outputPath);
-  if (!existsSync5(outputDir)) mkdirSync3(outputDir, { recursive: true });
+  if (!existsSync6(outputDir)) mkdirSync3(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
@@ -9945,7 +10010,7 @@ FFmpeg stopped after ${streamingTimeout} ms without consuming a frame.` : "";
           }) ? "external_interruption" : void 0
         };
       }
-      const fileSize = existsSync5(outputPath) ? statSync4(outputPath).size : 0;
+      const fileSize = existsSync6(outputPath) ? statSync4(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus,
@@ -10046,7 +10111,7 @@ function isMemberGroupHidden(groupsById, el) {
 }
 
 // ../engine/src/services/videoFrameExtractor.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync8, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync9, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
 import { join as join10 } from "path";
 import { cpus } from "os";
 
@@ -10192,7 +10257,7 @@ import {
   closeSync as closeSync2,
   createReadStream as createReadStream2,
   createWriteStream,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   fsyncSync,
   linkSync,
   mkdtempSync as mkdtempSync3,
@@ -11144,7 +11209,7 @@ async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransient
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync6(destDir)) {
+  if (!existsSync7(destDir)) {
     mkdirSync4(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url, validationScope);
@@ -11221,7 +11286,7 @@ function unwrapTemplate(html) {
 import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
 import {
   createReadStream as createReadStream3,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync5,
@@ -11333,7 +11398,7 @@ function hasFrameFiles(dir) {
 function lookupCacheEntry(rootDir, input) {
   const keyHash = computeCacheKey(input);
   const dir = join9(rootDir, cacheEntryDirName(keyHash));
-  const complete = existsSync7(join9(dir, COMPLETE_SENTINEL)) && hasFrameFiles(dir);
+  const complete = existsSync8(join9(dir, COMPLETE_SENTINEL)) && hasFrameFiles(dir);
   return { entry: { dir, keyHash }, hit: complete };
 }
 function partialCacheEntryDir(entry) {
@@ -11344,7 +11409,7 @@ function isTargetExistsRenameError(err) {
   return code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM";
 }
 function adoptPublishedWinner(entry, partialDir) {
-  if (!existsSync7(join9(entry.dir, COMPLETE_SENTINEL))) return null;
+  if (!existsSync8(join9(entry.dir, COMPLETE_SENTINEL))) return null;
   removeDir(partialDir);
   return { dir: entry.dir, published: true };
 }
@@ -11889,7 +11954,9 @@ function parseImageElements(html) {
   return images;
 }
 async function readFirstFrameColour(videoPath, signal) {
-  const result = await runFfmpeg(firstFrameColourArgs(videoPath), { signal });
+  const result = await runFfmpeg([...urlInputArgs(videoPath), ...firstFrameColourArgs(videoPath)], {
+    signal
+  });
   return parseFirstFrameColour(result.stderr);
 }
 var CHROME_BT601_UNTAGGED_CODECS = /* @__PURE__ */ new Set(["vp9", "av1"]);
@@ -11975,14 +12042,21 @@ async function runSegmentedExtraction(job) {
   }
   return ran[ran.length - 1];
 }
-async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
+async function extractVideoFramesRange(...args) {
+  try {
+    return await extractVideoFramesRangeUnredacted(...args);
+  } catch (error) {
+    throw redactUrlQueriesInError(error);
+  }
+}
+async function extractVideoFramesRangeUnredacted(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const { outputDir, quality = 95 } = options;
   const normalizedFps = toFps(options.fps);
   const fps = fpsToNumber(normalizedFps);
   const ffmpegFps = fpsToFfmpegArg(normalizedFps);
   const videoOutputDir = outputDirOverride ?? join10(outputDir, videoId);
-  if (!existsSync8(videoOutputDir)) mkdirSync6(videoOutputDir, { recursive: true });
+  if (!existsSync9(videoOutputDir)) mkdirSync6(videoOutputDir, { recursive: true });
   let metadata;
   try {
     metadata = await extractMediaMetadata(videoPath);
@@ -12017,7 +12091,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (options.frameRanges && (!sampleAtOutputFps || metadata.isVFR)) {
     throw new Error("frameRanges extraction needs a constant-frame-rate source");
   }
-  const args = [];
+  const args = urlInputArgs(videoPath);
   if (decodeWithVideoToolbox) {
     args.push("-hwaccel", "videotoolbox");
   }
@@ -12537,6 +12611,11 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       if (!isHttpUrl(videoPath)) {
         videoPath = resolveProjectRelativeSrc(video.src, baseDir, compiledDir);
       }
+      const remoteUrl = options.urlByAbsentLocalPath?.get(videoPath);
+      if (remoteUrl) {
+        resolvedVideos.push({ video, videoPath: remoteUrl });
+        continue;
+      }
       if (isHttpUrl(videoPath)) {
         const downloadDir = join10(options.outputDir, DOWNLOAD_SUBDIR);
         mkdirSync6(downloadDir, { recursive: true });
@@ -12549,7 +12628,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
           { onTelemetry: writeUrlDownloadTelemetry }
         );
       }
-      if (!existsSync8(videoPath)) {
+      if (!existsSync9(videoPath)) {
         if (!warnedSrcs.has(video.src)) {
           warnedSrcs.add(video.src);
           process.stderr.write(
@@ -13264,7 +13343,7 @@ var FrameLookupTable = class {
   cleanup() {
     for (const video of this.videos.values()) {
       if (video.extracted.ownedByLookup) continue;
-      if (existsSync8(video.extracted.outputDir)) {
+      if (existsSync9(video.extracted.outputDir)) {
         rmSync4(video.extracted.outputDir, { recursive: true, force: true });
       }
     }
@@ -13717,7 +13796,7 @@ async function queryElementStacking(page, nativeHdrIds) {
 }
 
 // ../engine/src/services/audioMixer.ts
-import { closeSync as closeSync4, existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync7, openSync as openSync4, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
+import { closeSync as closeSync4, existsSync as existsSync11, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync7, openSync as openSync4, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
 import { join as join14, dirname as dirname7, isAbsolute, relative } from "path";
 
 // ../engine/src/utils/notMediaPayload.ts
@@ -14381,7 +14460,7 @@ function chainTailSeconds(chain, automation) {
 // ../engine/src/services/audioFxRender.ts
 import {
   closeSync as closeSync3,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdtempSync as mkdtempSync6,
   openSync as openSync3,
   readFileSync as readFileSync7,
@@ -14688,7 +14767,7 @@ async function renderInSegments(openPage, inputWav, header, chain, outputWav, op
 }
 async function applyAudioFxChain(inputWav, chain, outputWav, options) {
   if (enabledAudioFxNodes(chain).length === 0) return { path: inputWav, envelopeBaked: false };
-  if (!existsSync9(inputWav)) {
+  if (!existsSync10(inputWav)) {
     throw new AudioFxRenderError(`Audio FX input is missing: ${inputWav}`);
   }
   const limits = { ...DEFAULT_STREAMING_LIMITS, ...options.streaming };
@@ -15201,7 +15280,7 @@ function parseAudioElements(html) {
 async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
-  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
+  if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
   const sourceDuration = sourceTimeAt(normalizedPlaybackRate, duration);
   const metadata = await extractAudioMetadata(srcPath).catch(() => null);
@@ -15247,7 +15326,7 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
-  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
+  if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -15301,7 +15380,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
     };
   }
   const outputDir = dirname7(outputPath);
-  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
+  if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildFilterComplex = (ignoreAutomation, useNormalize2) => {
     const filterParts = [];
     tracks.forEach((track, i) => {
@@ -15407,7 +15486,7 @@ function groupNormalizeOptionUnsupported(stderr) {
 async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
-  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
+  if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildInputFilters = (ignoreKeyframes) => memberTracks.map((track, i) => {
     const volumeFilter = buildVolumeExpression(track, ignoreKeyframes);
     return buildTrackInputFilter(track, i, volumeFilter, totalDuration);
@@ -15521,7 +15600,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const failures = [];
   const groupTracks = /* @__PURE__ */ new Map();
   const groupMeta = /* @__PURE__ */ new Map();
-  if (!existsSync10(workDir)) mkdirSync7(workDir, { recursive: true });
+  if (!existsSync11(workDir)) mkdirSync7(workDir, { recursive: true });
   const internalController = new AbortController();
   const effectiveSignal = internalController.signal;
   if (signal) {
@@ -15545,6 +15624,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         let srcPath = element.src;
         if (!isHttpUrl(srcPath)) {
           srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
+          srcPath = config?.urlByAbsentLocalPath?.get(srcPath) ?? srcPath;
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -15563,7 +15643,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync10(srcPath)) {
+        if (!existsSync11(srcPath)) {
           failures.push({
             stage: "source",
             reason: "source_not_found",
@@ -15907,7 +15987,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus as cpus2, freemem } from "os";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
 import { join as join16 } from "path";
 import { getHeapStatistics } from "v8";
@@ -16370,7 +16450,7 @@ async function verifyDiskDrawElementSamples(session, task, streaming) {
 async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCaptureHook, signal, onFrameCaptured, onFrameBuffer, config, parallel, onFailure, onWorkerPhase) {
   const startTime = Date.now();
   let framesCaptured = 0;
-  if (!existsSync11(task.outputDir)) mkdirSync8(task.outputDir, { recursive: true });
+  if (!existsSync12(task.outputDir)) mkdirSync8(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   const needsSeparateBrowsers = shouldDisableBrowserPoolForParallelWorker({ parallel });
@@ -16589,11 +16669,11 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync11(outputDir)) mkdirSync8(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) mkdirSync8(outputDir, { recursive: true });
   let totalFrames = 0;
   const sortedTasks = [...tasks].sort((a, b) => a.startFrame - b.startFrame);
   for (const task of sortedTasks) {
-    if (!existsSync11(task.outputDir)) {
+    if (!existsSync12(task.outputDir)) {
       continue;
     }
     const files = readdirSync6(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();