hyperframes 0.8.26 → 0.8.28

package/dist/fontLocalizeCli.js

@@ -3433,10 +3433,10 @@ function compareDocumentPosition(nodeA, nodeB) {
 function uniqueSort(nodes) {
   nodes = nodes.filter((node, i, arr) => !arr.includes(node, i + 1));
   nodes.sort((a, b) => {
-    const relative7 = compareDocumentPosition(a, b);
-    if (relative7 & DocumentPosition.PRECEDING) {
+    const relative8 = compareDocumentPosition(a, b);
+    if (relative8 & DocumentPosition.PRECEDING) {
       return -1;
-    } else if (relative7 & DocumentPosition.FOLLOWING) {
+    } else if (relative8 & DocumentPosition.FOLLOWING) {
       return 1;
     }
     return 0;
@@ -5771,10 +5771,10 @@ function parse2(formula) {
   if (idx < formula.length && formula.charAt(idx) === "n") {
     idx++;
     a = sign * (number !== null && number !== void 0 ? number : 1);
-    skipWhitespace();
+    skipWhitespace2();
     if (idx < formula.length) {
       sign = readSign();
-      skipWhitespace();
+      skipWhitespace2();
       number = readNumber();
     } else {
       sign = number = 0;
@@ -5803,7 +5803,7 @@ function parse2(formula) {
     }
     return idx === start ? null : value;
   }
-  function skipWhitespace() {
+  function skipWhitespace2() {
     while (idx < formula.length && whitespace.has(formula.charCodeAt(idx))) {
       idx++;
     }
@@ -17022,7 +17022,7 @@ var require_util = __commonJS({
       return path;
     }
     exports.normalize = normalize;
-    function join56(aRoot, aPath) {
+    function join57(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -17054,11 +17054,11 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join56;
+    exports.join = join57;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
-    function relative7(aRoot, aPath) {
+    function relative8(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -17077,7 +17077,7 @@ var require_util = __commonJS({
       }
       return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
     }
-    exports.relative = relative7;
+    exports.relative = relative8;
     var supportsNullProto = (function() {
       var obj = /* @__PURE__ */ Object.create(null);
       return !("__proto__" in obj);
@@ -17227,7 +17227,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join56(urlGenerate(parsed), sourceURL);
+        sourceURL = join57(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -50174,13 +50174,6 @@ function checkOutputResolutionCompatibility(input) {
       message: `outputResolution cannot be combined with hdrMode='force-hdr'. HDR rendering composites at composition dimensions and does not yet support supersampling. Pick one or render in two passes.`
     };
   }
-  if (input.alphaRequested) {
-    return {
-      ok: false,
-      kind: "alpha-incompatible",
-      message: `outputResolution cannot be combined with alpha output (--format webm|mov|png-sequence). The alpha screenshot path does not yet apply deviceScaleFactor and would silently produce composition-resolution frames. Render alpha at composition resolution and upscale separately, or use --format mp4.`
-    };
-  }
   const target = CANVAS_DIMENSIONS[outputResolution];
   if (target.width * compositionHeight !== target.height * compositionWidth) {
     return buildAspectMismatch(compositionWidth, compositionHeight, outputResolution, target);
@@ -52567,7 +52560,7 @@ var init_telemetryRedaction = __esm({
 
 // ../core/dist/safePath.js
 import { resolve as resolve3, sep, join as join2, dirname as dirname3, basename } from "path";
-import { realpathSync } from "fs";
+import { lstatSync, realpathSync } from "fs";
 var init_safePath = __esm({
   "../core/dist/safePath.js"() {
     "use strict";
@@ -57686,6 +57679,7 @@ var init_captureFailure = __esm({
     PROTOCOL_TIMEOUT_PATTERNS = [
       /Runtime\.callFunctionOn timed out/i,
       /Runtime\.evaluate timed out/i,
+      /Page\.captureScreenshot timed out/i,
       /HeadlessExperimental\.beginFrame timed out/i,
       /drawElement worker encode timed out \(frame \d+\)/i,
       /Protocol error[\s\S]*tim(?:ed|e) out/i,
@@ -58652,6 +58646,18 @@ function recordScriptLoadFailure(session, url) {
     session.scriptLoadFailures.push(url);
   }
 }
+function classifyConsoleScriptFailure(type, text) {
+  if (type !== "error") return null;
+  if (text.startsWith("[HyperFrames] composition script error:")) {
+    const detail = text.slice("[HyperFrames] composition script error:".length).trim();
+    const compId = detail.split(" ")[0] || "unknown";
+    return `runtime-error:${compId}`;
+  }
+  if (/failed to find a valid digest in the ['"]integrity['"] attribute/i.test(text) && /resource has been blocked/i.test(text)) {
+    return "runtime-error:subresource-integrity";
+  }
+  return null;
+}
 async function initializeSession(session) {
   const { page, serverUrl } = session;
   page.on("console", (msg) => {
@@ -58661,11 +58667,8 @@ async function initializeSession(session) {
     const diagnostic = formatConsoleDiagnostic(type, text, locationUrl);
     if (!diagnostic.suppressHostLog) console.log(diagnostic.text);
     appendBrowserDiagnostic(session, diagnostic.text);
-    if (type === "error" && text.startsWith("[HyperFrames] composition script error:")) {
-      const detail = text.slice("[HyperFrames] composition script error:".length).trim();
-      const compId = detail.split(" ")[0] || "unknown";
-      recordScriptLoadFailure(session, `runtime-error:${compId}`);
-    }
+    const scriptFailure = classifyConsoleScriptFailure(type, text);
+    if (scriptFailure) recordScriptLoadFailure(session, scriptFailure);
   });
   page.on("pageerror", (err) => {
     const message = err instanceof Error ? err.message : String(err);
@@ -62143,7 +62146,7 @@ import {
   linkSync,
   mkdtempSync,
   mkdirSync as mkdirSync4,
-  lstatSync,
+  lstatSync as lstatSync2,
   openSync,
   readdirSync as readdirSync3,
   rmdirSync,
@@ -62257,9 +62260,9 @@ function sameCacheLockStatGeneration(left, right) {
 }
 function observeCachePathLock(lockPath) {
   for (let pass = 0; pass < 3; pass += 1) {
-    const before2 = lstatSync(lockPath);
+    const before2 = lstatSync2(lockPath);
     const owner = readdirSync3(lockPath).find((name) => name.startsWith(CACHE_LOCK_OWNER_PREFIX));
-    const after2 = lstatSync(lockPath);
+    const after2 = lstatSync2(lockPath);
     if (sameCacheLockStatGeneration(before2, after2)) return { stats: after2, owner };
   }
   throw new UrlDownloadError("filesystem", true, "Cache lock changed repeatedly during inspection");
@@ -62770,7 +62773,7 @@ function syncAndPublishPartial(partialPath, localPath) {
     if (code !== "EEXIST") throw error;
     let winner;
     try {
-      winner = lstatSync(localPath);
+      winner = lstatSync2(localPath);
     } catch (inspectionError) {
       if (inspectionError.code !== "ENOENT") throw inspectionError;
       throw new UrlDownloadError(
@@ -62966,7 +62969,7 @@ async function reuseOrInvalidateCachedFile(url, localPath, timeoutMs, signal, op
     for (let pass = 0; pass < 3; pass += 1) {
       let before2;
       try {
-        before2 = lstatSync(localPath);
+        before2 = lstatSync2(localPath);
       } catch (error) {
         if (error.code === "ENOENT") continue;
         throw error;
@@ -62984,7 +62987,7 @@ async function reuseOrInvalidateCachedFile(url, localPath, timeoutMs, signal, op
       }
       let after2;
       try {
-        after2 = lstatSync(localPath);
+        after2 = lstatSync2(localPath);
       } catch (error) {
         if (error.code === "ENOENT") continue;
         throw error;
@@ -63440,7 +63443,7 @@ function scopeSelector(selector, scope, compositionId, authoredRootId, compoundA
   if (/^(html|body|:root)$/i.test(trimmed)) {
     return scopeRootSelectors ? compositionBoxSelector(scope) : selector;
   }
-  const compositionIdPattern = new RegExp(`\\[\\s*data-composition-id\\s*=\\s*(["'])${escapeRegExp(compositionId)}\\1\\s*\\]`, "g");
+  const compositionIdPattern = new RegExp(`\\[\\s*data-composition-id\\s*[\\^\\*\\$]?=\\s*(["'])${escapeRegExp(compositionId)}\\1\\s*\\]`, "g");
   if (compositionIdPattern.test(trimmed)) {
     const isRootBoxSelector = trimmed.replace(compositionIdPattern, "").trim() === "";
     if (isRootBoxSelector) {
@@ -63492,7 +63495,12 @@ function scopeCssToComposition(css, compositionId, scopeSelectorOverride, author
   if (!css || !trimmedCompositionId)
     return css;
   const scope = scopeSelectorOverride || `[data-composition-id="${escapeCssAttributeValue(trimmedCompositionId)}"]`;
-  const root = postcss.parse(css);
+  let root;
+  try {
+    root = postcss.parse(css);
+  } catch {
+    return "";
+  }
   root.walkRules((rule) => {
     if (isInsideGlobalAtRule(rule))
       return;
@@ -69887,6 +69895,59 @@ function hasAttrName(tagSource, attr) {
   const attrs = tagSource.replace(/^<\s*[a-z][\w:-]*/i, "");
   return new RegExp(`(?:^|\\s)${escaped}(?:\\s*=|\\s|/?>)`, "i").test(attrs);
 }
+function srcKind(src) {
+  const stripped = src.trim();
+  if (!stripped) return null;
+  const lower = stripped.toLowerCase();
+  if (lower.startsWith("data:")) {
+    const mime = /^data:([^;,]+)/i.exec(stripped)?.[1]?.toLowerCase();
+    if (!mime) return null;
+    if (mime.startsWith("image/")) return "image";
+    if (mime.startsWith("video/")) return "video";
+    return null;
+  }
+  if (lower.startsWith("blob:")) return null;
+  let pathname = stripped;
+  try {
+    if (/^https?:/i.test(stripped)) {
+      pathname = decodeURIComponent(new URL(stripped).pathname);
+    } else {
+      pathname = stripped.split("?")[0]?.split("#")[0] ?? stripped;
+    }
+  } catch {
+    pathname = stripped.split("?")[0]?.split("#")[0] ?? stripped;
+  }
+  const base2 = pathname.split("/").pop() ?? "";
+  const dot = base2.lastIndexOf(".");
+  if (dot < 0) return null;
+  const ext = base2.slice(dot + 1).toLowerCase();
+  if (IMAGE_SRC_EXT.has(ext)) return "image";
+  if (VIDEO_SRC_EXT.has(ext)) return "video";
+  return null;
+}
+function findMediaSrcKindMismatchFindings(ctx) {
+  const findings = [];
+  for (const tag of ctx.tags) {
+    if (tag.name !== "video" && tag.name !== "img") continue;
+    const src = readAttr(tag.raw, "src");
+    if (!src) continue;
+    const kind = srcKind(src);
+    if (kind === null) continue;
+    if (tag.name === "video" && kind !== "image") continue;
+    if (tag.name === "img" && kind !== "video") continue;
+    const elementId = readAttr(tag.raw, "id") || void 0;
+    const expected = tag.name === "video" ? "video" : "image";
+    findings.push({
+      code: "media_src_kind_mismatch",
+      severity: "error",
+      message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> src is a ${kind}, not a ${expected}. The producer fail-closes when the tag and file kind disagree.`,
+      elementId,
+      fixHint: tag.name === "video" ? "Use <img> for a still, or point <video> at a video URL (mp4/webm/mov/\u2026)." : "Use <video> for a video URL, or point <img> at a still (png/jpg/webp/\u2026).",
+      snippet: truncateSnippet(tag.raw)
+    });
+  }
+  return findings;
+}
 function mediaHasResolvableSrc(tag, tags) {
   if (readAttr(tag.raw, "src")) return true;
   const end = tag.closeIndex ?? tag.endIndex;
@@ -71271,7 +71332,7 @@ async function lintHyperframeHtml(html, options = {}) {
     timings: { totalMs: performance.now() - startedAt, ...timings }
   };
 }
-var import_postcss_selector_parser, COMPOSITION_ID_IN_CSS_PATTERN, TIMELINE_REGISTRY_INIT_PATTERN, TIMELINE_REGISTRY_OBJECT_LITERAL_PATTERN, TIMELINE_REGISTRY_ASSIGN_PATTERN, WINDOW_TIMELINE_ASSIGN_PATTERN, INVALID_SCRIPT_CLOSE_PATTERN, TIMELINE_REGISTRY_KEY_PATTERN, TIMELINE_REGISTRY_OBJECT_OPEN_PATTERN, TIMELINE_REGISTRY_OBJECT_ENTRY_PATTERN, VISIBLE_MARKUP_COMMENT_PATTERN, VISIBLE_MARKUP_COMMENT_PROTECTED_BLOCK_PATTERN, coreRules, mediaRules, AUDIO_GROUP_TIMING_ATTRS, SCENE_BOUNDARY_EPSILON_SECONDS, UNRESOLVED_TARGET, gsapWindowsCache, CONFLICTING_TRANSLATE_PROPS, CONFLICTING_SCALE_PROPS, RELATIVE_TWEEN_VALUE, TRANSFORM_SENSITIVE_READ, TRANSFORM_INVARIANT_READ, CALLBACK_MEASUREMENT_PATTERN, NUMBER_METHODS, gsapRules, captionRules, MAX_COMPOSITION_LINES, MAX_TIMED_ELEMENTS_PER_TRACK, TRACK_DENSITY_EXEMPT_TAGS, CAPTION_CUE_TOKEN, HEAVY_OVERLAY_ELEMENT_COUNT_WARN, HEAVY_OVERLAY_EXEMPT_TAGS, HEAVY_OVERLAY_CSS_PATTERN, INLINE_STYLE_DISPLAY_NONE_PATTERN, compositionRules, adapterRules, TEXTURE_BASE_CLASS, TEXTURE_CLASS_PREFIX, textureRules, GENERIC_FAMILIES, fontRules, slideshowRules, RULE_GROUPS, LINT_RULE_COUNT, LINT_RULE_GROUP_COUNTS;
+var import_postcss_selector_parser, COMPOSITION_ID_IN_CSS_PATTERN, TIMELINE_REGISTRY_INIT_PATTERN, TIMELINE_REGISTRY_OBJECT_LITERAL_PATTERN, TIMELINE_REGISTRY_ASSIGN_PATTERN, WINDOW_TIMELINE_ASSIGN_PATTERN, INVALID_SCRIPT_CLOSE_PATTERN, TIMELINE_REGISTRY_KEY_PATTERN, TIMELINE_REGISTRY_OBJECT_OPEN_PATTERN, TIMELINE_REGISTRY_OBJECT_ENTRY_PATTERN, VISIBLE_MARKUP_COMMENT_PATTERN, VISIBLE_MARKUP_COMMENT_PROTECTED_BLOCK_PATTERN, coreRules, IMAGE_SRC_EXT, VIDEO_SRC_EXT, mediaRules, AUDIO_GROUP_TIMING_ATTRS, SCENE_BOUNDARY_EPSILON_SECONDS, UNRESOLVED_TARGET, gsapWindowsCache, CONFLICTING_TRANSLATE_PROPS, CONFLICTING_SCALE_PROPS, RELATIVE_TWEEN_VALUE, TRANSFORM_SENSITIVE_READ, TRANSFORM_INVARIANT_READ, CALLBACK_MEASUREMENT_PATTERN, NUMBER_METHODS, gsapRules, captionRules, MAX_COMPOSITION_LINES, MAX_TIMED_ELEMENTS_PER_TRACK, TRACK_DENSITY_EXEMPT_TAGS, CAPTION_CUE_TOKEN, HEAVY_OVERLAY_ELEMENT_COUNT_WARN, HEAVY_OVERLAY_EXEMPT_TAGS, HEAVY_OVERLAY_CSS_PATTERN, INLINE_STYLE_DISPLAY_NONE_PATTERN, compositionRules, adapterRules, TEXTURE_BASE_CLASS, TEXTURE_CLASS_PREFIX, textureRules, GENERIC_FAMILIES, fontRules, slideshowRules, RULE_GROUPS, LINT_RULE_COUNT, LINT_RULE_GROUP_COUNTS;
 var init_dist3 = __esm({
   "../lint/dist/index.js"() {
     "use strict";
@@ -71398,7 +71459,12 @@ var init_dist3 = __esm({
           let root;
           try {
             root = postcss2.parse(style.content);
-          } catch {
+          } catch (error) {
+            findings.push({
+              code: "css_parse_error",
+              severity: "error",
+              message: `CSS parse error: ${error instanceof Error ? error.message : "unknown"}`
+            });
             continue;
           }
           root.walkRules((rule) => {
@@ -71539,7 +71605,7 @@ var init_dist3 = __esm({
           {
             pattern: /crypto\.getRandomValues\s*\(/,
             label: "crypto.getRandomValues()",
-            hint: "Remove time-dependent code. Use a seeded PRNG for deterministic renders."
+            hint: "Use a seeded PRNG (e.g. a simple mulberry32) so renders are deterministic across frames."
           },
           {
             pattern: /gsap\.utils\.random\s*\(/,
@@ -71575,6 +71641,31 @@ var init_dist3 = __esm({
         return findings;
       }
     ];
+    IMAGE_SRC_EXT = /* @__PURE__ */ new Set([
+      "jpg",
+      "jpeg",
+      "png",
+      "gif",
+      "bmp",
+      "webp",
+      "svg",
+      "heic",
+      "heif",
+      "tiff",
+      "ico"
+    ]);
+    VIDEO_SRC_EXT = /* @__PURE__ */ new Set([
+      "mp4",
+      "mov",
+      "avi",
+      "webm",
+      "mkv",
+      "flv",
+      "wmv",
+      "m4v",
+      "mpg",
+      "mpeg"
+    ]);
     mediaRules = [
       // duplicate_media_id + duplicate_media_discovery_risk
       ({ tags }) => {
@@ -71778,6 +71869,8 @@ var init_dist3 = __esm({
         }
         return findings;
       },
+      // media_src_kind_mismatch
+      findMediaSrcKindMismatchFindings,
       // placeholder_media_url
       ({ tags }) => {
         const findings = [];
@@ -74725,7 +74818,7 @@ var init_extractedFrameIndex = __esm({
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import {
   existsSync as existsSync9,
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync5,
   renameSync,
@@ -74829,7 +74922,7 @@ function isPartialChild(name) {
 }
 function directorySizeBytes(path) {
   try {
-    const stat = lstatSync2(path);
+    const stat = lstatSync3(path);
     if (!stat.isDirectory()) return stat.size;
   } catch {
     return 0;
@@ -74844,7 +74937,7 @@ function directorySizeBytes(path) {
   for (const child of children) {
     const childPath = join10(path, child);
     try {
-      const stat = lstatSync2(childPath);
+      const stat = lstatSync3(childPath);
       if (stat.isDirectory()) {
         total += directorySizeBytes(childPath);
       } else {
@@ -79117,12 +79210,17 @@ var init_fileServer = __esm({
       ".gif": "image/gif",
       ".svg": "image/svg+xml",
       ".webp": "image/webp",
+      ".avif": "image/avif",
+      ".ico": "image/vnd.microsoft.icon",
       ".mp4": "video/mp4",
+      ".mov": "video/quicktime",
       ".webm": "video/webm",
       ".mp3": "audio/mpeg",
       ".wav": "audio/wav",
       ".ogg": "audio/ogg",
       ".aac": "audio/aac",
+      ".flac": "audio/flac",
+      ".m4a": "audio/mp4",
       ".woff": "font/woff",
       ".woff2": "font/woff2",
       ".ttf": "font/ttf",
@@ -84141,7 +84239,15 @@ __export(fontCompression_exports, {
   fontToDataUri: () => fontToDataUri
 });
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
+import {
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync10,
+  mkdtempSync as mkdtempSync5,
+  readFileSync as readFileSync7,
+  renameSync as renameSync4,
+  rmSync as rmSync8,
+  writeFileSync as writeFileSync8
+} from "fs";
 import { homedir as homedir4, tmpdir as tmpdir4 } from "os";
 import { dirname as dirname11, join as join24 } from "path";
 async function compressToWoff2(input) {
@@ -84168,15 +84274,17 @@ function readCachedCompression(path) {
   }
 }
 function cacheCompression(path, compressed) {
-  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+  let tempDir;
   try {
     mkdirSync10(dirname11(path), { recursive: true });
+    tempDir = mkdtempSync5(join24(dirname11(path), ".compression-"));
+    const tmpPath = join24(tempDir, "font.woff2");
     writeFileSync8(tmpPath, compressed, { flag: "wx", mode: 420 });
     renameSync4(tmpPath, path);
   } catch {
   } finally {
     try {
-      rmSync8(tmpPath, { force: true });
+      if (tempDir) rmSync8(tempDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -84226,7 +84334,7 @@ init_src();
 import {
   existsSync as existsSync30,
   mkdirSync as mkdirSync17,
-  mkdtempSync as mkdtempSync7,
+  mkdtempSync as mkdtempSync9,
   readFileSync as readFileSync12,
   readdirSync as readdirSync11,
   rmSync as rmSync13,
@@ -84236,7 +84344,7 @@ import {
   appendFileSync
 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join41, dirname as dirname16, resolve as resolve13 } from "path";
+import { join as join42, dirname as dirname17, resolve as resolve13 } from "path";
 import { totalmem as totalmem3 } from "os";
 import { randomUUID as randomUUID3 } from "crypto";
 import { fileURLToPath as fileURLToPath5 } from "url";
@@ -84390,12 +84498,17 @@ var MIME_TYPES2 = {
   ".gif": "image/gif",
   ".svg": "image/svg+xml",
   ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/vnd.microsoft.icon",
   ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
   ".webm": "video/webm",
   ".mp3": "audio/mpeg",
   ".wav": "audio/wav",
   ".ogg": "audio/ogg",
   ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".m4a": "audio/mp4",
   ".woff": "font/woff",
   ".woff2": "font/woff2",
   ".ttf": "font/ttf",
@@ -86673,7 +86786,9 @@ function isToleratedShortClipBoundaryMiss(report, threshold) {
 }
 function expectedFramesForVideo(video, entry, fps) {
   const rounding = entry && !entry.metadata.isVFR ? "nearest" : "ceil";
-  const slotFrames = expectedFramesForClip(video.start, video.end, fps, rounding);
+  const playbackRate = normalizePlaybackRate(video.playbackRate ?? 1);
+  const slotSourceDuration = Math.max(0, video.end - video.start) * playbackRate;
+  const slotFrames = expectedFramesForClip(0, slotSourceDuration, fps, rounding);
   if (!entry) return slotFrames;
   const sourceDuration = resolvePlayableVideoDuration(entry.metadata) - video.mediaStart;
   if (!Number.isFinite(sourceDuration) || sourceDuration <= 0) return slotFrames;
@@ -86733,7 +86848,7 @@ init_compiler();
 init_subCompositionValidity();
 init_assetResolution();
 import { createReadStream as createReadStream4, existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join27, dirname as dirname13, resolve as resolve12, basename as basename6 } from "path";
+import { join as join27, dirname as dirname13, resolve as resolve12, basename as basename6, relative as relative2 } from "path";
 
 // ../producer/src/services/renderMediaCollector.ts
 init_esm10();
@@ -86819,7 +86934,7 @@ init_src();
 
 // ../producer/src/services/deterministicFonts.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir5, tmpdir as tmpdir5 } from "os";
 import { join as join25 } from "path";
 
@@ -86828,7 +86943,7 @@ init_dist();
 
 // ../core/dist/fonts/systemFontLocator.js
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync20, lstatSync as lstatSync3, readdirSync as readdirSync9, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync20, lstatSync as lstatSync4, readdirSync as readdirSync9, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir3, platform as platform2 } from "os";
 import { join as join23, resolve as resolve10 } from "path";
 var SYSTEM_FONT_SIZE_LIMIT = 5 * 1024 * 1024;
@@ -86882,9 +86997,9 @@ function isPathBounded(filePath) {
 }
 function isRegularFile(filePath) {
   try {
-    const lst = lstatSync3(filePath);
+    const lst = lstatSync4(filePath);
     if (lst.isSymbolicLink())
-      return isPathBounded(filePath) && lstatSync3(realpathSync3(filePath)).isFile();
+      return isPathBounded(filePath) && lstatSync4(realpathSync3(filePath)).isFile();
     return lst.isFile();
   } catch {
     return false;
@@ -87431,6 +87546,11 @@ function extractRequestedFontFamilies(html) {
 function fontFormatHint(src) {
   return src.startsWith("data:font/collection;") ? "collection" : "woff2";
 }
+var BUNDLED_SUBSET_UNICODE_RANGE = "U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD";
+function isBundledSubsetRange(unicodeRange) {
+  const normalize = (range) => range.toLowerCase().replace(/\s+/g, "");
+  return unicodeRange !== void 0 && normalize(unicodeRange) === normalize(BUNDLED_SUBSET_UNICODE_RANGE);
+}
 function buildFontFaceRule(familyName, src, weight, style, unicodeRange) {
   return [
     "@font-face {",
@@ -87502,16 +87622,25 @@ async function buildFontFaceCss(requestedFamilies, options, fontText) {
       const canonical = CANONICAL_FONTS[canonicalKey];
       if (!canonical) continue;
       const coveredWeights = /* @__PURE__ */ new Set();
+      const bundledRules = [];
       for (const face of canonical.faces) {
         const style = face.style || "normal";
         const src = fontDataUri(canonical.packageName, face.weight, style);
-        rules.push(buildFontFaceRule(originalCaseFamily, src, face.weight, style));
+        bundledRules.push(
+          buildFontFaceRule(
+            originalCaseFamily,
+            src,
+            face.weight,
+            style,
+            BUNDLED_SUBSET_UNICODE_RANGE
+          )
+        );
         coveredWeights.add(coverageKey(face.weight, style));
       }
       const canonicalFamily = resolveAliasDisplayName(normalizedFamily);
       const googleFaces2 = canonicalFamily ? await fetchGoogleFont(canonicalFamily, options, fontText) : [];
       const supplementary = googleFaces2.filter(
-        (face) => !coveredWeights.has(coverageKey(face.weight, face.style))
+        (face) => !coveredWeights.has(coverageKey(face.weight, face.style)) || !isBundledSubsetRange(face.unicodeRange)
       );
       const runs = groupFacesBySource(supplementary).flatMap(
         (group) => partitionWeightRuns(group, coveredWeights)
@@ -87532,6 +87661,7 @@ async function buildFontFaceCss(requestedFamilies, options, fontText) {
           )
         );
       }
+      rules.push(...bundledRules);
       continue;
     }
     const googleFaces = await fetchGoogleFont(originalCaseFamily, options, fontText);
@@ -87600,7 +87730,7 @@ function resolveFontCacheRoot() {
     return process.env.HYPERFRAMES_FONT_CACHE_DIR;
   }
   if (process.env.AWS_LAMBDA_FUNCTION_NAME) {
-    lambdaFontCacheRoot ??= mkdtempSync5(join25(tmpdir5(), "hyperframes-fonts-"));
+    lambdaFontCacheRoot ??= mkdtempSync6(join25(tmpdir5(), "hyperframes-fonts-"));
     return lambdaFontCacheRoot;
   }
   return join25(homedir5(), ".cache", "hyperframes", "fonts");
@@ -87609,10 +87739,24 @@ var WOFF2_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWeb
 function fontSlug(familyName) {
   return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
+var ephemeralFontCacheRoot;
 function fontCacheDir(slug) {
   const dir = join25(resolveFontCacheRoot(), slug);
   if (!existsSync22(dir)) {
-    mkdirSync11(dir, { recursive: true });
+    try {
+      mkdirSync11(dir, { recursive: true });
+    } catch {
+      const firstFallback = ephemeralFontCacheRoot === void 0;
+      ephemeralFontCacheRoot ??= mkdtempSync6(join25(tmpdir5(), "hyperframes-fonts-"));
+      const fallback = join25(ephemeralFontCacheRoot, slug);
+      mkdirSync11(fallback, { recursive: true });
+      if (firstFallback) {
+        defaultLogger.warn(
+          `Font cache directory is unwritable (${dir}). Using temporary fallback \u2014 fonts will re-download each run. Fix with: chmod 755 ${resolveFontCacheRoot()}`
+        );
+      }
+      return fallback;
+    }
   }
   return dir;
 }
@@ -87829,17 +87973,108 @@ async function fetchGoogleFont(familyName, options, fontText) {
   return faces;
 }
 var GOOGLE_FONTS_TEXT_MAX_ENCODED_LENGTH = 1700;
+var SMALL_TO_FULL_KANA = /* @__PURE__ */ new Map([
+  ["\u3041", "\u3042"],
+  ["\u3043", "\u3044"],
+  ["\u3045", "\u3046"],
+  ["\u3047", "\u3048"],
+  ["\u3049", "\u304A"],
+  ["\u3063", "\u3064"],
+  ["\u3083", "\u3084"],
+  ["\u3085", "\u3086"],
+  ["\u3087", "\u3088"],
+  ["\u308E", "\u308F"],
+  ["\u30A1", "\u30A2"],
+  ["\u30A3", "\u30A4"],
+  ["\u30A5", "\u30A6"],
+  ["\u30A7", "\u30A8"],
+  ["\u30A9", "\u30AA"],
+  ["\u30C3", "\u30C4"],
+  ["\u30E3", "\u30E4"],
+  ["\u30E5", "\u30E6"],
+  ["\u30E7", "\u30E8"],
+  ["\u30EE", "\u30EF"],
+  ["\u30F5", "\u30AB"],
+  ["\u30F6", "\u30B1"]
+]);
+function collectLangAttributes(document2) {
+  const locales = /* @__PURE__ */ new Set();
+  for (const element of document2.querySelectorAll("[lang]")) {
+    const lang = element.getAttribute("lang");
+    if (!lang) continue;
+    const primary = lang.split("-")[0].toLowerCase();
+    try {
+      Intl.getCanonicalLocales(primary);
+      locales.add(primary);
+    } catch {
+    }
+  }
+  return locales;
+}
+function addCaseClosure(out, character, locales) {
+  out.add(character);
+  for (const variant of `${character.toUpperCase()}${character.toLowerCase()}`) {
+    out.add(variant);
+  }
+  for (const locale of locales) {
+    for (const variant of `${character.toLocaleUpperCase(locale)}${character.toLocaleLowerCase(locale)}`) {
+      out.add(variant);
+    }
+  }
+}
+function addFullwidthVariants(chars) {
+  for (const character of [...chars]) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code >= 33 && code <= 126) {
+      chars.add(String.fromCodePoint(code + 65248));
+    }
+  }
+}
+function addFullSizeKanaVariants(chars) {
+  for (const character of [...chars]) {
+    const full = SMALL_TO_FULL_KANA.get(character);
+    if (full) chars.add(full);
+  }
+}
+var FULL_WIDTH_KEYWORD_RE = /\bfull-width\b/;
+var FULL_SIZE_KANA_KEYWORD_RE = /\bfull-size-kana\b/;
+var DECLARATION_BOUNDARY_RE = /[;{}]/;
+function skipWhitespace(s, pos) {
+  while (pos < s.length && " 	\n\r\f\v".includes(s[pos])) pos += 1;
+  return pos;
+}
+function findDeclarationEnd(s, pos) {
+  const match = DECLARATION_BOUNDARY_RE.exec(s.slice(pos));
+  return match ? pos + match.index : s.length;
+}
+function hasTextTransformKeyword(html, keyword) {
+  const haystack = html.toLowerCase();
+  const property = "text-transform";
+  let from = 0;
+  for (; ; ) {
+    const at2 = haystack.indexOf(property, from);
+    if (at2 === -1) return false;
+    const afterProp = skipWhitespace(haystack, at2 + property.length);
+    if (haystack[afterProp] !== ":") {
+      from = at2 + property.length;
+      continue;
+    }
+    const end = findDeclarationEnd(haystack, afterProp + 1);
+    if (keyword.test(haystack.slice(afterProp + 1, end))) return true;
+    from = end;
+  }
+}
 function extractGoogleFontsText(html) {
   const { document: document2 } = parseHTML(html);
   const decodedBodyText = document2.body?.textContent ?? "";
-  const characters = [...Array.from(html), ...Array.from(decodedBodyText)];
+  const locales = collectLangAttributes(document2);
   const uniqueCharacters = /* @__PURE__ */ new Set();
-  for (const character of characters) {
-    uniqueCharacters.add(character);
-    for (const variant of `${character.toUpperCase()}${character.toLowerCase()}`) {
-      uniqueCharacters.add(variant);
-    }
+  for (const character of /* @__PURE__ */ new Set([...Array.from(html), ...Array.from(decodedBodyText)])) {
+    addCaseClosure(uniqueCharacters, character, locales);
   }
+  if (hasTextTransformKeyword(html, FULL_WIDTH_KEYWORD_RE)) addFullwidthVariants(uniqueCharacters);
+  if (hasTextTransformKeyword(html, FULL_SIZE_KANA_KEYWORD_RE))
+    addFullSizeKanaVariants(uniqueCharacters);
   const fontText = [...uniqueCharacters].join("");
   return encodeURIComponent(fontText).length <= GOOGLE_FONTS_TEXT_MAX_ENCODED_LENGTH ? fontText : void 0;
 }
@@ -88688,6 +88923,7 @@ async function preflightCompositionAssetMediaTypes(input) {
 function logRemoteDownloadTelemetry(event) {
   defaultLogger.info("[Compiler] Remote asset download integrity", { ...event });
 }
+var INFERRED_MEDIA_DURATION_ATTR = "data-hf-inferred-duration";
 function parseSubCompHtmlForValidity(html) {
   return parseHTML(html).document;
 }
@@ -88922,6 +89158,18 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     return { duration, resolvedPath: filePath };
   });
 }
+function markInferredVariableMediaDurations(html, unresolvedMedia) {
+  const unresolvedIds = new Set(unresolvedMedia.map((element) => element.id));
+  if (unresolvedIds.size === 0) return html;
+  const { document: document2 } = parseHTML(html);
+  let changed = false;
+  for (const element of document2.querySelectorAll("video[data-var-src], audio[data-var-src]")) {
+    if (!unresolvedIds.has(element.id)) continue;
+    element.setAttribute(INFERRED_MEDIA_DURATION_ATTR, "");
+    changed = true;
+  }
+  return changed ? document2.toString() : html;
+}
 async function compileHtmlFile(html, baseDir, downloadDir, log) {
   const { html: staticCompiled, unresolved } = compileTimingAttrs(html);
   const mediaUnresolved = unresolved.filter(
@@ -88945,7 +89193,8 @@ async function compileHtmlFile(html, baseDir, downloadDir, log) {
   const resolutions = resolvedResults.filter(
     (r) => r.duration != null && Number.isFinite(r.duration)
   );
-  let compiledHtml = resolutions.length > 0 ? injectDurations(staticCompiled, resolutions) : staticCompiled;
+  const markedStaticHtml = markInferredVariableMediaDurations(staticCompiled, mediaUnresolved);
+  let compiledHtml = resolutions.length > 0 ? injectDurations(markedStaticHtml, resolutions) : markedStaticHtml;
   const preResolved = extractResolvedMedia(compiledHtml);
   const clampResults = await Promise.all(
     preResolved.filter((el) => !!el.src && !el.loop).map(async (el) => {
@@ -89715,8 +89964,38 @@ function rewriteUnresolvableGsapToCdn(html, projectDir) {
     }
   );
 }
+function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
+  if (!isPathInside3(htmlPath, projectDir)) return html;
+  const entryPath = relative2(projectDir, htmlPath).replace(/\\/g, "/");
+  if (!entryPath.includes("/")) return html;
+  const { document: document2 } = parseHTML(html);
+  const assetExists = (path) => existsSync25(resolve12(projectDir, path));
+  rewriteAssetPaths(
+    document2.querySelectorAll("[src], [href]"),
+    entryPath,
+    (el, attr) => el.getAttribute(attr),
+    (el, attr, value) => el.setAttribute(attr, value),
+    assetExists
+  );
+  rewriteInlineStyleAssetUrls(
+    document2.querySelectorAll("[style]"),
+    entryPath,
+    (el) => el.getAttribute("style"),
+    (el, value) => el.setAttribute("style", value),
+    assetExists
+  );
+  for (const style of document2.querySelectorAll("style")) {
+    style.textContent = rewriteCssAssetUrls(style.textContent || "", entryPath, assetExists);
+  }
+  return document2.toString();
+}
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
-  const rawHtml = rewriteUnresolvableGsapToCdn(readFileSync10(htmlPath, "utf-8"), projectDir);
+  const entryHtml = rebaseDirectEntryAssetPaths(
+    readFileSync10(htmlPath, "utf-8"),
+    projectDir,
+    htmlPath
+  );
+  const rawHtml = rewriteUnresolvableGsapToCdn(entryHtml, projectDir);
   assertSubCompositionsUsable(rawHtml, projectDir);
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
@@ -89873,6 +90152,8 @@ async function discoverMediaFromBrowser(page) {
       const start = parseFloat(htmlEl.getAttribute("data-start") || "0");
       const endRaw = htmlEl.getAttribute("data-end");
       const durationRaw = htmlEl.getAttribute("data-duration");
+      const durationInferred = htmlEl.hasAttribute("data-hf-inferred-duration");
+      const intrinsicDuration = isImage ? 0 : htmlEl.duration;
       const playbackStartRaw = htmlEl.getAttribute("data-playback-start");
       const mediaStartRaw = htmlEl.getAttribute("data-media-start");
       const loop = htmlEl.hasAttribute("loop");
@@ -89886,6 +90167,8 @@ async function discoverMediaFromBrowser(page) {
         start,
         endRaw,
         durationRaw,
+        intrinsicDuration,
+        durationInferred,
         playbackStartRaw,
         mediaStartRaw,
         loop,
@@ -89896,18 +90179,20 @@ async function discoverMediaFromBrowser(page) {
     });
     return results;
   });
-  return elements.map(({ endRaw, durationRaw, playbackStartRaw, mediaStartRaw, ...element }) => ({
-    ...element,
-    end: parseStrictFiniteTimingNumber(endRaw) ?? 0,
-    duration: parseStrictFiniteTimingNumber(durationRaw) ?? 0,
-    mediaStart: readMediaStart({
-      getAttribute(name) {
-        if (name === "data-playback-start") return playbackStartRaw;
-        if (name === "data-media-start") return mediaStartRaw;
-        return null;
-      }
+  return elements.map(
+    ({ endRaw, durationRaw, intrinsicDuration, playbackStartRaw, mediaStartRaw, ...element }) => ({
+      ...element,
+      end: parseStrictFiniteTimingNumber(endRaw) ?? 0,
+      duration: element.durationInferred && Number.isFinite(intrinsicDuration) && intrinsicDuration > 0 ? intrinsicDuration : parseStrictFiniteTimingNumber(durationRaw) ?? 0,
+      mediaStart: readMediaStart({
+        getAttribute(name) {
+          if (name === "data-playback-start") return playbackStartRaw;
+          if (name === "data-media-start") return mediaStartRaw;
+          return null;
+        }
+      })
     })
-  }));
+  );
 }
 async function discoverAudioVolumeAutomationFromTimeline(page, audioIds, compositionDuration, sampleFps) {
   if (audioIds.length === 0 || compositionDuration <= 0) return [];
@@ -90353,6 +90638,11 @@ function hasVariableBoundMedia(html, variables) {
     return Boolean(variableId && Object.hasOwn(variables, variableId));
   });
 }
+function reconcileBrowserMediaEnd(existingEnd, projectedEnd, sourceChanged, durationInferred) {
+  if (projectedEnd <= 0) return existingEnd;
+  if (sourceChanged && durationInferred) return projectedEnd;
+  return existingEnd <= 0 ? projectedEnd : Math.min(existingEnd, projectedEnd);
+}
 function hasRuntimeInsertedMedia(html) {
   const { document: document2 } = parseHTML(html);
   const scriptBodies = [...document2.querySelectorAll("script")].map((script) => script.textContent ?? "").join("\n");
@@ -90584,7 +90874,8 @@ async function runProbeStage(input) {
           if (existingVideoIds.has(el.id)) {
             const existing = composition.videos.find((v) => v.id === el.id);
             if (existing) {
-              if (existing.src !== src) {
+              const sourceChanged = existing.src !== src;
+              if (sourceChanged) {
                 existing.src = src;
               }
               const projectedEnd = projectBrowserEndToCompositionTimeline(
@@ -90592,9 +90883,12 @@ async function runProbeStage(input) {
                 el.start,
                 resolveBrowserMediaEnd(el.start, el.end, el.duration)
               );
-              if (projectedEnd > 0) {
-                existing.end = existing.end <= 0 ? projectedEnd : Math.min(existing.end, projectedEnd);
-              }
+              existing.end = reconcileBrowserMediaEnd(
+                existing.end,
+                projectedEnd,
+                sourceChanged,
+                el.durationInferred
+              );
               if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)) {
                 existing.mediaStart = el.mediaStart;
               }
@@ -90621,7 +90915,8 @@ async function runProbeStage(input) {
           if (existingAudioIds.has(el.id)) {
             const existing = composition.audios.find((a) => a.id === el.id);
             if (existing) {
-              if (existing.src !== src) {
+              const sourceChanged = existing.src !== src;
+              if (sourceChanged) {
                 existing.src = src;
               }
               const projectedEnd = projectBrowserEndToCompositionTimeline(
@@ -90629,9 +90924,12 @@ async function runProbeStage(input) {
                 el.start,
                 resolveBrowserMediaEnd(el.start, el.end, el.duration)
               );
-              if (projectedEnd > 0) {
-                existing.end = existing.end <= 0 ? projectedEnd : Math.min(existing.end, projectedEnd);
-              }
+              existing.end = reconcileBrowserMediaEnd(
+                existing.end,
+                projectedEnd,
+                sourceChanged,
+                el.durationInferred
+              );
               if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)) {
                 existing.mediaStart = el.mediaStart;
               }
@@ -91312,9 +91610,32 @@ async function runAudioStage(input) {
 
 // ../producer/src/services/render/stages/captureStage.ts
 init_src();
+import { statfsSync } from "fs";
 function shouldAllowAdaptiveCaptureRetry(workerCount, _explicitlyConfigured) {
   return workerCount > 1;
 }
+function estimateDiskCaptureBytes(totalFrames, captureOptions) {
+  const scale = captureOptions.deviceScaleFactor ?? 1;
+  const outputWidth = Math.ceil(captureOptions.width * scale);
+  const outputHeight = Math.ceil(captureOptions.height * scale);
+  return Math.ceil(totalFrames) * outputWidth * outputHeight * 4;
+}
+function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes = (path) => {
+  try {
+    const stat = statfsSync(path);
+    return stat.bavail * stat.bsize;
+  } catch {
+    return null;
+  }
+}) {
+  const freeBytes = freeDiskBytes(framesDir);
+  if (freeBytes === null) return;
+  const estimatedBytes = estimateDiskCaptureBytes(totalFrames, captureOptions);
+  if (estimatedBytes <= freeBytes * 0.9) return;
+  throw new Error(
+    `Disk capture may need ~${(estimatedBytes / 1e6).toFixed(1)} MB of temporary frame storage, but only ${(freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Re-run with --low-memory-mode to stream frames, raise PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS if streaming is supported, or free up disk space.`
+  );
+}
 async function runCaptureStage(input) {
   const {
     fileServer,
@@ -91353,6 +91674,8 @@ async function runCaptureStage(input) {
       );
     }
   }
+  const captureOptions = buildCaptureOptions();
+  assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions);
   if (workerCount > 1) {
     const attempts = await executeDiskCaptureWithAdaptiveRetry({
       serverUrl: fileServer.url,
@@ -91362,7 +91685,7 @@ async function runCaptureStage(input) {
       initialWorkerCount: workerCount,
       allowRetry: shouldAllowAdaptiveCaptureRetry(workerCount, job.config.workers !== void 0),
       frameExt: needsAlpha ? "png" : "jpg",
-      captureOptions: buildCaptureOptions(),
+      captureOptions,
       createBeforeCaptureHook: createRenderVideoFrameInjector,
       abortSignal,
       frameRangeStart: frameRange?.startFrame,
@@ -91400,7 +91723,7 @@ async function runCaptureStage(input) {
     const session = probeSession ?? await createCaptureSession(
       fileServer.url,
       framesDir,
-      buildCaptureOptions(),
+      captureOptions,
       videoInjector,
       captureCfg
     );
@@ -91940,11 +92263,11 @@ import {
   constants as constants2,
   fstatSync as fstatSync2,
   mkdirSync as mkdirSync14,
-  mkdtempSync as mkdtempSync6,
+  mkdtempSync as mkdtempSync7,
   openSync as openSync4,
   readFileSync as readFileSync11,
   rmSync as rmSync10,
-  statfsSync
+  statfsSync as statfsSync2
 } from "fs";
 import { join as join33 } from "path";
 var NO_FOLLOW_FLAG = constants2.O_NOFOLLOW ?? 0;
@@ -92123,7 +92446,7 @@ function assertHdrExtractionDiskHeadroom(framesDir, plannedVideos, fps, log) {
   }
   let freeBytes;
   try {
-    const stat = statfsSync(framesDir);
+    const stat = statfsSync2(framesDir);
     freeBytes = stat.bavail * stat.bsize;
   } catch {
     return { estimatedBytes, budgetBytes: configuredBudget };
@@ -92190,7 +92513,7 @@ async function extractHdrVideoFrames(args) {
       const window3 = extractionWindows.get(videoId);
       if (!video || !window3) continue;
       mkdirSync14(framesDir, { recursive: true });
-      const frameDir = mkdtempSync6(join33(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
+      const frameDir = mkdtempSync7(join33(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
       createdFrameDirs.add(frameDir);
       const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
       const rawPath = join33(frameDir, "frames.rgb48le");
@@ -94189,7 +94512,8 @@ async function runEncodeStage(input) {
     return { encodeMs: Date.now() - stage5Start };
   }
   updateJobStatus(job, "encoding", "Encoding video", 75, onProgress);
-  const scaledEncodeTimeout = Math.ceil((job.duration ?? 0) * 4e3);
+  const baseScaledEncodeTimeout = Math.ceil((job.duration ?? 0) * 4e3);
+  const scaledEncodeTimeout = baseScaledEncodeTimeout * (job.config.quality === "high" ? 6 : 1);
   const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
   const frameExt = needsAlpha ? "png" : "jpg";
   const framePattern = `frame_%06d.${frameExt}`;
@@ -94242,8 +94566,30 @@ import { extname as extname6 } from "path";
 init_src();
 init_dist2();
 import { spawn as spawn5 } from "child_process";
-import { rmSync as rmSync12 } from "fs";
+import { mkdtempSync as mkdtempSync8, renameSync as renameSync6, rmSync as rmSync12 } from "fs";
+import { dirname as dirname16, join as join41 } from "path";
 var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
+var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
+var MAX_TRUE_PEAK_CORRECTION_PASSES = 3;
+function buildAacTruePeakCorrectionArgs(inputPath, outputPath, targetDurationSeconds, attenuationDb) {
+  return [
+    "-i",
+    inputPath,
+    "-map",
+    "0:a:0",
+    "-vn",
+    "-af",
+    `volume=${attenuationDb.toFixed(3)}dB`,
+    "-t",
+    formatSeconds(targetDurationSeconds),
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    "-y",
+    outputPath
+  ];
+}
 function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds) {
   const delta = targetDurationSeconds - sourceDurationSeconds;
   const targetSec = formatSeconds(targetDurationSeconds);
@@ -94318,6 +94664,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
   const probeVideo = input.probeVideoFrameInfo ?? ((videoPath) => defaultProbeVideoFrameInfo(videoPath, input.signal));
   const probeAudio = input.probeAudioInfo ?? defaultProbeAudioInfo;
   const runner = input.runFfmpeg ?? ((args) => defaultRunFfmpeg(args, input.signal));
+  const probeTruePeak = input.probeAudioTruePeakDbfs ?? (input.runFfmpeg ? void 0 : defaultProbeAudioTruePeakDbfs);
   const [videoResult, audioResult] = await Promise.allSettled([
     probeVideo(input.videoPath),
     probeAudio(input.audioPath, input.signal)
@@ -94389,6 +94736,26 @@ async function padOrTrimAudioToVideoFrameCount(input) {
   } finally {
     for (const path of plan2.cleanupPaths) rmSync12(path, { force: true });
   }
+  if (probeTruePeak) {
+    const correction = await enforceAacTruePeak({
+      audioPath: input.outputPath,
+      targetDurationSeconds,
+      signal: input.signal,
+      probeTruePeak,
+      runner
+    });
+    if (!correction.success) {
+      return {
+        success: false,
+        outputPath: input.outputPath,
+        targetDurationSeconds,
+        sourceDurationSeconds: audioInfo.durationSeconds,
+        operation: plan2.operation,
+        error: correction.error,
+        failureReason: correction.failureReason
+      };
+    }
+  }
   return {
     success: true,
     outputPath: input.outputPath,
@@ -94397,6 +94764,60 @@ async function padOrTrimAudioToVideoFrameCount(input) {
     operation: plan2.operation
   };
 }
+async function enforceAacTruePeak(input) {
+  let scratchDir;
+  try {
+    scratchDir = mkdtempSync8(join41(dirname16(input.audioPath), ".true-peak-"));
+    const correctedPath = join41(scratchDir, "audio.m4a");
+    let attenuationDb = 0;
+    let measuredPath = input.audioPath;
+    for (let pass = 0; pass <= MAX_TRUE_PEAK_CORRECTION_PASSES; pass += 1) {
+      const truePeakDbfs = await input.probeTruePeak(measuredPath, input.signal);
+      if (Number.isNaN(truePeakDbfs) || truePeakDbfs === Number.POSITIVE_INFINITY) {
+        return { success: false, error: "audioPadTrim: FFmpeg reported an invalid true peak" };
+      }
+      if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
+        if (measuredPath === correctedPath) renameSync6(correctedPath, input.audioPath);
+        return { success: true };
+      }
+      if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
+      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - truePeakDbfs;
+      const result = await input.runner(
+        buildAacTruePeakCorrectionArgs(
+          input.audioPath,
+          correctedPath,
+          input.targetDurationSeconds,
+          attenuationDb
+        )
+      );
+      if (!result.success) {
+        return {
+          success: false,
+          error: sanitizeProbeFailure(
+            result.error ?? "audioPadTrim: failed to constrain AAC true peak",
+            [input.audioPath, correctedPath]
+          ),
+          failureReason: result.failureReason
+        };
+      }
+      measuredPath = correctedPath;
+    }
+    return {
+      success: false,
+      error: `audioPadTrim: AAC true peak remained above ${AAC_DELIVERY_TRUE_PEAK_DBFS} dBFS after ${MAX_TRUE_PEAK_CORRECTION_PASSES} correction passes`
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `audioPadTrim: failed to validate AAC true peak: ${sanitizeProbeFailure(
+        err,
+        scratchDir ? [input.audioPath, scratchDir] : [input.audioPath]
+      )}`
+    };
+  } finally {
+    if (scratchDir) rmSync12(scratchDir, { recursive: true, force: true });
+  }
+}
 function failResult(outputPath, target, source, error) {
   return {
     success: false,
@@ -94470,6 +94891,22 @@ async function defaultProbeAudioInfo(audioPath, signal) {
     audioCodec: metadata.audioCodec
   };
 }
+async function defaultProbeAudioTruePeakDbfs(audioPath, signal) {
+  const result = await runFfmpeg(
+    ["-i", audioPath, "-map", "0:a:0", "-vn", "-af", "ebur128=peak=true", "-f", "null", "-"],
+    { signal }
+  );
+  if (!result.success) {
+    throw new Error(`[audioPadTrim] ${formatFfmpegError(result.exitCode, result.stderr)}`);
+  }
+  const matches2 = [...result.stderr.matchAll(/^\s*Peak:\s*([+-]?(?:[\d.]+|inf)) dBFS$/gim)];
+  const token = matches2.at(-1)?.[1]?.toLowerCase();
+  const value = token === "-inf" ? Number.NEGATIVE_INFINITY : Number(token);
+  if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY) {
+    throw new Error("[audioPadTrim] FFmpeg did not report AAC true peak");
+  }
+  return value;
+}
 async function defaultRunFfmpeg(args, signal) {
   const result = await runFfmpeg(args, { signal });
   if (result.success) return { success: true };
@@ -94584,7 +95021,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries2) {
-      const full = join41(current2, name);
+      const full = join42(current2, name);
       try {
         const st = statSync10(full);
         if (st.isDirectory()) {
@@ -94628,7 +95065,8 @@ function summarizeExtractionObservability(extractionResult, videoCount, coverage
 var RenderQualityError = class extends Error {
   constructor(warnings) {
     super(
-      `Render blocked by ${warnings.length} correctness warning${warnings.length === 1 ? "" : "s"}: ` + warnings.map((warning) => warning.code).join(", ")
+      `Render blocked by ${warnings.length} correctness warning${warnings.length === 1 ? "" : "s"}:
+` + warnings.map((warning) => `- ${warning.code}: ${redactTelemetryString(warning.message)}`).join("\n")
     );
     this.warnings = warnings;
     this.name = "RenderQualityError";
@@ -94732,7 +95170,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join41(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join42(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     const missing = !existsSync30(framePath) || statSync10(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
@@ -94755,7 +95193,7 @@ function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, ran
       workerId,
       startFrame: rangeStart + range.startFrame,
       endFrame: rangeStart + range.endFrame,
-      outputDir: join41(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputDir: join42(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
       outputFrameOffset: rangeStart
     }));
     batches.push(batch);
@@ -94778,8 +95216,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform3 = process.platform, systemTempDir = tmpdir7()) {
-  if (platform3 === "win32") return join41(systemTempDir, "hf-render-");
-  return join41(dirname16(outputPath), `work-${jobId}-`);
+  if (platform3 === "win32") return join42(systemTempDir, "hf-render-");
+  return join42(dirname17(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function captureAttemptMadeProgress(attemptTargetFrameCount, remainingFrameCount) {
@@ -94808,7 +95246,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 = join41(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join42(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync30(framePath)) captured++;
   }
   return captured;
@@ -94833,7 +95271,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join41(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join42(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -95170,15 +95608,15 @@ function deVerifyFallbackTelemetry(err) {
   };
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal) {
-  const moduleDir = dirname16(fileURLToPath5(import.meta.url));
+  const moduleDir = dirname17(fileURLToPath5(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve13(process.env.PRODUCER_RENDERS_DIR, "..") : resolve13(moduleDir, "../..");
-  const debugDir = join41(producerRoot, ".debug");
-  const outputDir = dirname16(outputPath);
+  const debugDir = join42(producerRoot, ".debug");
+  const outputDir = dirname17(outputPath);
   if (!existsSync30(outputDir)) mkdirSync17(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join41(debugDir, job.id) : mkdtempSync7(resolveRenderWorkDirPrefix(outputPath, job.id));
+  const workDir = job.config.debug ? join42(debugDir, job.id) : mkdtempSync9(resolveRenderWorkDirPrefix(outputPath, job.id));
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join41(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join42(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -95226,7 +95664,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join41(workDir, "perf-summary.json");
+  const perfOutputPath = join42(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -95318,15 +95756,15 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join41(projectDir, entryFile);
+    let htmlPath = join42(projectDir, entryFile);
     if (!existsSync30(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync12(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join41(workDir, "standalone-entry.html");
-      const projectIndexPath = join41(projectDir, "index.html");
+      const wrapperPath = join42(workDir, "standalone-entry.html");
+      const projectIndexPath = join42(projectDir, "index.html");
       if (!existsSync30(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
@@ -95481,7 +95919,7 @@ async function executeRenderPipeline(input) {
       beginFrameStalled: probeResult.beginFrameStalled
     });
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress);
-    const compiledDir = join41(workDir, "compiled");
+    const compiledDir = join42(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -95601,7 +96039,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer2({
           projectDir,
-          compiledDir: join41(workDir, "compiled"),
+          compiledDir: join42(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -95619,7 +96057,7 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join41(workDir, "captured-frames");
+    const framesDir = join42(workDir, "captured-frames");
     if (!existsSync30(framesDir)) mkdirSync17(framesDir, { recursive: true });
     const resolvedBrowserGpuMode = await resolveBrowserGpuMode(cfg.browserGpuMode, {
       chromePath: resolveHeadlessShellPath(cfg),
@@ -95944,7 +96382,7 @@ async function executeRenderPipeline(input) {
       gif: ".gif"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join41(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join42(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -96537,7 +96975,7 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && existsSync30(stagedOutputPath)) {
-        const debugOutput = join41(workDir, `output${videoExt}`);
+        const debugOutput = join42(workDir, `output${videoExt}`);
         copyFileSync6(stagedOutputPath, debugOutput);
       }
     }
@@ -96875,12 +97313,12 @@ import {
   existsSync as existsSync33,
   mkdirSync as mkdirSync18,
   statSync as statSync12,
-  mkdtempSync as mkdtempSync8,
+  mkdtempSync as mkdtempSync10,
   writeFileSync as writeFileSync11,
   rmSync as rmSync14,
   createReadStream as createReadStream5
 } from "fs";
-import { resolve as resolve15, dirname as dirname18, join as join44 } from "path";
+import { resolve as resolve15, dirname as dirname19, join as join45 } from "path";
 import { tmpdir as tmpdir8 } from "os";
 import { parseArgs } from "util";
 import crypto from "crypto";
@@ -96891,7 +97329,7 @@ import { serve as serve3 } from "@hono/node-server";
 // ../producer/src/services/hyperframeLint.ts
 init_dist3();
 import { existsSync as existsSync31, readFileSync as readFileSync13, statSync as statSync11 } from "fs";
-import { resolve as resolve14, join as join42 } from "path";
+import { resolve as resolve14, join as join43 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -96939,7 +97377,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join42(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join43(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -96982,7 +97420,7 @@ async function runHyperframeLint(prepared) {
 // ../producer/src/services/healthWorker.ts
 import { Worker as Worker3 } from "worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname17, join as join43 } from "path";
+import { dirname as dirname18, join as join44 } from "path";
 import { existsSync as existsSync32 } from "fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -97057,8 +97495,8 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname17(fileURLToPath6(import.meta.url));
-  const candidates = [join43(here, "healthWorkerThread.js"), join43(here, "healthWorkerThread.ts")];
+  const here = dirname18(fileURLToPath6(import.meta.url));
+  const candidates = [join44(here, "healthWorkerThread.js"), join44(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync32(candidate)) return candidate;
   }
@@ -97195,7 +97633,7 @@ 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 = dirname18(absoluteOutputPath);
+  const outputDir = dirname19(absoluteOutputPath);
   if (!existsSync33(outputDir)) mkdirSync18(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
@@ -97263,8 +97701,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir8();
-  const tempProjectDir = mkdtempSync8(join44(tempRoot, "producer-project-"));
-  writeFileSync11(join44(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync10(join45(tempRoot, "producer-project-"));
+  writeFileSync11(join45(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -97714,12 +98152,12 @@ init_src();
 // ../producer/src/services/distributed/plan.ts
 init_dist2();
 init_src();
-import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync20, renameSync as renameSync6, rmSync as rmSync15, writeFileSync as writeFileSync13 } from "fs";
-import { join as join48, relative as relative4, sep as sep4 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync20, renameSync as renameSync7, rmSync as rmSync15, writeFileSync as writeFileSync13 } from "fs";
+import { join as join49, relative as relative5, sep as sep4 } from "path";
 
 // ../producer/src/services/render/stages/freezePlan.ts
 import { existsSync as existsSync34, mkdirSync as mkdirSync19, readFileSync as readFileSync14, readdirSync as readdirSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join45, relative as relative2, resolve as resolve16 } from "path";
+import { join as join46, relative as relative3, resolve as resolve16 } from "path";
 
 // ../producer/src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -97761,7 +98199,7 @@ var FIELD_DELIMITER = Buffer.from([0]);
 // ../producer/src/services/distributed/shared.ts
 init_src();
 import { execFile as execFileCallback } from "child_process";
-import { dirname as dirname19, join as join46 } from "path";
+import { dirname as dirname20, join as join47 } from "path";
 import { existsSync as existsSync35, readFileSync as readFileSync15 } from "fs";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { promisify as promisify3 } from "util";
@@ -97770,8 +98208,8 @@ var execFile3 = promisify3(execFileCallback);
 
 // ../producer/src/services/distributed/planSize.ts
 import { createHash as createHash10 } from "crypto";
-import { lstatSync as lstatSync4, readdirSync as readdirSync13 } from "fs";
-import { extname as extname7, join as join47, relative as relative3 } from "path";
+import { lstatSync as lstatSync5, readdirSync as readdirSync13 } from "fs";
+import { extname as extname7, join as join48, relative as relative4 } from "path";
 var PLAN_ROOT_CATEGORY = {
   compiled: "compiled",
   [PLAN_AUDIO_RELATIVE_PATH]: "audio",
@@ -97783,9 +98221,9 @@ var PLAN_ROOT_CATEGORY = {
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join48("meta", "composition.json"),
-  join48("meta", "encoder.json"),
-  join48("meta", "chunks.json")
+  join49("meta", "composition.json"),
+  join49("meta", "encoder.json"),
+  join49("meta", "chunks.json")
 ];
 
 // ../producer/src/services/distributed/planV2.ts
@@ -97794,21 +98232,21 @@ import {
   closeSync as closeSync6,
   copyFileSync as copyFileSync8,
   existsSync as existsSync38,
-  lstatSync as lstatSync5,
+  lstatSync as lstatSync6,
   mkdirSync as mkdirSync22,
-  mkdtempSync as mkdtempSync10,
+  mkdtempSync as mkdtempSync12,
   openSync as openSync5,
   readFileSync as readFileSync16,
   readSync as readSync3,
   readdirSync as readdirSync14,
-  renameSync as renameSync8,
+  renameSync as renameSync9,
   rmSync as rmSync17,
   statSync as statSync14,
   writeFileSync as writeFileSync15
 } from "fs";
 import { createHash as createHash11 } from "crypto";
 import { tmpdir as tmpdir9 } from "os";
-import { dirname as dirname21, isAbsolute as isAbsolute4, join as join51, relative as relative5, resolve as resolve17, sep as sep5 } from "path";
+import { dirname as dirname22, isAbsolute as isAbsolute4, join as join52, relative as relative6, resolve as resolve17, sep as sep5 } from "path";
 
 // ../producer/src/services/distributed/planV2Publisher.ts
 import {
@@ -97816,21 +98254,21 @@ import {
   existsSync as existsSync37,
   linkSync as linkSync3,
   mkdirSync as mkdirSync21,
-  mkdtempSync as mkdtempSync9,
-  renameSync as renameSync7,
+  mkdtempSync as mkdtempSync11,
+  renameSync as renameSync8,
   rmSync as rmSync16,
   statSync as statSync13,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname20, join as join50 } from "path";
+import { dirname as dirname21, join as join51 } from "path";
 
 // ../producer/src/services/distributed/planV2Layout.ts
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 
 // ../producer/src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync11, rmSync as rmSync20 } from "fs";
+import { mkdtempSync as mkdtempSync13, rmSync as rmSync20 } from "fs";
 import { tmpdir as tmpdir10 } from "os";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 
 // ../producer/src/services/distributed/assemble.ts
 init_src();
@@ -97845,19 +98283,19 @@ import {
   statSync as statSync15,
   writeFileSync as writeFileSync16
 } from "fs";
-import { dirname as dirname22, join as join52 } from "path";
+import { dirname as dirname23, join as join53 } from "path";
 
 // ../producer/src/services/distributed/renderChunk.ts
 init_src();
 import { randomBytes as randomBytes2 } from "crypto";
 import { existsSync as existsSync40, mkdirSync as mkdirSync24, readFileSync as readFileSync18, readdirSync as readdirSync16, rmSync as rmSync19, writeFileSync as writeFileSync17 } from "fs";
-import { extname as extname8, join as join53 } from "path";
+import { extname as extname8, join as join54 } from "path";
 init_src();
 
 // ../producer/src/services/distributed/projectHash.ts
 import { readdirSync as readdirSync17, readFileSync as readFileSync19 } from "fs";
 import { createHash as createHash12 } from "crypto";
-import { join as join55, relative as relative6 } from "path";
+import { join as join56, relative as relative7 } from "path";
 
 // src/fontLocalize.ts
 function safeVersion(version2) {
@@ -97898,8 +98336,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.26" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.26" : "0.0.0-dev";
+var VERSION = true ? "0.8.28" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.28" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {