@hyperframes/producer 0.8.205 → 0.8.206

package/dist/public-server.js

@@ -3,14 +3,14 @@
 // src/server.ts
 import {
   existsSync as existsSync19,
-  mkdirSync as mkdirSync10,
-  statSync as statSync9,
+  mkdirSync as mkdirSync11,
+  statSync as statSync10,
   mkdtempSync as mkdtempSync4,
-  writeFileSync as writeFileSync6,
-  rmSync as rmSync12,
+  writeFileSync as writeFileSync7,
+  rmSync as rmSync13,
   createReadStream as createReadStream3
 } from "node:fs";
-import { resolve as resolve9, dirname as dirname12, join as join30 } from "node:path";
+import { resolve as resolve10, dirname as dirname13, join as join31 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -23,13 +23,13 @@ import { fetchPublicHttpsText as fetchPublicHttpsText2 } from "@hyperframes/engi
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
   existsSync as existsSync16,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync5,
-  rmSync as rmSync11,
-  statSync as statSync7,
-  writeFileSync as writeFileSync5,
-  copyFileSync as copyFileSync4,
+  rmSync as rmSync12,
+  statSync as statSync8,
+  writeFileSync as writeFileSync6,
+  copyFileSync as copyFileSync5,
   appendFileSync
 } from "fs";
 import { tmpdir as tmpdir2 } from "node:os";
@@ -77,7 +77,7 @@ import {
   augmentProtocolTimeoutError,
   augmentPageNavigationTimeoutError
 } from "@hyperframes/engine";
-import { join as join26, dirname as dirname10, resolve as resolve7 } from "path";
+import { join as join27, dirname as dirname11, resolve as resolve8 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -101,6 +101,7 @@ import { Readable } from "node:stream";
 import { join, extname, resolve as resolve2, sep } from "node:path";
 import { injectScriptsAtHeadStart, injectScriptsIntoHtml } from "@hyperframes/core/compiler";
 import { fpsToNumber } from "@hyperframes/core";
+import { stripSdrPngColourTags } from "@hyperframes/core/compiler/png-colour-tags";
 
 // src/services/hyperframeRuntimeLoader.ts
 import { createHash } from "node:crypto";
@@ -217,11 +218,11 @@ var defaultLogger = createConsoleLogger("info");
 
 // src/services/fileServer.ts
 var readFileAsync = promisify(readFile);
-function isPathInside(child, parent, options = {}) {
+function isPathInside(child2, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
   const resolveFn = pathModule?.resolve ?? resolve2;
   const separator = pathModule?.sep ?? sep;
-  const resolvedChild = resolveFn(child);
+  const resolvedChild = resolveFn(child2);
   const resolvedParent = resolveFn(parent);
   const normalizedChild = resolveSymlinks && existsSync2(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
   const normalizedParent = resolveSymlinks && existsSync2(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
@@ -741,6 +742,18 @@ function createFileServer(options) {
         html = isIndex ? injectScriptsIntoHtml(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
         return c.text(html, 200, { "Content-Type": contentType });
       }
+      if (ext === ".png") {
+        const untagged = stripSdrPngColourTags(await readFileAsync(fd));
+        if (untagged) {
+          const headers = {
+            "Content-Type": contentType,
+            "Content-Length": String(untagged.length)
+          };
+          return new Response(c.req.method === "HEAD" ? null : new Uint8Array(untagged), {
+            headers
+          });
+        }
+      }
       const totalSize = stat.size;
       const rangeHeader = c.req.header("range");
       const rangeRequest = parseRangeHeader(rangeHeader, totalSize);
@@ -768,7 +781,8 @@ function createFileServer(options) {
       const stream = createReadStream(filePath, {
         fd,
         autoClose: true,
-        ...range ? { start: range.start, end: range.end } : {}
+        start: range?.start ?? 0,
+        ...range ? { end: range.end } : {}
       });
       streamOwnsFd = true;
       try {
@@ -782,10 +796,10 @@ function createFileServer(options) {
       if (!streamOwnsFd) closeSync(fd);
     }
   });
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const connections = /* @__PURE__ */ new Set();
     const server = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" }, (info) => {
-      resolve10({
+      resolve11({
         url: `http://localhost:${info.port}`,
         port: info.port,
         addPreHeadScript: (script) => {
@@ -1292,8 +1306,8 @@ var OrderedRenderEventPublisher = class {
     let timer;
     const drained = await Promise.race([
       this.tail.then(() => true),
-      new Promise((resolve10) => {
-        timer = setTimeout(() => resolve10(false), FLUSH_TIMEOUT_MS);
+      new Promise((resolve11) => {
+        timer = setTimeout(() => resolve11(false), FLUSH_TIMEOUT_MS);
       })
     ]);
     clearTimeout(timer);
@@ -3636,7 +3650,7 @@ var SequentialCaptureStallError = class extends Error {
   }
 };
 function raceAgainstStall(promise, deadlineMs, input, signal) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const timer = setTimeout(
       () => {
         reject(
@@ -3655,7 +3669,7 @@ function raceAgainstStall(promise, deadlineMs, input, signal) {
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve10(value);
+        resolve11(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -5583,15 +5597,15 @@ function countAuthoredTimedClips(html) {
 }
 
 // src/services/render/stages/compileStage.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { suggestMatchingPreset } from "@hyperframes/core";
 
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
-import { createHash as createHash5 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join14, dirname as dirname6, resolve as resolve6, basename as basename4, relative as relative2 } from "path";
-import { parseHTML as parseHTML4 } from "linkedom";
+import { createHash as createHash6 } from "node:crypto";
+import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join15, dirname as dirname7, resolve as resolve7, basename as basename4, relative as relative2 } from "path";
+import { parseHTML as parseHTML5 } from "linkedom";
 import {
   COMPOSITION_SOURCE_URL,
   compileTimingAttrs,
@@ -5867,7 +5881,7 @@ function readLoopOverride(el) {
   }
   return null;
 }
-function resolveGifSourcePath(src, options) {
+function resolveLocalImageSourcePath(src, options) {
   const trimmed = src.trim();
   if (!trimmed || trimmed.startsWith("data:")) return null;
   const { basePath } = splitUrlSuffix(trimmed);
@@ -6090,7 +6104,7 @@ async function prepareAnimatedGifInputs(html, options) {
     const img = images[i];
     const src = (img.getAttribute("src") || "").trim();
     if (!hasGifExtension(src)) continue;
-    const sourcePath = resolveGifSourcePath(src, options);
+    const sourcePath = resolveLocalImageSourcePath(src, options);
     if (!sourcePath) continue;
     const bytes = readFileSync5(sourcePath);
     const metadata = parseAnimatedGifMetadata(bytes);
@@ -6138,19 +6152,74 @@ async function prepareAnimatedGifInputs(html, options) {
   };
 }
 
-// src/services/htmlCompiler.ts
-import { createStudioPositionSeekReapplyScript } from "@hyperframes/studio-server/manual-edits-render-script";
-import { getPositionEditsRenderScript } from "@hyperframes/core/runtime/position-edits-render";
-
-// src/services/assetMediaType.ts
-import { existsSync as existsSync9 } from "node:fs";
+// src/services/heifImagePrep.ts
+import { createHash as createHash5 } from "node:crypto";
 import {
-  fingerprintElementId,
-  isNotMediaPayload,
-  NotMediaPayloadError,
-  probeMediaProfile,
-  resolveProjectRelativeSrc as resolveProjectRelativeSrc2
-} from "@hyperframes/engine";
+  closeSync as closeSync4,
+  copyFileSync as copyFileSync3,
+  mkdirSync as mkdirSync6,
+  openSync as openSync4,
+  readFileSync as readFileSync6,
+  readSync as readSync3,
+  rmSync as rmSync8,
+  statSync as statSync6,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { dirname as dirname6, join as join14, resolve as resolve6 } from "node:path";
+import { parseHTML as parseHTML4 } from "linkedom";
+import { renameWithRetry as renameWithRetry4, runFfmpeg as runFfmpeg3, runFfprobe } from "@hyperframes/engine";
+
+// src/services/heifRotation.ts
+function* boxes(buf, start, end) {
+  let at = start;
+  while (at + 8 <= end) {
+    let size = buf.readUInt32BE(at);
+    let header = 8;
+    if (size === 1 && at + 16 <= end) {
+      size = Number(buf.readBigUInt64BE(at + 8));
+      header = 16;
+    } else if (size === 0) {
+      size = end - at;
+    }
+    if (size < header || at + size > end) return;
+    yield { type: buf.toString("latin1", at + 4, at + 8), start: at + header, end: at + size };
+    at += size;
+  }
+}
+function child(buf, parent, type, skip = 0) {
+  return [...boxes(buf, parent.start + skip, parent.end)].filter((box) => box.type === type);
+}
+function readHeifPrimaryRotation(buf) {
+  try {
+    const root = { type: "", start: 0, end: buf.length };
+    const meta = child(buf, root, "meta")[0];
+    const pitm = meta && child(buf, meta, "pitm", 4)[0];
+    const iprp = meta && child(buf, meta, "iprp", 4)[0];
+    const ipco = iprp && child(buf, iprp, "ipco")[0];
+    if (!pitm || !ipco || !iprp) return 0;
+    const primaryId = buf[pitm.start] === 0 ? buf.readUInt16BE(pitm.start + 4) : buf.readUInt32BE(pitm.start + 4);
+    const props = [...boxes(buf, ipco.start, ipco.end)];
+    for (const ipma of child(buf, iprp, "ipma")) {
+      const version = buf[ipma.start];
+      const wide = (buf[ipma.start + 3] & 1) === 1;
+      let at = ipma.start + 8;
+      for (let n = buf.readUInt32BE(ipma.start + 4); n > 0 && at < ipma.end; n--) {
+        const id = version < 1 ? buf.readUInt16BE(at) : buf.readUInt32BE(at);
+        at += version < 1 ? 2 : 4;
+        const count = buf[at++];
+        for (let i = 0; i < count; i++) {
+          const index = wide ? buf.readUInt16BE(at) & 32767 : buf[at] & 127;
+          at += wide ? 2 : 1;
+          const prop = props[index - 1];
+          if (id === primaryId && prop?.type === "irot")
+            return (buf[prop.start] & 3) * 90;
+        }
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
 
 // src/utils/semaphore.ts
 var Semaphore = class {
@@ -6165,10 +6234,10 @@ var Semaphore = class {
       this.active++;
       return () => this.release();
     }
-    return new Promise((resolve10) => {
+    return new Promise((resolve11) => {
       this.queue.push(() => {
         this.active++;
-        resolve10(() => this.release());
+        resolve11(() => this.release());
       });
     });
   }
@@ -6199,7 +6268,229 @@ async function withMediaProbeSlot(operation) {
   }
 }
 
+// src/services/heifImagePrep.ts
+var PREPARED_HEIF_SUBDIR = "_heif_images";
+var CACHE_SCHEMA2 = "hfheif-v1";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var HEIF_IMAGE_CONVERSION_FAILED = "HEIF_IMAGE_CONVERSION_FAILED";
+var HEIF_TOOL_UNAVAILABLE = "HEIF_TOOL_UNAVAILABLE";
+var HEIF_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "hevc", "hevx", "heim", "heis", "mif1", "msf1"]);
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+var DATA_URL_RE = /^data:image\/(?:heic|heif)(?:-sequence)?;base64,(.*)$/is;
+var HeifImageConversionError = class extends Error {
+  code = HEIF_IMAGE_CONVERSION_FAILED;
+  owner = "user";
+  retryable = false;
+  constructor(label, reason) {
+    super(
+      `Could not convert HEIC/HEIF image ${label} to JPEG: ${reason}. Re-export the photo as JPEG or PNG and update its src.`
+    );
+    this.name = "HeifImageConversionError";
+  }
+};
+var HeifToolUnavailableError = class extends Error {
+  code = HEIF_TOOL_UNAVAILABLE;
+  owner = "system";
+  retryable = false;
+  constructor(label, reason) {
+    super(
+      `Could not convert HEIC/HEIF image ${label}: ${reason}. Converting HEIC needs ffmpeg and ffprobe 7.0 or newer with the hevc decoder.`
+    );
+    this.name = "HeifToolUnavailableError";
+  }
+};
+var TOOL_FAILURE_RE = /(?:ffmpeg|ffprobe) not found|ENOENT|Option not found|Unrecognized option|Unknown decoder|Decoder \S+ not found/i;
+function isHeifBytes(head) {
+  const bytes = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
+  if (bytes.length < 16 || bytes.toString("ascii", 4, 8) !== "ftyp") return false;
+  const boxEnd = Math.min(bytes.readUInt32BE(0), bytes.length);
+  if (boxEnd < 16) return false;
+  const brands = [bytes.toString("ascii", 8, 12)];
+  for (let offset = 16; offset + 4 <= boxEnd; offset += 4) {
+    brands.push(bytes.toString("ascii", offset, offset + 4));
+  }
+  return !brands.some((b) => AVIF_BRANDS.has(b)) && brands.some((b) => HEIF_BRANDS.has(b));
+}
+function readHead(path) {
+  let fd;
+  try {
+    fd = openSync4(path, "r");
+    const buf = Buffer.alloc(4096);
+    return buf.subarray(0, readSync3(fd, buf, 0, buf.length, 0));
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) closeSync4(fd);
+  }
+}
+async function probeJson(path, withGroups) {
+  const stdout = await runFfprobe(
+    path,
+    withGroups ? ["-show_stream_groups", "-show_streams", "-of", "json"] : ["-show_streams", "-of", "json"]
+  );
+  return JSON.parse(stdout);
+}
+var ROTATION_FILTER = {
+  0: "",
+  90: "transpose=2",
+  180: "hflip,vflip",
+  270: "transpose=1"
+};
+function primaryGrid(probed) {
+  const groups = probed.stream_groups ?? [];
+  return (groups.find((g) => g.disposition?.default === 1) ?? groups[0])?.components?.[0];
+}
+async function convertHeifToJpeg(request) {
+  const probed = await probeJson(request.inputPath, true);
+  const grid = primaryGrid(probed);
+  const rotation = readHeifPrimaryRotation(readFileSync6(request.inputPath));
+  const filters = [];
+  let inputs = [];
+  let size = probed.streams?.[0];
+  if (grid?.subcomponents?.length) {
+    size = grid;
+    const layout = grid.subcomponents.map(
+      (t) => `${t.tile_horizontal_offset}_${t.tile_vertical_offset}`
+    );
+    inputs = grid.subcomponents.map((t) => `[0:${t.stream_index}]`);
+    filters.push(
+      `${inputs.join("")}xstack=inputs=${inputs.length}:layout=${layout.join("|")}`,
+      `crop=${grid.width}:${grid.height}:${grid.horizontal_offset ?? 0}:${grid.vertical_offset ?? 0}`
+    );
+  }
+  if (!size?.width || !size.height) throw new Error("no declared image size");
+  if (rotation && grid) filters.push(ROTATION_FILTER[rotation]);
+  const mapArgs = filters.length > 0 ? ["-filter_complex", `${filters.join(",")}[v]`, "-map", "[v]"] : [];
+  const result = await runFfmpeg3(
+    [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      request.inputPath,
+      ...mapArgs,
+      "-frames:v",
+      "1",
+      "-q:v",
+      "2",
+      "-f",
+      "mjpeg",
+      "-y",
+      request.outputPath
+    ],
+    { timeout: request.timeoutMs ?? DEFAULT_TIMEOUT_MS }
+  );
+  if (!result.success) {
+    throw result.error ?? new Error(`ffmpeg exited ${result.exitCode}: ${result.stderr.slice(-300)}`);
+  }
+  const out = (await probeJson(request.outputPath, false)).streams?.[0];
+  const same = out?.width === size.width && out.height === size.height;
+  const swapped = out?.width === size.height && out.height === size.width;
+  if (!same && !swapped) {
+    throw new Error(
+      `wrong size: decoded ${out?.width}x${out?.height}, file declares ${size.width}x${size.height}`
+    );
+  }
+}
+function resolveImageSource(src, options) {
+  const data = DATA_URL_RE.exec(src);
+  if (data) {
+    const bytes = Buffer.from(data[1], "base64");
+    return isHeifBytes(bytes.subarray(0, 4096)) ? { path: null, bytes, label: '"inline image"' } : null;
+  }
+  const path = resolveLocalImageSourcePath(src, options);
+  const head = path ? readHead(path) : null;
+  if (!path || !head || !isHeifBytes(head)) return null;
+  return { path, bytes: readFileSync6(path), label: `"${splitUrlSuffix(src).basePath}"` };
+}
+function isUsableFile2(path) {
+  try {
+    return statSync6(path).size > 0;
+  } catch {
+    return false;
+  }
+}
+async function ensurePreparedJpeg(source, cachePath, outputPath, options) {
+  mkdirSync6(dirname6(cachePath), { recursive: true });
+  mkdirSync6(dirname6(outputPath), { recursive: true });
+  if (!isUsableFile2(cachePath)) {
+    const tmpPath = `${cachePath}.tmp-${process.pid}-${Date.now()}`;
+    const inlinePath = `${tmpPath}.heic`;
+    const inputPath = source.path ?? inlinePath;
+    try {
+      if (!source.path) writeFileSync4(inlinePath, source.bytes);
+      await (options.transcode ?? convertHeifToJpeg)({
+        inputPath,
+        outputPath: tmpPath,
+        timeoutMs: options.timeoutMs
+      });
+      if (!isUsableFile2(tmpPath)) throw new Error("conversion produced an empty file");
+      renameWithRetry4(tmpPath, cachePath);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw TOOL_FAILURE_RE.test(reason) ? new HeifToolUnavailableError(source.label, reason) : new HeifImageConversionError(source.label, reason);
+    } finally {
+      rmSync8(tmpPath, { force: true });
+      rmSync8(inlinePath, { force: true });
+    }
+  }
+  if (resolve6(outputPath) !== resolve6(cachePath) && !isUsableFile2(outputPath)) {
+    copyFileSync3(cachePath, outputPath);
+  }
+}
+async function prepareHeifImageInputs(html, options) {
+  const outputDir = options.outputDir ?? join14(options.downloadDir, PREPARED_HEIF_SUBDIR);
+  const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_HEIF_SUBDIR);
+  const cacheDir = options.cacheDir ?? outputDir;
+  const preparedAssets = /* @__PURE__ */ new Map();
+  const preparedImages = [];
+  if (!/<img\b/i.test(html)) return { html, preparedAssets, preparedImages };
+  const { document: document2 } = parseHTML4(html);
+  const found = [];
+  for (const img of Array.from(document2.querySelectorAll("img[src]"))) {
+    const src = (img.getAttribute("src") || "").trim();
+    const source = src ? resolveImageSource(src, options) : null;
+    if (!source) continue;
+    const hash = createHash5("sha256").update(CACHE_SCHEMA2).update("\0").update(source.bytes).digest("hex");
+    found.push({ img, src, source, filename: `${CACHE_SCHEMA2}-${hash.slice(0, 24)}.jpg` });
+  }
+  if (found.length === 0) return { html, preparedAssets, preparedImages };
+  const unique = new Map(found.map((item) => [item.filename, item.source]));
+  const failed = /* @__PURE__ */ new Set();
+  await Promise.all(
+    [...unique].map(
+      ([filename, source]) => withMediaProbeSlot(
+        () => ensurePreparedJpeg(source, join14(cacheDir, filename), join14(outputDir, filename), options)
+      ).catch((error) => {
+        if (!options.onFailure) throw error;
+        failed.add(filename);
+        options.onFailure(error);
+      })
+    )
+  );
+  for (const { img, src, filename } of found) {
+    if (failed.has(filename)) continue;
+    const outputSrc = `${outputSrcPrefix}/${filename}`;
+    img.setAttribute("src", outputSrc);
+    preparedAssets.set(outputSrc, join14(outputDir, filename));
+    preparedImages.push({ sourceSrc: src, outputSrc, outputPath: join14(outputDir, filename) });
+  }
+  return { html: document2.toString(), preparedAssets, preparedImages };
+}
+
+// src/services/htmlCompiler.ts
+import { createStudioPositionSeekReapplyScript } from "@hyperframes/studio-server/manual-edits-render-script";
+import { getPositionEditsRenderScript } from "@hyperframes/core/runtime/position-edits-render";
+
 // src/services/assetMediaType.ts
+import { existsSync as existsSync9 } from "node:fs";
+import {
+  fingerprintElementId,
+  isNotMediaPayload,
+  NotMediaPayloadError,
+  probeMediaProfile,
+  resolveProjectRelativeSrc as resolveProjectRelativeSrc2
+} from "@hyperframes/engine";
 var ASSET_MEDIA_TYPE_MISMATCH = "ASSET_MEDIA_TYPE_MISMATCH";
 var AssetMediaTypeMismatchError = class extends Error {
   code = ASSET_MEDIA_TYPE_MISMATCH;
@@ -6309,7 +6600,7 @@ function logRemoteDownloadTelemetry(event) {
 }
 var INFERRED_MEDIA_DURATION_ATTR = "data-hf-inferred-duration";
 function parseSubCompHtmlForValidity(html) {
-  return parseHTML4(html).document;
+  return parseHTML5(html).document;
 }
 function endsWithSourceUrl(code) {
   const trimmed = code.trimEnd();
@@ -6317,7 +6608,7 @@ function endsWithSourceUrl(code) {
   return lastLine.startsWith("//# sourceURL=") || lastLine.startsWith("//@ sourceURL=");
 }
 function prepareCompositionScripts(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   for (const el of document2.querySelectorAll("script:not([src])")) {
     const isModule = (el.getAttribute("type") || "").trim().toLowerCase() === "module";
     const runsAsScript = isModule || isJavaScriptType(el);
@@ -6354,14 +6645,14 @@ Check that each file referenced by data-composition-src contains valid HTML with
   }
 };
 function assertSubCompositionsUsable(html, projectDir, visited = /* @__PURE__ */ new Set()) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const hosts = [...document2.querySelectorAll("[data-composition-src]")];
   const problems = [];
   for (const el of hosts) {
     const srcPath = el.getAttribute("data-composition-src");
     if (!srcPath) continue;
     if (isUnresolvedAssetPlaceholder(srcPath)) continue;
-    const filePath = resolve6(projectDir, srcPath);
+    const filePath = resolve7(projectDir, srcPath);
     if (visited.has(filePath)) continue;
     const read = readProjectFile(filePath);
     if (read.kind === "missing") {
@@ -6417,7 +6708,7 @@ function runtimeRoot(document2) {
 }
 function detectRenderModeHints(html, pageMotionBlur) {
   const reasons = [];
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   if (document2.querySelector("canvas[layoutsubtree]")) {
     reasons.push({
       code: "htmlInCanvas",
@@ -6459,7 +6750,7 @@ function detectThreeDTransformUsage(html) {
 }
 var BACKGROUND_IMAGE_DECL_PATTERN = /(?:^|;|\{)\s*background(?:-image)?\s*:[^;}]*(?:\bgradient\s*\(|url\s*\()/i;
 function detectAncestorBackgroundImage(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const root = document2.querySelector("[data-composition-id]");
   if (!root) return false;
   const ancestors = [];
@@ -6506,7 +6797,7 @@ function detectShaderTransitionUsage(html) {
 async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName, elementIdentity, log, urlByAbsentLocalPath) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync10(downloadDir)) mkdirSync6(downloadDir, { recursive: true });
+    if (!existsSync10(downloadDir)) mkdirSync7(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir, void 0, void 0, void 0, {
         onTelemetry: logRemoteDownloadTelemetry
@@ -6516,7 +6807,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     }
   } else {
     filePath = decodedUrlPath(src);
-    if (!filePath.startsWith("/")) filePath = join14(baseDir, filePath);
+    if (!filePath.startsWith("/")) filePath = join15(baseDir, filePath);
     filePath = urlByAbsentLocalPath?.get(filePath) ?? filePath;
   }
   if (!isHttpUrl(filePath) && !existsSync10(filePath)) {
@@ -6573,7 +6864,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
 function markInferredVariableMediaDurations(html, unresolvedMedia) {
   const unresolvedIds = new Set(unresolvedMedia.map((element) => element.id));
   if (unresolvedIds.size === 0) return html;
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   let changed = false;
   for (const element of document2.querySelectorAll("video[data-var-src], audio[data-var-src]")) {
     if (!unresolvedIds.has(element.id)) continue;
@@ -6644,13 +6935,13 @@ async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocal
 }
 async function parseSubCompositions(html, projectDir, downloadDir, visited = /* @__PURE__ */ new Set(), urlByAbsentLocalPath) {
   const subCompositions = /* @__PURE__ */ new Map();
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const compEls = document2.querySelectorAll("[data-composition-src]");
   const workItems = [];
   for (const el of compEls) {
     const srcPath = el.getAttribute("data-composition-src");
     if (!srcPath) continue;
-    const filePath = resolve6(projectDir, srcPath);
+    const filePath = resolve7(projectDir, srcPath);
     if (visited.has(filePath)) {
       continue;
     }
@@ -6667,7 +6958,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         rewriteUnresolvableGsapToCdn(item.rawSubHtml, projectDir, item.srcPath),
-        dirname6(item.filePath),
+        dirname7(item.filePath),
         downloadDir,
         void 0,
         urlByAbsentLocalPath
@@ -6695,7 +6986,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
   return { subCompositions };
 }
 function promoteCssImportsToLinkTags(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   if (!head) return html;
   const importRe = /@import\s+url\(\s*['"]?([^'")\s]+)['"]?\s*\)\s*;?/gi;
@@ -6764,7 +7055,7 @@ var ProducerHostIdentityMap = class extends Map {
   }
 };
 function coalesceHeadStylesAndBodyScripts(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   const body = document2.querySelector("body");
   if (!head && !body) return html;
@@ -6815,7 +7106,7 @@ function coalesceHeadStylesAndBodyScripts(html) {
   return document2.toString();
 }
 function inlineSubCompositions(html, subCompositions, projectDir, variableOverrides = {}) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   const body = document2.querySelector("body");
   const hosts = Array.from(document2.querySelectorAll("[data-composition-src]"));
@@ -6844,17 +7135,17 @@ function inlineSubCompositions(html, subCompositions, projectDir, variableOverri
       resolveHtml: (srcPath) => {
         let compHtml = subCompositions.get(srcPath) || null;
         if (!compHtml) {
-          const read = readProjectFile(resolve6(projectDir, srcPath));
+          const read = readProjectFile(resolve7(projectDir, srcPath));
           if (read.kind === "file") {
             compHtml = rewriteUnresolvableGsapToCdn(read.text, projectDir, srcPath);
           }
         }
         return compHtml;
       },
-      parseHtml: (htmlStr) => parseHTML4(htmlStr).document,
+      parseHtml: (htmlStr) => parseHTML5(htmlStr).document,
       // Mirrors the preview bundler: a sub-composition's SIBLING assets resolve
       // against its own directory, project-root refs stay as authored.
-      assetExists: (path) => existsSync10(resolve6(projectDir, path)),
+      assetExists: (path) => existsSync10(resolve7(projectDir, path)),
       // Preserve the authored root wrapper as a child of the host, matching
       // the preview bundler's shape (htmlBundler.ts's prepareFlattenedInnerRoot,
       // which the runtime compositionLoader mirrors with its own copy for the
@@ -6955,7 +7246,7 @@ ${html}
 </html>`;
 }
 function injectTextRenderingRule(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   if (!head) return html;
   if (document2.querySelector("style[data-hyperframes-text-rendering]")) {
@@ -6979,7 +7270,7 @@ function matchesScriptIntegrity(bytes, metadata) {
     (alg) => hashes.some((hash) => hash[1]?.toLowerCase() === alg)
   );
   if (!strongest) return true;
-  const actual = createHash5(strongest).update(bytes).digest();
+  const actual = createHash6(strongest).update(bytes).digest();
   return hashes.some(
     (hash) => hash[1]?.toLowerCase() === strongest && actual.equals(Buffer.from(hash[2], "base64"))
   );
@@ -6987,7 +7278,7 @@ function matchesScriptIntegrity(bytes, metadata) {
 async function inlineExternalScripts(html) {
   const fullHtml = ensureFullDocument(html);
   const wrappedFragment = fullHtml !== html;
-  const { document: document2 } = parseHTML4(fullHtml);
+  const { document: document2 } = parseHTML5(fullHtml);
   const scripts = document2.querySelectorAll("script[src]");
   const externalScripts = [];
   for (const el of scripts) {
@@ -7036,12 +7327,12 @@ ${safeText}
   return wrappedFragment ? document2.body.innerHTML || "" : document2.toString();
 }
 function collectExternalAssets(html, projectDir) {
-  const absProjectDir = resolve6(projectDir);
+  const absProjectDir = resolve7(projectDir);
   const externalAssets = /* @__PURE__ */ new Map();
   function processPath(rawPath) {
     const trimmed = rawPath.trim();
     if (isNonRelativeUrl(trimmed)) return null;
-    const absPath = resolve6(absProjectDir, trimmed);
+    const absPath = resolve7(absProjectDir, trimmed);
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
@@ -7050,7 +7341,7 @@ function collectExternalAssets(html, projectDir) {
     externalAssets.set(safeKey, absPath);
     return safeKey;
   }
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   for (const el of document2.querySelectorAll("[src], [href]")) {
     for (const attr of ["src", "href"]) {
       const val = (el.getAttribute(attr) || "").trim();
@@ -7095,7 +7386,7 @@ var REMOTE_SOURCE_TAG_RE = /<source\b[^>]*?\bsrc\s*=\s*["'](https?:\/\/[^"']+)["
 var REMOTE_IMG_TAG_RE = /<img\b[^>]*?(?<![\w-])src\s*=\s*["'](https?:\/\/[^"']+)["'][^>]*>/gi;
 async function downloadAndRewriteUrls(urlSet, html, remoteDir, warnLabel, logLabel, extraRewrite) {
   if (urlSet.size === 0) return { html, remoteMediaAssets: /* @__PURE__ */ new Map() };
-  if (!existsSync10(remoteDir)) mkdirSync6(remoteDir, { recursive: true });
+  if (!existsSync10(remoteDir)) mkdirSync7(remoteDir, { recursive: true });
   const urlToLocal = /* @__PURE__ */ new Map();
   await Promise.all(
     [...urlSet].map(async (url) => {
@@ -7142,7 +7433,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -7157,7 +7448,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -7173,7 +7464,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -7308,7 +7599,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     processed,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -7353,7 +7644,7 @@ async function embedLocalFontFaces(html, projectDir) {
       while ((urlMatch = urlRe.exec(block)) !== null) {
         const localPath = urlMatch[1];
         if (!localPath || embeddedPaths.has(localPath)) continue;
-        const absPath = localPath.startsWith("/") ? localPath : resolve6(projectDir, localPath);
+        const absPath = localPath.startsWith("/") ? localPath : resolve7(projectDir, localPath);
         if (!isPathInside2(absPath, projectDir)) continue;
         const ext = absPath.match(/\.(woff2?|ttf|otf|ttc)$/i)?.[1]?.toLowerCase() ?? "ttf";
         try {
@@ -7402,7 +7693,7 @@ function renderGsapDist() {
 }
 function rewriteUnresolvableGsapToCdn(html, projectDir, compSrcPath) {
   let gsapDist;
-  const exists = (path) => existsSync10(resolve6(projectDir, path));
+  const exists = (path) => existsSync10(resolve7(projectDir, path));
   return html.replace(
     /(<script\b[^>]*\bsrc=["'])([^"']*gsap[^"']*\/dist\/([^"']+))(["'][^>]*>)/gi,
     (full, prefix, src, file, suffix) => {
@@ -7418,8 +7709,8 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
   if (!isPathInside2(htmlPath, projectDir)) return html;
   const entryPath = relative2(projectDir, htmlPath).replace(/\\/g, "/");
   if (!entryPath.includes("/")) return html;
-  const { document: document2 } = parseHTML4(html);
-  const assetExists = (path) => existsSync10(resolve6(projectDir, path));
+  const { document: document2 } = parseHTML5(html);
+  const assetExists = (path) => existsSync10(resolve7(projectDir, path));
   rewriteAssetPaths(
     document2.querySelectorAll("[src], [href]"),
     entryPath,
@@ -7441,7 +7732,7 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
   const entryHtml = rebaseDirectEntryAssetPaths(
-    readFileSync6(htmlPath, "utf-8"),
+    readFileSync7(htmlPath, "utf-8"),
     projectDir,
     htmlPath
   );
@@ -7511,12 +7802,26 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   const { html: htmlWithLocalImages, remoteMediaAssets: remoteImageAssets } = await localizeRemoteImageSources(htmlWithLocalMedia, downloadDir);
   const { html: htmlWithLocalBg, remoteMediaAssets: remoteBgAssets } = await localizeRemoteBackgroundImages(htmlWithLocalImages, downloadDir);
   const { html: htmlWithLocalizedFonts, remoteMediaAssets: remoteFontAssets } = await localizeRemoteFontFaces(htmlWithLocalBg, downloadDir);
+  const {
+    html: htmlWithJpegs,
+    preparedAssets: preparedHeifAssets,
+    preparedImages: preparedHeifImages
+  } = await prepareHeifImageInputs(htmlWithLocalizedFonts, {
+    projectDir,
+    downloadDir,
+    cacheDir: options.animatedGifCacheDir,
+    sourceAssets: remoteImageAssets,
+    timeoutMs: options.ffmpegProcessTimeout
+  });
+  if (preparedHeifImages.length > 0) {
+    defaultLogger.info(`[Compiler] Converted ${preparedHeifImages.length} HEIC image(s) to JPEG`);
+  }
   const gifSourceAssets = new Map(remoteImageAssets);
   const {
     html: htmlWithPreparedGifs,
     preparedAssets: preparedGifAssets,
     preparedGifs
-  } = await prepareAnimatedGifInputs(htmlWithLocalizedFonts, {
+  } = await prepareAnimatedGifInputs(htmlWithJpegs, {
     projectDir,
     downloadDir,
     cacheDir: options.animatedGifCacheDir,
@@ -7543,11 +7848,14 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   for (const [relPath, absPath] of preparedGifAssets) {
     externalAssets.set(relPath, absPath);
   }
+  for (const [relPath, absPath] of preparedHeifAssets) {
+    externalAssets.set(relPath, absPath);
+  }
   const { videos, audios, images, droppedMediaIds } = collectRenderMedia(html);
   const masterFxChain = parseMasterFxChain(html);
   for (const video of videos) {
     if (isHttpUrl(video.src)) continue;
-    const videoPath = resolve6(projectDir, video.src);
+    const videoPath = resolve7(projectDir, video.src);
     const reencode = `ffmpeg -i "${video.src}" -c:v libx264 -r 30 -g 30 -keyint_min 30 -movflags +faststart -c:a copy output.mp4`;
     (async () => {
       const metadata = await withMediaProbeSlot(() => extractMediaMetadata(videoPath));
@@ -7567,7 +7875,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     })().catch(() => {
     });
   }
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const rootEl = document2.querySelector("[data-composition-id]");
   const width = rootEl ? parseInt(rootEl.getAttribute("data-width") || "1080", 10) : 1080;
   const height = rootEl ? parseInt(rootEl.getAttribute("data-height") || "1920", 10) : 1920;
@@ -7974,7 +8282,7 @@ async function runCompileStage(input) {
     abortSignal
   } = input;
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join15(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join16(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
@@ -7982,7 +8290,7 @@ async function runCompileStage(input) {
     variables: input.variables,
     urlByAbsentLocalPath: input.urlByAbsentLocalPath,
     pageMotionBlur: input.pageMotionBlur,
-    animatedGifCacheDir: cfg.extractCacheDir ? join15(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join16(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -8038,7 +8346,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join15(workDir, "compiled"),
+    compiledDir: join16(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -8083,8 +8391,8 @@ async function runCompileStage(input) {
 }
 
 // src/services/render/stages/probeStage.ts
-import { join as join16 } from "node:path";
-import { parseHTML as parseHTML5 } from "linkedom";
+import { join as join17 } from "node:path";
+import { parseHTML as parseHTML6 } from "linkedom";
 import {
   closeCaptureSession as closeCaptureSession4,
   compositionRequiresWebGpu,
@@ -8131,7 +8439,7 @@ function durationToFrameCount(duration, fps) {
 }
 function hasScriptedAudioVolumeAutomation(html, audioCount) {
   if (audioCount <= 0) return false;
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   const scriptBodies = [...document2.querySelectorAll("script")].map((script) => script.textContent ?? "").join("\n");
   if (!scriptBodies) return false;
   return /\.\s*volume\s*=/i.test(scriptBodies) || /\b(?:gsap|tl|timeline|tween)\s*\.\s*(?:to|fromTo|set)\s*\([\s\S]{0,2000}\bvolume\s*:/i.test(
@@ -8139,12 +8447,12 @@ function hasScriptedAudioVolumeAutomation(html, audioCount) {
   );
 }
 function hasAutoStartVideos(html) {
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   return document2.querySelector("video[data-hf-auto-start]") !== null;
 }
 function hasVariableBoundMedia(html, variables) {
   if (!variables || Object.keys(variables).length === 0) return false;
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   return Array.from(
     document2.querySelectorAll(
       "img[data-var-src], audio[data-var-src], video[data-var-src], source[data-var-src]"
@@ -8155,7 +8463,7 @@ function hasVariableBoundMedia(html, variables) {
   });
 }
 function authoredMediaStarts(html) {
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   const starts = /* @__PURE__ */ new Map();
   for (const media of document2.querySelectorAll("video, audio")) {
     const id = media.getAttribute(MEDIA_RENDER_ID_ATTR2) || media.getAttribute("id");
@@ -8192,7 +8500,7 @@ function reconcileBrowserMediaEnd(existingEnd, projectedEnd, sourceChanged, dura
   return existingEnd <= 0 ? projectedEnd : Math.min(existingEnd, projectedEnd);
 }
 function hasRuntimeMediaChanges(html) {
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   const scriptBodies = [...document2.querySelectorAll("script")].map(
     (script) => script.textContent ?? ""
   );
@@ -8275,7 +8583,7 @@ async function runProbeStage(input) {
       });
       fileServer = await createFileServer({
         projectDir,
-        compiledDir: join16(workDir, "compiled"),
+        compiledDir: join17(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM],
         fps: job.config.fps
@@ -8304,7 +8612,7 @@ async function runProbeStage(input) {
           log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join16(workDir, "probe"),
+            join17(workDir, "probe"),
             captureOpts,
             null,
             probeCfg
@@ -8389,7 +8697,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join16(workDir, "probe-screenshot"),
+            join17(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -8425,7 +8733,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join16(workDir, "downloads")
+            join17(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -8616,7 +8924,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join16(workDir, "compiled"),
+      compiledDir: join17(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -8750,7 +9058,7 @@ function validateRenderDuration(input) {
 
 // src/services/render/stages/extractVideosStage.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import {
   classifyVideoExtractionError,
   createFrameLookupTable,
@@ -9065,14 +9373,14 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join17(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join18(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         toneMapHdrToSdr: job.config.hdrMode === "force-sdr",
         timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
         collectProbeFailures: extractionPolicy.failureMode === "enforce",
         deferRangeExtraction,
-        contentKeyedDirs: [join17(compiledDir, REMOTE_MEDIA_SUBDIR)],
+        contentKeyedDirs: [join18(compiledDir, REMOTE_MEDIA_SUBDIR)],
         urlByAbsentLocalPath
       },
       abortSignal,
@@ -9139,8 +9447,8 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { join as join19 } from "node:path";
-import { rmSync as rmSync9 } from "node:fs";
+import { join as join20 } from "node:path";
+import { rmSync as rmSync10 } from "node:fs";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
@@ -9149,8 +9457,8 @@ import {
 
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, rmSync as rmSync8 } from "node:fs";
-import { dirname as dirname7, join as join18 } from "node:path";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync9 } from "node:fs";
+import { dirname as dirname8, join as join19 } from "node:path";
 import {
   DEFAULT_CONFIG,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -9158,8 +9466,8 @@ import {
   extractAudioMetadata as extractAudioMetadata3,
   getFfprobeBinary,
   ManagedChildProcess,
-  renameWithRetry as renameWithRetry4,
-  runFfmpeg as runFfmpeg4,
+  renameWithRetry as renameWithRetry5,
+  runFfmpeg as runFfmpeg5,
   trackChildProcess
 } from "@hyperframes/engine";
 import { redactKnownPaths, redactTelemetryString as redactTelemetryString3 } from "@hyperframes/core";
@@ -9169,7 +9477,7 @@ import {
   aacSegmentCount,
   describeFfmpegFailure,
   extractAudioMetadata as extractAudioMetadata2,
-  runFfmpeg as runFfmpeg3
+  runFfmpeg as runFfmpeg4
 } from "@hyperframes/engine";
 var toDbfs = (token) => token.toLowerCase() === "-inf" ? Number.NEGATIVE_INFINITY : Number(token);
 function checkedDbfs(value) {
@@ -9193,7 +9501,7 @@ async function scanTruePeak(audioPath, trim, timeoutMs, signal) {
       else laterBlocks = Math.max(laterBlocks, block);
     }
   };
-  const result = await runFfmpeg3(
+  const result = await runFfmpeg4(
     ["-i", audioPath, "-map", "0:a:0", "-vn", "-af", `${trim}ebur128=peak=true`, "-f", "null", "-"],
     { signal, timeout: timeoutMs, onStderr: readLines }
   );
@@ -9353,7 +9661,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       error: `audioPadTrim: failed to materialize ${plan.operation}: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    for (const path of plan.cleanupPaths) rmSync8(path, { force: true });
+    for (const path of plan.cleanupPaths) rmSync9(path, { force: true });
   }
   let loweredDb = 0;
   if (probeTruePeak) {
@@ -9400,8 +9708,8 @@ async function constrainAacTruePeak(input) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync3(join18(dirname7(input.audioPath), ".true-peak-"));
-    const correctedPath = join18(scratchDir, "audio.m4a");
+    scratchDir = mkdtempSync3(join19(dirname8(input.audioPath), ".true-peak-"));
+    const correctedPath = join19(scratchDir, "audio.m4a");
     const measurements = [];
     let attenuationDb = 0;
     let sourcePeakDbfs;
@@ -9416,7 +9724,7 @@ async function enforceAacTruePeak(input) {
       }
       if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
         if (measuredPath !== correctedPath) return { success: true };
-        renameWithRetry4(correctedPath, input.audioPath);
+        renameWithRetry5(correctedPath, input.audioPath);
         return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
@@ -9457,7 +9765,7 @@ async function enforceAacTruePeak(input) {
       )}`
     };
   } finally {
-    if (scratchDir) rmSync8(scratchDir, { recursive: true, force: true });
+    if (scratchDir) rmSync9(scratchDir, { recursive: true, force: true });
   }
 }
 function failResult(outputPath, target, source, error) {
@@ -9534,7 +9842,7 @@ async function defaultProbeAudioInfo(audioPath, signal) {
   };
 }
 async function defaultRunFfmpeg(args, timeoutMs, signal) {
-  return toStepResult(await runFfmpeg4(args, { signal, timeout: timeoutMs }), timeoutMs);
+  return toStepResult(await runFfmpeg5(args, { signal, timeout: timeoutMs }), timeoutMs);
 }
 function defaultAacEncoder(timeoutMs, signal, pcmSourcePath) {
   return async (inputPath, outputPath, durationSeconds, filter) => {
@@ -9604,7 +9912,7 @@ function assertAudioNotInterrupted(failures) {
 }
 async function runAudioStage(input) {
   const stageStart = Date.now();
-  const pcmSourcePath = join19(input.workDir, "audio-source.wav");
+  const pcmSourcePath = join20(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
   try {
     const result = await mixAudioForDelivery(input, duration, pcmSourcePath);
@@ -9624,7 +9932,7 @@ async function runAudioStage(input) {
     }
     return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
   } finally {
-    rmSync9(pcmSourcePath, { force: true });
+    rmSync10(pcmSourcePath, { force: true });
   }
 }
 async function mixAudioForDelivery(input, duration, pcmSourcePath) {
@@ -9642,7 +9950,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertNotAborted,
     log
   } = input;
-  const audioOutputPath = join19(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join20(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -9653,7 +9961,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join19(workDir, "audio-work"),
+        join20(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -9722,7 +10030,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 
 // src/services/render/stages/captureStage.ts
 import { existsSync as existsSync12, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
   frameFileExtension,
@@ -9795,13 +10103,13 @@ function measureCaptureFrameBytes(workDir, framesDir) {
   if (!existsSync12(workDir)) return total;
   for (const attempt of readdirSync3(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join20(workDir, attempt));
+      total += sampleDirectoryBytes(join21(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join20(workDir, attempt);
+    const attemptDir = join21(workDir, attempt);
     for (const name of readdirSync3(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join20(attemptDir, name));
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join21(attemptDir, name));
     }
   }
   return total;
@@ -10094,8 +10402,8 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 }
 
 // src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8 } from "node:fs";
+import { join as join25 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
   cloneCaptureWarnings as cloneCaptureWarnings2,
@@ -10167,7 +10475,7 @@ function createHdrImageTransferCache(options = {}) {
 }
 
 // src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import {
   TRANSITIONS,
   crossfade
@@ -10292,7 +10600,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join21(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join22(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -10324,7 +10632,7 @@ async function runSequentialLayeredFrameLoop(input) {
 }
 
 // src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import {
   TRANSITIONS as TRANSITIONS2,
   closeCaptureSession as closeCaptureSession6,
@@ -10338,7 +10646,7 @@ import {
 // src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname8, join as join22 } from "node:path";
+import { dirname as dirname9, join as join23 } from "node:path";
 import { createRequire } from "node:module";
 import { existsSync as existsSync13 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
@@ -10351,10 +10659,10 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname8(fileURLToPath3(import.meta.url));
-  const jsPath = join22(moduleDir, "shaderTransitionWorker.js");
+  const moduleDir = dirname9(fileURLToPath3(import.meta.url));
+  const jsPath = join23(moduleDir, "shaderTransitionWorker.js");
   if (existsSync13(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join22(moduleDir, "shaderTransitionWorker.ts");
+  const tsPath = join23(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -10497,8 +10805,8 @@ async function createShaderTransitionWorkerPool(opts) {
       if (terminated) {
         throw new Error("shader-blend pool already terminated");
       }
-      return new Promise((resolve10, reject) => {
-        const task = traceEnabled ? { req, resolve: resolve10, reject, enqueuedAtMs: Date.now(), traceId: ++nextTaskId } : { req, resolve: resolve10, reject };
+      return new Promise((resolve11, reject) => {
+        const task = traceEnabled ? { req, resolve: resolve11, reject, enqueuedAtMs: Date.now(), traceId: ++nextTaskId } : { req, resolve: resolve11, reject };
         const idle = slots.find((s) => !s.busy && !s.dead);
         if (idle) {
           queue.unshift(task);
@@ -10722,7 +11030,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join23(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join24(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -10910,9 +11218,9 @@ async function runCaptureHdrStage(input) {
         if (hdrVideoFrameSources.has(v.id)) hdrVideoEndTimes.set(v.id, v.end);
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-      const debugDumpDir = debugDumpEnabled ? join24(framesDir, "debug-composite") : null;
+      const debugDumpDir = debugDumpEnabled ? join25(framesDir, "debug-composite") : null;
       if (debugDumpDir && !existsSync14(debugDumpDir)) {
-        mkdirSync7(debugDumpDir, { recursive: true });
+        mkdirSync8(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
       const hdrTargetTransfer = compositeTransfer === "srgb" ? void 0 : compositeTransfer;
@@ -11065,24 +11373,24 @@ async function runCaptureHdrStage(input) {
 
 // src/services/render/stages/encodeStage.ts
 import {
-  copyFileSync as copyFileSync3,
+  copyFileSync as copyFileSync4,
   existsSync as existsSync15,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
-  rmSync as rmSync10,
-  statSync as statSync6,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync8,
+  rmSync as rmSync11,
+  statSync as statSync7,
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname9, join as join25 } from "node:path";
+import { dirname as dirname10, join as join26 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
   formatFfmpegError,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME2,
   resolveConfig,
-  runFfmpeg as runFfmpeg5,
+  runFfmpeg as runFfmpeg6,
   spawnStreamingEncoder as spawnStreamingEncoder4
 } from "@hyperframes/engine";
 import {
@@ -11158,17 +11466,17 @@ function gifEncodeFailure(startTime, outputPath, error, failureReason) {
 }
 async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
   const { outputPath } = argsInput;
-  const result = await runFfmpeg5(buildGifPaletteuseArgs({ ...argsInput, wholeFrames: true }), run);
+  const result = await runFfmpeg6(buildGifPaletteuseArgs({ ...argsInput, wholeFrames: true }), run);
   if (!result.success) {
     const error = formatFfmpegError(result.exitCode, result.stderr);
     return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
   }
-  const gif = readFileSync7(outputPath);
+  const gif = readFileSync8(outputPath);
   if (!clearGifFramesBeforeNext(gif)) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
   }
-  writeFileSync4(outputPath, gif);
+  writeFileSync5(outputPath, gif);
   return null;
 }
 async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
@@ -11190,17 +11498,17 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
   try {
     const run = { signal: input.signal, timeout: input.timeout };
     for (const args of [buildGifPalettegenArgs(argsInput), buildGifPaletteuseArgs(argsInput)]) {
-      const result = await runFfmpeg5(args, run);
+      const result = await runFfmpeg6(args, run);
       if (!result.success) {
         const error = formatFfmpegError(result.exitCode, result.stderr);
         return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
       }
     }
-    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync7(outputPath)) !== false) {
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync8(outputPath)) !== false) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync15(outputPath) ? statSync6(outputPath).size : 0;
+    const fileSize = existsSync15(outputPath) ? statSync7(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -11209,7 +11517,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       fileSize
     };
   } finally {
-    rmSync10(input.palettePath, { force: true });
+    rmSync11(input.palettePath, { force: true });
   }
 }
 function startEncodeProgress(job, stage, onProgress) {
@@ -11281,10 +11589,10 @@ function encodeWhileCapturing(input, totalFrames) {
     const stream = await encoder;
     for (let next = 0; next < totalFrames; next++) {
       while (!landed.has(next) && !captureDone && !signal.aborted) {
-        await new Promise((resolve10) => wake = resolve10);
+        await new Promise((resolve11) => wake = resolve11);
       }
       if (signal.aborted) return;
-      const mergedPath = join25(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const mergedPath = join26(input.framesDir, formatCaptureFrameName(next, "jpg"));
       const frame = await readLandedFrame(landed.get(next), mergedPath);
       landed.delete(next);
       if (!await stream.writeFrame(frame)) {
@@ -11359,7 +11667,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync15(outputPath)) mkdirSync8(outputPath, { recursive: true });
+    if (!existsSync15(outputPath)) mkdirSync9(outputPath, { recursive: true });
     const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -11367,11 +11675,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join25(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync3(join25(framesDir, name), dst);
+      const dst = join26(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync4(join26(framesDir, name), dst);
     });
     if (hasAudio && audioOutputPath && existsSync15(audioOutputPath)) {
-      copyFileSync3(audioOutputPath, join25(outputPath, MIXED_AUDIO_FILENAME2));
+      copyFileSync4(audioOutputPath, join26(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
       );
@@ -11391,7 +11699,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join25(dirname9(videoOnlyPath), "gif-palette.png"),
+      palettePath: join26(dirname10(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -11601,9 +11909,9 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries) {
-      const full = join26(current, name);
+      const full = join27(current, name);
       try {
-        const st = statSync7(full);
+        const st = statSync8(full);
         if (st.isDirectory()) {
           stack.push(full);
         } else if (st.isFile()) {
@@ -11750,8 +12058,8 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join26(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync16(framePath) || statSync7(framePath).size <= 8;
+    const framePath = join27(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const missing = !existsSync16(framePath) || statSync8(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -11767,7 +12075,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
 function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0, stride = 1) {
   const workersPerBatch = Math.max(1, Math.floor(maxWorkers));
   const batches = [];
-  const outputDirFor = (batchIndex, workerId) => join26(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
+  const outputDirFor = (batchIndex, workerId) => join27(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
   if (stride > 1) {
     const spans = /* @__PURE__ */ new Map();
     for (const range of ranges) {
@@ -11827,8 +12135,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform2 = process.platform, systemTempDir = tmpdir2()) {
-  if (platform2 === "win32" || platform2 === "darwin") return join26(systemTempDir, "hf-render-");
-  return join26(dirname10(outputPath), `work-${jobId}-`);
+  if (platform2 === "win32" || platform2 === "darwin") return join27(systemTempDir, "hf-render-");
+  return join27(dirname11(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -11870,7 +12178,7 @@ The composition is too large for the available memory. To reduce memory pressure
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join26(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join27(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync16(framePath)) captured++;
   }
   return captured;
@@ -11896,7 +12204,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join26(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join27(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -12502,18 +12810,18 @@ function deVerifyFallbackTelemetry(err) {
   };
 }
 function resolveRenderDebugDir() {
-  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve7(process.env.PRODUCER_RENDERS_DIR, "..") : resolve7(dirname10(fileURLToPath4(import.meta.url)), "../..");
-  return join26(producerRoot, ".debug");
+  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname11(fileURLToPath4(import.meta.url)), "../..");
+  return join27(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
-  const outputDir = dirname10(outputPath);
-  if (!existsSync16(outputDir)) mkdirSync9(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join26(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
+  const outputDir = dirname11(outputPath);
+  if (!existsSync16(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  const workDir = job.config.debug ? join27(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join26(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join27(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -12527,7 +12835,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
       log.info("KEEP_TEMP=1, leaving workDir on disk for inspection", { workDir });
       return;
     }
-    rmSync11(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    rmSync12(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   });
   try {
     await executeRenderPipeline({
@@ -12573,7 +12881,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join26(workDir, "perf-summary.json");
+  const perfOutputPath = join27(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -12646,7 +12954,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync16(workDir)) mkdirSync9(workDir, { recursive: true });
+    if (!existsSync16(workDir)) mkdirSync10(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -12675,22 +12983,22 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join26(projectDir, entryFile);
+    let htmlPath = join27(projectDir, entryFile);
     if (!existsSync16(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync8(htmlPath, "utf-8");
+    const rawEntry = readFileSync9(htmlPath, "utf-8");
     if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join26(workDir, "standalone-entry.html");
-      const projectIndexPath = join26(projectDir, "index.html");
+      const wrapperPath = join27(workDir, "standalone-entry.html");
+      const projectIndexPath = join27(projectDir, "index.html");
       if (!existsSync16(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync8(projectIndexPath, "utf-8"),
+        readFileSync9(projectIndexPath, "utf-8"),
         entryFile,
         rawEntry
       );
@@ -12699,7 +13007,7 @@ async function executeRenderPipeline(input) {
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync5(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync6(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -12846,7 +13154,7 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join26(workDir, "compiled");
+    const compiledDir = join27(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -12980,7 +13288,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join26(workDir, "compiled"),
+          compiledDir: join27(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -12998,8 +13306,8 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join26(workDir, "captured-frames");
-    if (!existsSync16(framesDir)) mkdirSync9(framesDir, { recursive: true });
+    const framesDir = join27(workDir, "captured-frames");
+    if (!existsSync16(framesDir)) mkdirSync10(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
     });
@@ -13470,7 +13778,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join26(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join27(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -13723,7 +14031,7 @@ async function executeRenderPipeline(input) {
           pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join26(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join27(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -13738,10 +14046,10 @@ async function executeRenderPipeline(input) {
             });
           }
           if (completedSegments.size === 0) {
-            rmSync11(segmentDir, { recursive: true, force: true });
+            rmSync12(segmentDir, { recursive: true, force: true });
           }
         } else {
-          rmSync11(segmentDir, { recursive: true, force: true });
+          rmSync12(segmentDir, { recursive: true, force: true });
         }
         const segmentManifest = readSegmentManifest(segmentDir) ?? {
           version: 1,
@@ -13822,7 +14130,7 @@ async function executeRenderPipeline(input) {
           );
           updateCaptureObservability({ segmentRetries: segmentedRes.segmentRetries });
           if (job.config.keepSegments !== true) {
-            rmSync11(segmentDir, { recursive: true, force: true });
+            rmSync12(segmentDir, { recursive: true, force: true });
           }
         } else {
           capturePlan = replanAfterFailure(capturePlan, { kind: "streaming_unavailable" });
@@ -14094,8 +14402,8 @@ async function executeRenderPipeline(input) {
             "capture_disk",
             "drawElement capture failed; retrying with a fresh screenshot session"
           );
-          rmSync11(framesDir, { recursive: true, force: true });
-          mkdirSync9(framesDir, { recursive: true });
+          rmSync12(framesDir, { recursive: true, force: true });
+          mkdirSync10(framesDir, { recursive: true });
           resetCaptureAttemptProgress(job);
           dedupPerfs.length = 0;
           cfg.useDrawElement = false;
@@ -14271,7 +14579,7 @@ async function executeRenderPipeline(input) {
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync5(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync6(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -14281,8 +14589,8 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && !isHls && existsSync16(stagedOutputPath)) {
-        const debugOutput = join26(workDir, `output${videoExt}`);
-        copyFileSync4(stagedOutputPath, debugOutput);
+        const debugOutput = join27(workDir, `output${videoExt}`);
+        copyFileSync5(stagedOutputPath, debugOutput);
       }
     }
     await commitArtifactTransaction(artifactTransaction, () => {
@@ -14387,14 +14695,14 @@ async function executeRenderPipeline(input) {
 // src/services/hyperframeLint.ts
 import {
   existsSync as existsSync17,
-  readFileSync as readFileSync9,
-  statSync as statSync8,
-  openSync as openSync4,
+  readFileSync as readFileSync10,
+  statSync as statSync9,
+  openSync as openSync5,
   fstatSync as fstatSync3,
-  closeSync as closeSync4,
+  closeSync as closeSync5,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve8, join as join27, relative as relative3, isAbsolute as isAbsolute3, sep as sep2 } from "node:path";
+import { resolve as resolve9, join as join28, relative as relative3, isAbsolute as isAbsolute3, sep as sep2 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -14424,30 +14732,30 @@ function pickEntryFile(files, preferredEntryFile) {
 function readEntryHtml(filePath) {
   let fd;
   try {
-    fd = openSync4(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
+    fd = openSync5(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
-    if (!statSync8(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    if (!statSync9(filePath, { throwIfNoEntry: false })?.isFile()) return null;
     throw error;
   }
   try {
     if (!fstatSync3(fd).isFile()) return null;
-    return readFileSync9(fd, "utf-8");
+    return readFileSync10(fd, "utf-8");
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
-  const absProjectDir = resolve8(projectDir);
-  if (!existsSync17(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  const absProjectDir = resolve9(projectDir);
+  if (!existsSync17(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
     (value) => typeof value === "string" && value.trim().length > 0
   );
   for (const entryFile of entryCandidates) {
-    const absoluteEntryPath = resolve8(absProjectDir, entryFile);
+    const absoluteEntryPath = resolve9(absProjectDir, entryFile);
     const entryRelativePath = relative3(absProjectDir, absoluteEntryPath);
     if (entryRelativePath === ".." || entryRelativePath.startsWith(`..${sep2}`) || isAbsolute3(entryRelativePath)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
@@ -14462,7 +14770,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join27(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join28(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -14508,7 +14816,7 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname11, join as join28 } from "node:path";
+import { dirname as dirname12, join as join29 } from "node:path";
 import { existsSync as existsSync18 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -14527,12 +14835,12 @@ async function startHealthWorker(options = {}) {
     stdout: false,
     stderr: false
   });
-  await new Promise((resolve10, reject) => {
+  await new Promise((resolve11, reject) => {
     const onMessage = (msg) => {
       if (msg?.type === "listening") {
         worker.off("error", onError);
         worker.off("message", onMessage);
-        resolve10();
+        resolve11();
       } else if (msg?.type === "listen-error") {
         worker.off("error", onError);
         worker.off("message", onMessage);
@@ -14583,8 +14891,8 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname11(fileURLToPath5(import.meta.url));
-  const candidates = [join28(here, "healthWorkerThread.js"), join28(here, "healthWorkerThread.ts")];
+  const here = dirname12(fileURLToPath5(import.meta.url));
+  const candidates = [join29(here, "healthWorkerThread.js"), join29(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync18(candidate)) return candidate;
   }
@@ -14620,7 +14928,7 @@ import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
 
 // src/services/distributed/plan.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframes/engine";
-import { extname as extname4, isAbsolute as isAbsolute4, join as join29, relative as relative4, sep as sep3 } from "node:path";
+import { extname as extname4, isAbsolute as isAbsolute4, join as join30, relative as relative4, sep as sep3 } from "node:path";
 import {
   fpsToNumber as fpsToNumber10,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -14630,7 +14938,7 @@ import {
   normalizeVp9CpuUsed,
   resolveConfig as resolveConfig3,
   declareContentAddressedUrl,
-  renameWithRetry as renameWithRetry6,
+  renameWithRetry as renameWithRetry7,
   declareProbeFactsUrl
 } from "@hyperframes/engine";
 
@@ -14701,10 +15009,10 @@ var DISTRIBUTED_RENDER_CAPABILITIES = Object.freeze({
 var FIELD_DELIMITER = Buffer.from([0]);
 
 // src/services/distributed/chunkAudio.ts
-import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg6 } from "@hyperframes/engine";
+import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
 
 // src/services/distributed/mp4Stitch.ts
-import { renameWithRetry as renameWithRetry5 } from "@hyperframes/engine";
+import { renameWithRetry as renameWithRetry6 } from "@hyperframes/engine";
 var SCAN_BYTES = 64 * 1024;
 
 // src/services/distributed/chunkAudio.ts
@@ -14724,9 +15032,9 @@ var PLAN_ROOT_CATEGORY = {
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join29("meta", "composition.json"),
-  join29("meta", "encoder.json"),
-  join29("meta", "chunks.json")
+  join30("meta", "composition.json"),
+  join30("meta", "encoder.json"),
+  join30("meta", "chunks.json")
 ];
 
 // src/services/distributed/renderConfigValidation.ts
@@ -14957,6 +15265,8 @@ var DEFAULT_SERVER_FPS = { num: 30, den: 1 };
 var SSE_KEEPALIVE_MS = 3e4;
 var SAFE_RENDER_ERROR_CODES = /* @__PURE__ */ new Set([
   "ASSET_MEDIA_TYPE_MISMATCH",
+  "HEIF_IMAGE_CONVERSION_FAILED",
+  "HEIF_TOOL_UNAVAILABLE",
   "NOT_MEDIA_PAYLOAD",
   "INVALID_VIDEO_METADATA",
   "VIDEO_SOURCE_UNRENDERABLE",
@@ -15092,8 +15402,8 @@ function buildRenderJobConfig(input, outputPath, log) {
 function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
-  const outputDir = dirname12(absoluteOutputPath);
-  if (!existsSync19(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  const outputDir = dirname13(absoluteOutputPath);
+  if (!existsSync19(outputDir)) mkdirSync11(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -15133,12 +15443,12 @@ var MAX_PREVIEW_HTML_BYTES = 20 * 1024 * 1024;
 function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
-  const absProjectDir = resolve9(candidate);
-  if (!existsSync19(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
+  const absProjectDir = resolve10(candidate);
+  if (!existsSync19(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync19(resolve9(absProjectDir, entry))) {
+  if (!existsSync19(resolve10(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -15159,8 +15469,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync4(join30(tempRoot, "producer-project-"));
-  writeFileSync6(join30(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync4(join31(tempRoot, "producer-project-"));
+  writeFileSync7(join31(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -15185,7 +15495,7 @@ function resolveOutputPath(projectDir, outputCandidate, rendersDir, log) {
   try {
     return resolveRenderPaths(projectDir, outputCandidate, rendersDir).absoluteOutputPath;
   } catch (error) {
-    const fallbackPath = resolve9(rendersDir, `producer-fallback-${Date.now()}.mp4`);
+    const fallbackPath = resolve10(rendersDir, `producer-fallback-${Date.now()}.mp4`);
     log.warn("Failed to resolve output path, using fallback", {
       fallback: fallbackPath,
       error: error instanceof Error ? error.message : String(error)
@@ -15221,7 +15531,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync12(dir, { recursive: true, force: true });
+    rmSync13(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -15230,7 +15540,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync19(path) ? statSync9(path).size : 0;
+  return existsSync19(path) ? statSync10(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -15536,7 +15846,7 @@ function createRenderHandlers(options = {}) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync9(artifact.path);
+    const stats = statSync10(artifact.path);
     return new Response(createReadStream3(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -15603,7 +15913,7 @@ function startServer(options = {}) {
   process.on("SIGINT", () => shutdown("SIGINT"));
   return server;
 }
-var entryScript = process.argv[1] ? resolve9(process.argv[1]) : "";
+var entryScript = process.argv[1] ? resolve10(process.argv[1]) : "";
 var isPublicServerEntry = entryScript.endsWith("/public-server.js") || entryScript.endsWith("/src/server.ts");
 if (isPublicServerEntry) {
   const { values } = parseArgs({