hyperframes 0.8.80 → 0.8.82

package/dist/fontLocalizeCli.js

@@ -52868,17 +52868,22 @@ function escapeCaseInsensitiveToken(source, token, replacement) {
 function inlineScriptTags(scripts) {
   return scripts.map((source) => `<script>${escapeInlineScriptSource(source)}</script>`).join("\n");
 }
-function findDocumentTag(html, tag) {
-  const lowered = lowerAscii(html);
+function* markupStarts(lowered) {
   const unclosedRawText = /* @__PURE__ */ new Set();
   let cursor = 0;
   while (cursor !== -1) {
     const open = lowered.indexOf("<", cursor);
     if (open === -1)
-      return -1;
+      return;
+    yield open;
+    cursor = skipMarkup(lowered, open, unclosedRawText);
+  }
+}
+function findDocumentTag(html, tag) {
+  const lowered = lowerAscii(html);
+  for (const open of markupStarts(lowered)) {
     if (isTagAt(lowered, open, tag))
       return open;
-    cursor = skipMarkup(lowered, open, unclosedRawText);
   }
   return -1;
 }
@@ -53069,7 +53074,7 @@ function parseApplicationExtension(bytes, offset3) {
   }
   return null;
 }
-function parseAnimatedGifMetadata(bytes) {
+function parseAnimatedGifMetadata(bytes, onFrame) {
   if (bytes.length < 13)
     return null;
   const signature = readAscii(bytes, 0, 6);
@@ -53085,6 +53090,7 @@ function parseAnimatedGifMetadata(bytes) {
     pos += colorTableByteLength(packed);
   }
   let frameCount = 0;
+  let controlPackedOffset = null;
   const delaysCentiseconds = [];
   let loopCount = null;
   while (pos < bytes.length) {
@@ -53107,6 +53113,7 @@ function parseAnimatedGifMetadata(bytes) {
         if (delay == null)
           return null;
         delaysCentiseconds.push(normalizeDelayCentiseconds(delay));
+        controlPackedOffset = pos + 1;
         pos += 1 + blockSize;
         if (bytes[pos] !== 0)
           return null;
@@ -53122,6 +53129,8 @@ function parseAnimatedGifMetadata(bytes) {
         pos = parsed.nextOffset;
         continue;
       }
+      if (label === PLAIN_TEXT_LABEL)
+        controlPackedOffset = null;
       const next = skipSubBlocks(bytes, pos);
       if (next == null)
         return null;
@@ -53132,8 +53141,11 @@ function parseAnimatedGifMetadata(bytes) {
       if (pos + 9 > bytes.length)
         return null;
       const imagePacked = bytes[pos + 8] ?? 0;
+      const localColorTable = (imagePacked & 128) !== 0;
+      onFrame?.({ controlPackedOffset, localColorTable });
+      controlPackedOffset = null;
       pos += 9;
-      if ((imagePacked & 128) !== 0) {
+      if (localColorTable) {
         pos += colorTableByteLength(imagePacked);
       }
       if (pos >= bytes.length)
@@ -53159,11 +53171,59 @@ function parseAnimatedGifMetadata(bytes) {
     animated: frameCount > 1
   };
 }
-var BROWSER_MIN_DELAY_CENTISECONDS;
+function frameLayouts(bytes) {
+  const frames = [];
+  return parseAnimatedGifMetadata(bytes, (frame) => frames.push(frame)) === null ? null : frames;
+}
+function disposalOf(bytes, frame) {
+  return frame.controlPackedOffset === null ? null : (bytes[frame.controlPackedOffset] ?? 0) & DISPOSAL_BITS;
+}
+function gifClearsAfterLeavingFrameInPlace(bytes) {
+  const frames = frameLayouts(bytes);
+  if (frames === null)
+    return null;
+  let sawOpaque = false;
+  for (const frame of frames) {
+    const disposal = disposalOf(bytes, frame);
+    if (disposal === LEAVE_IN_PLACE)
+      sawOpaque = true;
+    else if (disposal === DISPOSE_TO_BACKGROUND && sawOpaque)
+      return true;
+  }
+  return false;
+}
+function clearGifFramesBeforeNext(bytes) {
+  const frames = frameLayouts(bytes);
+  if (frames === null)
+    return false;
+  const controls = frames.flatMap((f) => f.controlPackedOffset === null ? [] : [f.controlPackedOffset]);
+  const shared = frames.flatMap((f) => f.controlPackedOffset === null || f.localColorTable ? [] : [f.controlPackedOffset]);
+  const hasIndex = (at2) => ((bytes[at2] ?? 0) & HAS_TRANSPARENT_INDEX) !== 0;
+  const source = shared.find(hasIndex);
+  for (const at2 of controls) {
+    bytes[at2] = (bytes[at2] ?? 0) & ~DISPOSAL_BITS | DISPOSE_TO_BACKGROUND;
+  }
+  if (source === void 0)
+    return true;
+  for (const at2 of shared) {
+    if (hasIndex(at2))
+      continue;
+    bytes[at2] = (bytes[at2] ?? 0) | HAS_TRANSPARENT_INDEX;
+    bytes[at2 + TRANSPARENT_INDEX_AFTER_PACKED] = bytes[source + TRANSPARENT_INDEX_AFTER_PACKED] ?? 0;
+  }
+  return true;
+}
+var BROWSER_MIN_DELAY_CENTISECONDS, PLAIN_TEXT_LABEL, DISPOSAL_BITS, LEAVE_IN_PLACE, DISPOSE_TO_BACKGROUND, HAS_TRANSPARENT_INDEX, TRANSPARENT_INDEX_AFTER_PACKED;
 var init_gif = __esm({
   "../core/dist/media/gif.js"() {
     "use strict";
     BROWSER_MIN_DELAY_CENTISECONDS = 10;
+    PLAIN_TEXT_LABEL = 1;
+    DISPOSAL_BITS = 28;
+    LEAVE_IN_PLACE = 1 << 2;
+    DISPOSE_TO_BACKGROUND = 2 << 2;
+    HAS_TRANSPARENT_INDEX = 1;
+    TRANSPARENT_INDEX_AFTER_PACKED = 3;
   }
 });
 
@@ -54212,6 +54272,13 @@ var init_safePath = __esm({
   }
 });
 
+// ../core/dist/projectRule.js
+var init_projectRule = __esm({
+  "../core/dist/projectRule.js"() {
+    "use strict";
+  }
+});
+
 // ../core/dist/adapters/gsap.js
 var init_gsap = __esm({
   "../core/dist/adapters/gsap.js"() {
@@ -55334,6 +55401,7 @@ var init_dist2 = __esm({
     init_parityContract();
     init_telemetryRedaction();
     init_safePath();
+    init_projectRule();
     init_gsap();
     init_text2();
     init_renderOutputTimestamp();
@@ -63231,6 +63299,16 @@ var init_evenDimensions = __esm({
   }
 });
 
+// ../engine/src/utils/sdrCaptureColor.ts
+var SDR_RGB_TO_BT709_FILTER, SDR_CAPTURE_TO_BT709_FILTER;
+var init_sdrCaptureColor = __esm({
+  "../engine/src/utils/sdrCaptureColor.ts"() {
+    "use strict";
+    SDR_RGB_TO_BT709_FILTER = "scale=out_color_matrix=bt709:out_range=tv:flags=neighbor";
+    SDR_CAPTURE_TO_BT709_FILTER = `scale=in_color_matrix=bt601:in_range=pc:flags=neighbor,format=gbrp,${SDR_RGB_TO_BT709_FILTER}`;
+  }
+});
+
 // ../engine/src/utils/runFfmpeg.ts
 import { spawn as spawn2 } from "child_process";
 function isExternalFfmpegInterruption(result) {
@@ -63267,21 +63345,20 @@ ${tail}` : windowsMessage;
 ffmpeg stderr (tail):
 ${tail}` : `FFmpeg exited with code ${exitCode}`;
 }
-async function runFfmpeg(args, opts) {
-  const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
+function spawnFfmpeg(args) {
   const ffmpeg = spawn2(getFfmpegBinary(), args, { windowsHide: true });
   trackChildProcess(ffmpeg);
-  const managed = new ManagedChildProcess(ffmpeg, {
-    signal: opts?.signal,
-    deadlineAtMs: Date.now() + timeout,
-    onStderr: opts?.onStderr
-  });
-  const outcome = await managed.wait();
+  return ffmpeg;
+}
+function succeeded(outcome) {
+  return outcome.reason === "exit" && outcome.exitCode === 0;
+}
+function toResult(outcome, stderr = outcome.stderr) {
   const result = {
-    success: outcome.reason === "exit" && outcome.exitCode === 0,
+    success: succeeded(outcome),
     exitCode: outcome.exitCode,
     signal: outcome.signal,
-    stderr: outcome.stderr,
+    stderr,
     durationMs: outcome.durationMs,
     terminationReason: outcome.reason,
     error: outcome.error
@@ -63291,6 +63368,43 @@ async function runFfmpeg(args, opts) {
   }
   return result;
 }
+async function runFfmpeg(args, opts) {
+  const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
+  const managed = new ManagedChildProcess(spawnFfmpeg(args), {
+    signal: opts?.signal,
+    deadlineAtMs: Date.now() + timeout,
+    onStderr: opts?.onStderr
+  });
+  return toResult(await managed.wait());
+}
+async function runFfmpegPipeline(producerArgs, consumerArgs, opts) {
+  const deadlineAtMs = Date.now() + (opts?.timeout ?? DEFAULT_TIMEOUT);
+  const producer = spawnFfmpeg(producerArgs);
+  const consumer = spawnFfmpeg(consumerArgs);
+  consumer.stdin?.on("error", () => {
+  });
+  for (const event of ["close", "error"]) {
+    consumer.once(event, () => producer.stdout?.destroy());
+    producer.once(event, () => consumer.stdin?.end());
+  }
+  if (consumer.stdin) producer.stdout?.pipe(consumer.stdin);
+  const settleOrder = [];
+  const outcomes = await Promise.all(
+    [producer, consumer].map(
+      (child) => new ManagedChildProcess(child, {
+        signal: opts?.signal,
+        deadlineAtMs,
+        onStderr: opts?.onStderr
+      }).wait().then((outcome) => {
+        settleOrder.push(outcome);
+        return outcome;
+      })
+    )
+  );
+  const reported = settleOrder.find((outcome) => !succeeded(outcome)) ?? outcomes[1];
+  const stderr = [...outcomes.filter((outcome) => outcome !== reported), reported].map((outcome) => outcome.stderr).join("");
+  return toResult(reported, stderr);
+}
 var FFMPEG_SIGTERM_EXIT_LINE, DEFAULT_TIMEOUT, DEFAULT_STDERR_TAIL_LINES;
 var init_runFfmpeg = __esm({
   "../engine/src/utils/runFfmpeg.ts"() {
@@ -63696,6 +63810,8 @@ async function extractMediaMetadata(filePath) {
       isVFR,
       hasAlpha,
       colorSpace,
+      colorRange: videoStream.color_range,
+      pixelFormat,
       frames
     };
   })();
@@ -64239,23 +64355,20 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
         "tv"
       );
     }
+    const sdrFilter = options.hdr ? void 0 : SDR_CAPTURE_TO_BT709_FILTER;
+    const captureFilter = sdrFilter ?? "scale=in_range=pc:out_range=tv";
     if (gpuEncoder === "vaapi") {
       const vfIdx = args.indexOf("-vf");
       if (vfIdx !== -1) {
-        args[vfIdx + 1] = `scale=in_range=pc:out_range=tv,${args[vfIdx + 1]}`;
+        args[vfIdx + 1] = `${captureFilter},${args[vfIdx + 1]}`;
       }
     } else if (shouldUseGpu) {
-      const vf = withEvenDimensionPad("", pixelFormat, options.width, options.height);
+      const vf = withEvenDimensionPad(sdrFilter ?? "", pixelFormat, options.width, options.height);
       if (vf) args.push("-vf", vf);
     } else {
       args.push(
         "-vf",
-        withEvenDimensionPad(
-          "scale=in_range=pc:out_range=tv",
-          pixelFormat,
-          options.width,
-          options.height
-        )
+        withEvenDimensionPad(captureFilter, pixelFormat, options.width, options.height)
       );
     }
     args.push("-video_track_timescale", "90000");
@@ -64625,6 +64738,7 @@ var init_chunkEncoder = __esm({
     init_gpuEncoder();
     init_hdr();
     init_evenDimensions();
+    init_sdrCaptureColor();
     init_runFfmpeg();
     init_ffprobe();
     init_dist2();
@@ -64917,25 +65031,15 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
         "tv"
       );
     }
-    if (options.rawInputFormat) {
+    const sdrFilter = options.rawInputFormat ? SDR_RGB_TO_BT709_FILTER : SDR_CAPTURE_TO_BT709_FILTER;
+    if (options.rawInputFormat && options.hdr) {
     } else if (gpuEncoder === "vaapi") {
       const vfIdx = args.indexOf("-vf");
       if (vfIdx !== -1) {
-        args[vfIdx + 1] = `scale=in_range=pc:out_range=tv,${args[vfIdx + 1]}`;
+        args[vfIdx + 1] = `${sdrFilter},${args[vfIdx + 1]}`;
       }
-    } else if (shouldUseGpu) {
-      const vf = withEvenDimensionPad("", pixelFormat, options.width, options.height);
-      if (vf) args.push("-vf", vf);
     } else {
-      args.push(
-        "-vf",
-        withEvenDimensionPad(
-          "scale=in_range=pc:out_range=tv",
-          pixelFormat,
-          options.width,
-          options.height
-        )
-      );
+      args.push("-vf", withEvenDimensionPad(sdrFilter, pixelFormat, options.width, options.height));
     }
     args.push("-video_track_timescale", "90000");
   }
@@ -65100,6 +65204,7 @@ var init_streamingEncoder = __esm({
     init_ffmpegBinaries();
     init_hdr();
     init_evenDimensions();
+    init_sdrCaptureColor();
     init_config();
     init_dist2();
     init_vp9Options();
@@ -70877,10 +70982,11 @@ function resolveCompositionDuration(input) {
     reason: pendingClips > 0 ? "every clip's length is still pending" : "no authored duration and no clip with a length"
   };
 }
-var isPositiveFinite;
+var TIMING_TOLERANCE_SECONDS, isPositiveFinite;
 var init_compositionDuration = __esm({
   "../parsers/dist/compositionDuration.js"() {
     "use strict";
+    TIMING_TOLERANCE_SECONDS = 0.05;
     isPositiveFinite = (value) => value !== null && Number.isFinite(value) && value > 0;
   }
 });
@@ -75560,6 +75666,26 @@ function captionFindings(rows, severity) {
   }
   return findings;
 }
+function clipsPastRootFindings(root, rows) {
+  if (root.attrs["data-composition-id"] === void 0) return [];
+  const rootDuration = readDataDurationSeconds((name) => root.attrs[name]);
+  if (rootDuration === null) return [];
+  const limit = hundredths(rootDuration);
+  return rows.flatMap((row) => {
+    const { start, end } = readClipTiming({ getAttribute: (name) => row.attrs[name] ?? null });
+    if (start === null || end === null || end <= rootDuration + TIMING_TOLERANCE_SECONDS) return [];
+    return [
+      {
+        code: "clip_ends_past_root_duration",
+        severity: "warning",
+        message: `${describe(row)} runs from ${hundredths(start)}s to ${hundredths(end)}s, past the root composition's data-duration of ${limit}s, so it is cut off in previews, posters and renders.`,
+        elementId: row.attrs.id,
+        fixHint: `Extend the root data-duration to ${hundredths(end)}, or make ${describe(row)} end at or before ${limit}s.`,
+        snippet: truncateSnippet(row.open.raw)
+      }
+    ];
+  });
+}
 function dedupeKeyFor(finding) {
   return [
     finding.code,
@@ -75628,7 +75754,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, REGEX_ALLOWED_BEFORE, REGEX_ALLOWED_KEYWORDS, WORD_CHAR, CodeContext, VISIBLE_MARKUP_COMMENT_PATTERN, VISIBLE_MARKUP_COMMENT_PROTECTED_BLOCK_PATTERN, coreRules, IMAGE_SRC_EXT, VIDEO_SRC_EXT, AUDIO_SRC_EXT, SRC_KIND_NOUN, mediaRules, AUDIO_GROUP_TIMING_ATTRS, callIndexes, INSPECTION_VIEWPORT_CAP, 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, ZOOM_DECLARATION, NEGATIVE_Z_INDEX, compositionRules, CLIP_MEDIA_TAGS, 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, adapterRules, TEXTURE_BASE_CLASS, TEXTURE_CLASS_PREFIX, textureRules, GENERIC_FAMILIES, fontRules, slideshowRules, INLINE_TEXT_TAGS, OPAQUE_TAGS, NON_LAYOUT_TAGS, MEDIA_TAGS2, NODE_ATTRS, describe, structureRules, 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, REGEX_ALLOWED_BEFORE, REGEX_ALLOWED_KEYWORDS, WORD_CHAR, CodeContext, VISIBLE_MARKUP_COMMENT_PATTERN, VISIBLE_MARKUP_COMMENT_PROTECTED_BLOCK_PATTERN, coreRules, IMAGE_SRC_EXT, VIDEO_SRC_EXT, AUDIO_SRC_EXT, SRC_KIND_NOUN, mediaRules, AUDIO_GROUP_TIMING_ATTRS, callIndexes, INSPECTION_VIEWPORT_CAP, 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, ZOOM_DECLARATION, NEGATIVE_Z_INDEX, compositionRules, CLIP_MEDIA_TAGS, 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, adapterRules, TEXTURE_BASE_CLASS, TEXTURE_CLASS_PREFIX, textureRules, GENERIC_FAMILIES, fontRules, slideshowRules, INLINE_TEXT_TAGS, OPAQUE_TAGS, NON_LAYOUT_TAGS, MEDIA_TAGS2, NODE_ATTRS, describe, hundredths, structureRules, RULE_GROUPS, LINT_RULE_COUNT, LINT_RULE_GROUP_COUNTS;
 var init_dist3 = __esm({
   "../lint/dist/index.js"() {
     "use strict";
@@ -75649,6 +75775,9 @@ var init_dist3 = __esm({
     init_composition();
     init_slideshow();
     init_topLevelElements();
+    init_compositionContract();
+    init_mediaDuration();
+    init_compositionDuration();
     init_esm10();
     init_esm10();
     COMPOSITION_ID_IN_CSS_PATTERN = /\[data-composition-id=["']([^"']+)["']\]/g;
@@ -78865,6 +78994,7 @@ ${other.raw}`)
       "data-composition-src"
     ];
     describe = (node) => `<${node.tag}${node.attrs.id ? ` id="${node.attrs.id}"` : ""}>`;
+    hundredths = (seconds) => Math.round(seconds * 100) / 100;
     structureRules = [
       (ctx) => {
         if (ctx.options.isSubComposition) return [];
@@ -78875,7 +79005,8 @@ ${other.raw}`)
         return [
           ...nestedStructureFindings(rows, severity),
           ...missingDurationFindings(rows, severity),
-          ...captionFindings(rows, severity)
+          ...captionFindings(rows, severity),
+          ...clipsPastRootFindings(root, rows)
         ];
       }
     ];
@@ -79783,7 +79914,7 @@ var init_extractionCache = __esm({
     init_extractedFrameIndex();
     COMPLETE_SENTINEL = ".hf-complete";
     GC_MARKER = ".hf-last-gc";
-    SCHEMA_PREFIX = "hfcache-v4-";
+    SCHEMA_PREFIX = "hfcache-v6-";
     KEY_HEX_CHARS = 16;
     CACHE_GENERATION_PREFIX = "hfcache-v";
   }
@@ -80131,6 +80262,21 @@ function parseImageElements(html) {
   }
   return images;
 }
+function chromeGuessForUntaggedMatrix(metadata) {
+  const matrix = metadata.colorSpace?.colorSpace;
+  if (matrix && matrix !== "unknown") return [];
+  const hd = metadata.height >= 720 && !CHROME_BT601_UNTAGGED_CODECS.has(metadata.videoCodec);
+  return [`setparams=colorspace=${hd ? "bt709" : "smpte170m"}`];
+}
+function restoreSourceColourFilter(metadata) {
+  const tags = [
+    ["range", metadata.colorRange],
+    ["colorspace", metadata.colorSpace?.colorSpace],
+    ["color_primaries", metadata.colorSpace?.colorPrimaries],
+    ["color_trc", metadata.colorSpace?.colorTransfer]
+  ].filter(([, value]) => value && value !== "unknown" && value !== "reserved");
+  return tags.length > 0 ? [`setparams=${tags.map(([key2, value]) => `${key2}=${value}`).join(":")}`] : [];
+}
 async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const { outputDir, quality = 95 } = options;
@@ -80167,6 +80313,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const outputPattern = join13(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
+  const sampleCfrAtOutputFps = !options.finalFrameOnly && !metadata.isVFR;
   const args = [];
   if (isHdr && isMacOS) {
     args.push("-hwaccel", "videotoolbox");
@@ -80177,14 +80324,19 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (options.finalFrameOnly) {
     args.push("-i", videoPath, "-ss", String(startTime), "-frames:v", "1");
   } else {
+    if (sampleCfrAtOutputFps) args.push("-noaccurate_seek");
     args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
   }
   const vfFilters = [];
   if (isHdr && isMacOS) {
     vfFilters.push("format=nv12");
   }
-  if (!options.finalFrameOnly && !metadata.isVFR) {
-    vfFilters.push(`fps=${ffmpegFps}`);
+  if (sampleCfrAtOutputFps) {
+    vfFilters.push(
+      "settb=intb/2",
+      "setpts=PTS-lte(TB\\,0.001)",
+      `fps=${ffmpegFps}:start_time=0:round=up`
+    );
   }
   if (options.sdrToHdrTransfer) {
     vfFilters.push(SDR_TO_HDR_COLORSPACE_FILTER);
@@ -80192,14 +80344,37 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (options.toneMapHdrToSdr && isHdr && !isMacOS) {
     vfFilters.push(HDR_TO_SDR_TONEMAP_FILTER);
   }
-  if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
-  if (!options.finalFrameOnly && metadata.isVFR) {
-    args.push("-fps_mode", "cfr", "-r", ffmpegFps);
+  if (!isHdr && !options.sdrToHdrTransfer) {
+    vfFilters.push(...chromeGuessForUntaggedMatrix(metadata), SDR_CANVAS_PASSTHROUGH_FILTER);
+    if (format === "jpg") vfFilters.push(SDR_JPEG_AS_BT601_FULL_RANGE_FILTER);
+  }
+  const encodeArgs = ["-q:v", format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0"];
+  if (format === "png") encodeArgs.push("-compression_level", "1");
+  encodeArgs.push("-y", outputPattern);
+  const runOptions = { signal, timeout: ffmpegProcessTimeout };
+  const resampleVfrToCfr = !options.finalFrameOnly && metadata.isVFR;
+  if (resampleVfrToCfr) args.push("-fps_mode", "cfr", "-r", ffmpegFps);
+  let processResult;
+  if (resampleVfrToCfr && vfFilters.length > 0 && !isHdr && NUT_RAW_PIXEL_FORMATS.has(metadata.pixelFormat ?? "")) {
+    processResult = await runFfmpegPipeline(
+      [...args, "-an", "-sn", "-dn", "-c:v", "rawvideo", "-f", "nut", "pipe:1"],
+      [
+        "-f",
+        "nut",
+        "-i",
+        "pipe:0",
+        "-vf",
+        [...restoreSourceColourFilter(metadata), ...vfFilters].join(","),
+        "-fps_mode",
+        "passthrough",
+        ...encodeArgs
+      ],
+      runOptions
+    );
+  } else {
+    if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
+    processResult = await runFfmpeg([...args, ...encodeArgs], runOptions);
   }
-  args.push("-q:v", format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0");
-  if (format === "png") args.push("-compression_level", "1");
-  args.push("-y", outputPattern);
-  const processResult = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
   if (processResult.failureReason === "external_interruption") {
     throw new VideoSourceExtractionError(
       "external_interruption",
@@ -81162,7 +81337,7 @@ function createFrameLookupTable(videos, extracted, fps) {
   }
   return table;
 }
-var VIDEO_FRAME_FORMATS, EXTRACT_CACHE_MIN_AGE_MS, GC_STALENESS_MS, SDR_TO_HDR_COLORSPACE_FILTER, HDR_TO_SDR_TONEMAP_FILTER, HDR_TO_SDR_TRANSFORM_KEY, VideoSourceExtractionError, TRANSIENT_FFMPEG_SPAWN_CODES, FINAL_FRAME_LOGICAL_DURATION_SECONDS, ALPHA_CAPABLE_CODECS, FrameLookupTable;
+var VIDEO_FRAME_FORMATS, EXTRACT_CACHE_MIN_AGE_MS, GC_STALENESS_MS, SDR_TO_HDR_COLORSPACE_FILTER, HDR_TO_SDR_TONEMAP_FILTER, HDR_TO_SDR_TRANSFORM_KEY, SDR_CANVAS_PASSTHROUGH_FILTER, SDR_JPEG_AS_BT601_FULL_RANGE_FILTER, VideoSourceExtractionError, CHROME_BT601_UNTAGGED_CODECS, NUT_RAW_PIXEL_FORMATS, TRANSIENT_FFMPEG_SPAWN_CODES, FINAL_FRAME_LOGICAL_DURATION_SECONDS, ALPHA_CAPABLE_CODECS, FrameLookupTable;
 var init_videoFrameExtractor = __esm({
   "../engine/src/services/videoFrameExtractor.ts"() {
     "use strict";
@@ -81185,6 +81360,8 @@ var init_videoFrameExtractor = __esm({
     SDR_TO_HDR_COLORSPACE_FILTER = "colorspace=all=bt2020:iall=bt709:range=tv";
     HDR_TO_SDR_TONEMAP_FILTER = "zscale=t=linear:npl=100,tonemap=hable:desat=0,zscale=p=bt709:t=bt709:m=bt709:r=tv";
     HDR_TO_SDR_TRANSFORM_KEY = "hdr2sdr-hable-bt709";
+    SDR_CANVAS_PASSTHROUGH_FILTER = "setparams=color_primaries=bt709:color_trc=iec61966-2-1";
+    SDR_JPEG_AS_BT601_FULL_RANGE_FILTER = "scale=flags=neighbor,format=gbrp,scale=out_color_matrix=bt601:out_range=pc:flags=neighbor,format=yuv420p";
     VideoSourceExtractionError = class extends Error {
       constructor(kind, retryable, message, diagnostic = message) {
         super(message);
@@ -81198,6 +81375,47 @@ var init_videoFrameExtractor = __esm({
       diagnostic;
       hyperframesVideoSourceExtractionError = true;
     };
+    CHROME_BT601_UNTAGGED_CODECS = /* @__PURE__ */ new Set(["vp9", "av1"]);
+    NUT_RAW_PIXEL_FORMATS = /* @__PURE__ */ new Set([
+      "yuv420p",
+      "yuvj420p",
+      "yuv422p",
+      "yuvj422p",
+      "yuv444p",
+      "yuvj444p",
+      "yuva420p",
+      "yuva444p",
+      "yuv440p",
+      "yuv411p",
+      "yuv410p",
+      "yuva422p",
+      "yuv420p10le",
+      "yuv422p10le",
+      "yuv444p10le",
+      "yuva420p10le",
+      "yuva444p10le",
+      "yuv420p12le",
+      "nv12",
+      "nv21",
+      "yuyv422",
+      "uyvy422",
+      "gray",
+      "gray10le",
+      "ya8",
+      "gbrp",
+      "gbrap",
+      "gbrp10le",
+      "gbrp12le",
+      "gbrap10le",
+      "rgb24",
+      "bgr24",
+      "rgba",
+      "bgra",
+      "argb",
+      "abgr",
+      "rgb48le",
+      "rgba64le"
+    ]);
     TRANSIENT_FFMPEG_SPAWN_CODES = /* @__PURE__ */ new Set(["EAGAIN", "EMFILE", "ENFILE"]);
     FINAL_FRAME_LOGICAL_DURATION_SECONDS = 1e-6;
     ALPHA_CAPABLE_CODECS = /* @__PURE__ */ new Set(["vp9", "vp8", "prores"]);
@@ -88889,11 +89107,11 @@ import {
   existsSync as existsSync33,
   mkdirSync as mkdirSync19,
   mkdtempSync as mkdtempSync11,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync12,
   rmSync as rmSync15,
   statSync as statSync12,
-  writeFileSync as writeFileSync11,
+  writeFileSync as writeFileSync12,
   copyFileSync as copyFileSync6,
   appendFileSync
 } from "fs";
@@ -94151,7 +94369,80 @@ function dedupeVariants(variants) {
 init_esm10();
 init_fontData_generated();
 init_fontCompression();
+import postcss5 from "postcss";
+
+// ../producer/src/services/authoredGoogleFonts.ts
+init_esm10();
 import postcss4 from "postcss";
+function screenStylesheet(media) {
+  return !media?.trim() || media.split(",").some((query2) => /^(all|screen)$/i.test(query2.trim()));
+}
+function googleStylesheetFamilies(urlText) {
+  let parsed;
+  try {
+    parsed = new URL(urlText);
+  } catch {
+    return [];
+  }
+  if (parsed.protocol !== "https:" || parsed.hostname !== "fonts.googleapis.com") return [];
+  return parsed.searchParams.getAll("family").flatMap((family) => family.split("|")).map((family) => family.split(":")[0]?.trim().toLowerCase() ?? "").filter(Boolean);
+}
+function importUrls(css) {
+  let root;
+  try {
+    root = postcss4.parse(css);
+  } catch {
+    return [];
+  }
+  const urls = [];
+  for (const node of root.nodes) {
+    if (node.type !== "atrule" || node.name.toLowerCase() !== "import") continue;
+    const url = unconditionalImportUrl(node.params);
+    if (url) urls.push(url);
+  }
+  return urls;
+}
+function unconditionalImportUrl(params) {
+  const match = /^(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])\s*(.*)$/i.exec(params);
+  if (!match || !screenStylesheet(match[3] ?? null)) return void 0;
+  return match[1] ?? match[2];
+}
+function activeStylesheet(element) {
+  if (element.hasAttribute("disabled") || !screenStylesheet(element.getAttribute("media")))
+    return false;
+  const type = element.getAttribute("type")?.trim().toLowerCase();
+  return !type || type === "text/css";
+}
+function stylesheetUrls(element) {
+  if (!activeStylesheet(element)) return [];
+  if (element.localName !== "link") return importUrls(element.textContent ?? "");
+  const rel = (element.getAttribute("rel") ?? "").toLowerCase().split(/\s+/);
+  if (!rel.includes("stylesheet") || rel.includes("alternate")) return [];
+  const href = element.getAttribute("href");
+  return href ? [href] : [];
+}
+function authoredGoogleFontStylesheets(html) {
+  const byFamily = /* @__PURE__ */ new Map();
+  const { document: document2 } = parseHTML(html);
+  for (const element of document2.querySelectorAll("link, style")) {
+    for (const url of stylesheetUrls(element)) {
+      for (const family of googleStylesheetFamilies(url)) {
+        const previous = byFamily.get(family) ?? [];
+        byFamily.set(family, [...previous.filter((existing) => existing !== url), url]);
+      }
+    }
+  }
+  return byFamily;
+}
+function withPageText(url, fontText) {
+  const parsed = new URL(url);
+  if (!fontText || parsed.searchParams.has("text")) return url;
+  const withoutFragment = url.split("#")[0] ?? url;
+  const joiner = parsed.search ? "&" : "?";
+  return `${withoutFragment}${joiner}text=${encodeURIComponent(fontText)}${parsed.hash}`;
+}
+
+// ../producer/src/services/deterministicFonts.ts
 var GENERIC_FAMILIES2 = /* @__PURE__ */ new Set([
   "sans-serif",
   "serif",
@@ -94168,6 +94459,13 @@ var GENERIC_FAMILIES2 = /* @__PURE__ */ new Set([
   "-apple-system",
   "blinkmacsystemfont"
 ]);
+var CSS_WIDE_KEYWORDS = /* @__PURE__ */ new Set([
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
 function parseFontFamilyValue(value) {
   const pieces = [];
   let start = 0;
@@ -94202,7 +94500,17 @@ function parseFontFamilyValue(value) {
   pieces.push(value.slice(start));
   return pieces.map((piece) => piece.trim().replace(/^['"]/, "").replace(/['"]$/, "").trim()).filter((piece) => piece.length > 0);
 }
-function systemPrimaryReplacement(value, deterministicPrimary) {
+function systemPrimaryReplacement(value, deterministicPrimary, customProperties) {
+  const variable = primaryCssVariable(value);
+  if (variable) {
+    if (customProperties.get(variable.name) || variable.fallback === null) return null;
+    const fallback = systemPrimaryReplacement(
+      variable.fallback,
+      deterministicPrimary,
+      customProperties
+    );
+    return fallback ? `var(${variable.name}, ${fallback})${variable.rest}` : null;
+  }
   const families = parseFontFamilyValue(value);
   if (families.length === 0) return null;
   if (!GENERIC_FAMILIES2.has(normalizeFamilyName(families[0]))) return null;
@@ -94210,7 +94518,7 @@ function systemPrimaryReplacement(value, deterministicPrimary) {
 }
 function parseCssRoot(css) {
   try {
-    return postcss4.parse(css);
+    return postcss5.parse(css);
   } catch {
     return null;
   }
@@ -94219,11 +94527,11 @@ function isFontFaceDeclaration(decl) {
   const parent = decl.parent;
   return parent?.type === "atrule" && parent.name.toLowerCase() === "font-face";
 }
-function normalizeCssDeclarations(root, deterministicPrimary) {
+function normalizeCssDeclarations(root, replacePrimary) {
   let changed = false;
   root.walkDecls((decl) => {
     if (decl.prop.startsWith("--")) {
-      const replacement2 = systemPrimaryReplacement(decl.value, deterministicPrimary);
+      const replacement2 = replacePrimary(decl.value);
       if (!replacement2) return;
       decl.value = replacement2;
       changed = true;
@@ -94233,50 +94541,52 @@ function normalizeCssDeclarations(root, deterministicPrimary) {
     if (isFontFaceDeclaration(decl)) {
       return;
     }
-    const replacement = systemPrimaryReplacement(decl.value, deterministicPrimary);
+    const replacement = replacePrimary(decl.value);
     if (!replacement) return;
     decl.value = replacement;
     changed = true;
   });
   return changed;
 }
-function normalizeCssFontFamilyDeclarations(css, deterministicPrimary) {
+function normalizeCssFontFamilyDeclarations(css, replacePrimary) {
   const root = parseCssRoot(css);
   if (!root) return css;
-  const changed = normalizeCssDeclarations(root, deterministicPrimary);
+  const changed = normalizeCssDeclarations(root, replacePrimary);
   return changed ? root.toString() : css;
 }
-function normalizeInlineStyleAttribute(style, deterministicPrimary) {
+function normalizeInlineStyleAttribute(style, replacePrimary) {
   const root = parseCssRoot(`*{${style}}`);
   if (!root) return style;
   const rule = root.first;
   if (rule?.type !== "rule") return style;
   const before2 = rule.toString();
-  normalizeCssDeclarations(root, deterministicPrimary);
+  normalizeCssDeclarations(root, replacePrimary);
   if (rule.toString() === before2) return style;
   const serialized = (rule.nodes ?? []).map((node) => node.toString()).join("; ");
   return serialized.endsWith(";") ? serialized : `${serialized};`;
 }
 function normalizeSystemFontPrimaryFamilies(html, deterministicPrimary = "Inter") {
   const { document: document2 } = parseHTML(html);
+  const customProperties = collectFontFamilyCustomProperties(html);
+  const replacePrimary = (value) => systemPrimaryReplacement(value, deterministicPrimary, customProperties);
   let changed = false;
   for (const styleEl of Array.from(document2.querySelectorAll("style"))) {
     const current2 = styleEl.textContent ?? "";
-    const next = normalizeCssFontFamilyDeclarations(current2, deterministicPrimary);
+    const next = normalizeCssFontFamilyDeclarations(current2, replacePrimary);
     if (next === current2) continue;
     styleEl.textContent = next;
     changed = true;
   }
   for (const el of Array.from(document2.querySelectorAll("[style]"))) {
     const current2 = el.getAttribute("style") ?? "";
-    const next = normalizeInlineStyleAttribute(current2, deterministicPrimary);
+    const next = normalizeInlineStyleAttribute(current2, replacePrimary);
     if (next === current2) continue;
     el.setAttribute("style", next);
     changed = true;
   }
   for (const el of Array.from(document2.querySelectorAll("[data-font-family]"))) {
     const current2 = el.getAttribute("data-font-family") ?? "";
-    const next = systemPrimaryReplacement(current2, deterministicPrimary);
+    const next = replacePrimary(current2);
     if (!next) continue;
     el.setAttribute("data-font-family", next);
     changed = true;
@@ -94326,7 +94636,7 @@ function collectFontFamilyCustomProperties(html) {
   }
   return customProperties;
 }
-function primaryCssVariableName(value) {
+function primaryCssVariable(value) {
   const trimmed = value.trim();
   if (!trimmed.toLowerCase().startsWith("var(")) return null;
   let depth = 0;
@@ -94339,21 +94649,35 @@ function primaryCssVariableName(value) {
     if (char !== ")") continue;
     depth -= 1;
     if (depth !== 0) continue;
-    const varExpression = trimmed.slice(0, index + 1);
-    const inner = varExpression.slice(4, -1).trim();
+    const inner = trimmed.slice(4, index).trim();
     const commaIndex = inner.indexOf(",");
-    const variableName = (commaIndex === -1 ? inner : inner.slice(0, commaIndex)).trim();
-    return /^--[A-Za-z0-9_-]+$/.test(variableName) ? variableName : null;
+    const name = (commaIndex === -1 ? inner : inner.slice(0, commaIndex)).trim();
+    if (!/^--[A-Za-z0-9_-]+$/.test(name)) return null;
+    return {
+      name,
+      fallback: commaIndex === -1 ? null : inner.slice(commaIndex + 1),
+      rest: trimmed.slice(index + 1)
+    };
   }
   return null;
 }
-function resolveFontFamilyDeclarationFamilies(declaration, customProperties) {
+var MAX_CSS_VARIABLE_DEPTH = 8;
+function resolveDeclaredFamilies(declaration, customProperties, optional = false, depth = 0) {
+  const tag = (families2) => families2.map((family) => ({ family, optional }));
   const families = parseFontFamilyValue(declaration);
-  const variableName = primaryCssVariableName(declaration);
-  if (!variableName) return families;
-  const resolved = customProperties.get(variableName);
-  if (!resolved) return families;
-  return [...parseFontFamilyValue(resolved), ...families.slice(1)];
+  const variable = depth < MAX_CSS_VARIABLE_DEPTH ? primaryCssVariable(declaration) : null;
+  if (!variable) return tag(families);
+  const resolved = customProperties.get(variable.name);
+  const source = resolved || variable.fallback;
+  if (source === null) return tag(families);
+  const primary = resolveDeclaredFamilies(
+    source,
+    customProperties,
+    !resolved || depth > 0,
+    depth + 1
+  );
+  if (primary.length === 0) return [];
+  return [...primary, ...tag(families.slice(1))];
 }
 function* iterateFontFamilyDeclarations(html) {
   const { document: document2 } = parseHTML(html);
@@ -94478,18 +94802,22 @@ function extractExistingFontFaces(html) {
   }
   return families;
 }
+function isFetchableFamilyName(normalized2) {
+  if (!normalized2 || normalized2.startsWith("var(")) return false;
+  return !GENERIC_FAMILIES2.has(normalized2) && !CSS_WIDE_KEYWORDS.has(normalized2);
+}
 function extractRequestedFontFamilies(html) {
   const requested = /* @__PURE__ */ new Map();
   const customProperties = collectFontFamilyCustomProperties(html);
   for (const { declaration } of iterateFontFamilyDeclarations(html)) {
-    for (const originalCase of resolveFontFamilyDeclarationFamilies(
-      declaration,
-      customProperties
-    )) {
-      const normalized2 = originalCase.toLowerCase();
-      if (!normalized2 || GENERIC_FAMILIES2.has(normalized2)) continue;
-      if (normalized2.startsWith("var(")) continue;
-      if (!requested.has(normalized2)) requested.set(normalized2, originalCase);
+    for (const { family, optional } of resolveDeclaredFamilies(declaration, customProperties)) {
+      const normalized2 = family.toLowerCase();
+      if (!isFetchableFamilyName(normalized2)) continue;
+      const seen = requested.get(normalized2);
+      requested.set(normalized2, {
+        family: seen?.family ?? family,
+        optional: (seen?.optional ?? true) && optional
+      });
     }
   }
   return requested;
@@ -94567,7 +94895,10 @@ function partitionWeightRuns(faces, coveredWeights) {
 async function buildFontFaceCss(requestedFamilies, options, fontText) {
   const rules = [];
   const unresolved = [];
-  for (const [normalizedFamily, originalCaseFamily] of requestedFamilies) {
+  const requiredFirst = [...requestedFamilies].sort(
+    ([, a], [, b]) => Number(a.optional) - Number(b.optional)
+  );
+  for (const [normalizedFamily, { family: originalCaseFamily, optional }] of requiredFirst) {
     const canonicalKey = FONT_ALIASES[normalizedFamily];
     if (canonicalKey) {
       const canonical = CANONICAL_FONTS[canonicalKey];
@@ -94589,7 +94920,7 @@ async function buildFontFaceCss(requestedFamilies, options, fontText) {
         coveredWeights.add(coverageKey(face.weight, style));
       }
       const canonicalFamily = resolveAliasDisplayName(normalizedFamily);
-      const googleFaces2 = canonicalFamily ? await fetchGoogleFont(canonicalFamily, options, fontText) : [];
+      const googleFaces2 = canonicalFamily ? await fetchFamilyFaces(canonicalFamily, optional, options, fontText) : [];
       const supplementary = googleFaces2.filter(
         (face) => !coveredWeights.has(coverageKey(face.weight, face.style)) || !isBundledSubsetRange(face.unicodeRange)
       );
@@ -94615,7 +94946,7 @@ async function buildFontFaceCss(requestedFamilies, options, fontText) {
       rules.push(...bundledRules);
       continue;
     }
-    const googleFaces = await fetchGoogleFont(originalCaseFamily, options, fontText);
+    const googleFaces = await fetchFamilyFaces(originalCaseFamily, optional, options, fontText);
     if (googleFaces.length > 0) {
       for (const face of googleFaces) {
         rules.push(
@@ -94630,7 +94961,7 @@ async function buildFontFaceCss(requestedFamilies, options, fontText) {
       }
       continue;
     }
-    if (options.allowSystemFontCapture) {
+    if (options.allowSystemFontCapture && !pageNamedThisFile(originalCaseFamily, options)) {
       const variants = locateSystemFontVariants(originalCaseFamily);
       if (variants.length > 0) {
         let totalBytes = 0;
@@ -94880,7 +95211,8 @@ function raceAgainstAbort(promise, signal) {
   });
 }
 function fetchGoogleFontCss(url, familyName, options) {
-  const key2 = `${options.failClosedFontFetch ? "closed" : "open"}:${url}`;
+  const mode = options.failClosedFontFetch ? `closed${options.retryPolicy.maxAttempts}` : "open";
+  const key2 = `${mode}:${url}`;
   let shared = googleFontCssCache.get(key2);
   if (!shared) {
     shared = fetchFontResource(
@@ -94900,35 +95232,66 @@ function fetchGoogleFontCss(url, familyName, options) {
   }
   return raceAgainstAbort(shared, options.abortSignal);
 }
+function pageNamedThisFile(familyName, options) {
+  return options.authoredStylesheets.has(normalizeFamilyName(familyName.replace(/\+/g, " ")));
+}
+function declaredFaceFamily(block) {
+  const found = /font-family:\s*['"]([^'"]+)['"]/i.exec(block);
+  return found?.[1];
+}
 async function fetchGoogleFont(familyName, options, fontText) {
-  const slug = fontSlug(familyName);
   const googleFamilyName = familyName.replace(/\+/g, " ");
   const encodedFamily = encodeURIComponent(googleFamilyName);
   const textParam = fontText ? `&text=${encodeURIComponent(fontText)}` : "";
-  const url = `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,700${textParam}`;
-  let cssText;
+  const normalizedFamily = normalizeFamilyName(googleFamilyName);
+  const authoredStylesheet = FONT_ALIASES[normalizedFamily] ? void 0 : options.authoredStylesheets.get(normalizedFamily);
+  const urls = authoredStylesheet ? authoredStylesheet.map((url) => withPageText(url, fontText)) : [
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,700${textParam}`
+  ];
+  const faces = [];
+  for (const url of urls) {
+    faces.push(...await fetchGoogleFontStylesheet(googleFamilyName, url, options));
+  }
+  return faces;
+}
+async function readGoogleFontStylesheet(familyName, url, options) {
   try {
     const cssResult = await fetchGoogleFontCss(url, familyName, options);
     if (!cssResult.ok) {
-      return [];
+      return null;
     }
-    cssText = cssResult.body;
+    return cssResult.body;
   } catch (err) {
     throwIfCallerAborted(options.abortSignal);
     if (err instanceof FontFetchError) throw err;
     if (options.failClosedFontFetch) {
       throw fontFetchError(familyName, url, "Google Fonts CSS", { error: err });
     }
-    return [];
+    return null;
   }
-  const faceRegex = /@font-face\s*\{[^}]*font-style:\s*(normal|italic)[^}]*font-weight:\s*(\d+)[^}]*src:\s*url\(([^)]+)\)\s*format\(['"]woff2['"]\)(?:[^}]*?unicode-range:\s*([^;}]+))?[^}]*\}/gi;
+}
+function parseGoogleFontSource(match, familyName) {
+  const declared = declaredFaceFamily(match[0]);
+  if (declared && normalizeFamilyName(declared) !== normalizeFamilyName(familyName)) return null;
+  const url = match[3];
+  if (!url) return null;
+  return {
+    style: match[1] || "normal",
+    weight: (match[2] || "400").replace(/\s+/g, " "),
+    url,
+    unicodeRange: match[4]?.trim() || void 0
+  };
+}
+async function fetchGoogleFontStylesheet(familyName, url, options) {
+  const slug = fontSlug(familyName);
+  const cssText = await readGoogleFontStylesheet(familyName, url, options);
+  if (!cssText) return [];
+  const faceRegex = /@font-face\s*\{[^}]*font-style:\s*(normal|italic|oblique(?:\s+-?\d+(?:\.\d+)?deg){0,2})\s*;[^}]*font-weight:\s*(\d+(?:\s+\d+)?)[^}]*src:\s*url\(([^)]+)\)\s*format\(['"]woff2['"]\)(?:[^}]*?unicode-range:\s*([^;}]+))?[^}]*\}/gi;
   const faces = [];
   for (const match of cssText.matchAll(faceRegex)) {
-    const style = match[1] || "normal";
-    const weight = match[2] || "400";
-    const woff2Url = match[3] || "";
-    const unicodeRange = match[4]?.trim() || void 0;
-    if (!woff2Url) continue;
+    const source = parseGoogleFontSource(match, familyName);
+    if (!source) continue;
+    const { weight, style, unicodeRange, url: woff2Url } = source;
     const cachePath = cachedWoff2Path(slug, weight, style, subsetToken(woff2Url));
     const dataUri = await ensureWoff2DataUri(
       cachePath,
@@ -94947,6 +95310,23 @@ async function fetchGoogleFont(familyName, options, fontText) {
   }
   return faces;
 }
+async function fetchFamilyFaces(familyName, optional, options, fontText) {
+  if (!optional) return fetchGoogleFont(familyName, options, fontText);
+  const maxAttempts = Math.min(options.retryPolicy.maxAttempts, 2);
+  try {
+    return await fetchGoogleFont(
+      familyName,
+      { ...options, retryPolicy: { ...options.retryPolicy, maxAttempts } },
+      fontText
+    );
+  } catch (err) {
+    if (!(err instanceof FontFetchUnavailableError)) throw err;
+    defaultLogger.warn(
+      `[Compiler] Optional font "${familyName}" is unavailable, rendering its fallback: ${err.message}`
+    );
+    return [];
+  }
+}
 var GOOGLE_FONTS_TEXT_MAX_ENCODED_LENGTH = 1700;
 var SMALL_TO_FULL_KANA = /* @__PURE__ */ new Map([
   ["\u3041", "\u3042"],
@@ -95090,14 +95470,15 @@ async function injectDeterministicFontFaces(html, options = {}) {
     allowSystemFontCapture,
     abortSignal: options.abortSignal,
     retryPolicy,
-    retryDeadlineMs: Date.now() + retryPolicy.maxElapsedMs
+    retryDeadlineMs: Date.now() + retryPolicy.maxElapsedMs,
+    authoredStylesheets: authoredGoogleFontStylesheets(html)
   };
   const existingFaces = extractExistingFontFaces(html);
   const requestedFamilies = extractRequestedFontFamilies(html);
   const pendingFamilies = /* @__PURE__ */ new Map();
-  for (const [normalizedFamily, originalCaseFamily] of requestedFamilies) {
+  for (const [normalizedFamily, requested] of requestedFamilies) {
     if (!existingFaces.has(normalizedFamily)) {
-      pendingFamilies.set(normalizedFamily, originalCaseFamily);
+      pendingFamilies.set(normalizedFamily, requested);
     }
   }
   if (pendingFamilies.size === 0) {
@@ -95108,11 +95489,14 @@ async function injectDeterministicFontFaces(html, options = {}) {
     fetchOptions,
     extractGoogleFontsText(html)
   );
-  if (unresolved.length > 0 && options.failClosedFontFetch) {
+  const required = unresolved.filter(
+    (family) => !pendingFamilies.get(family.toLowerCase())?.optional
+  );
+  if (required.length > 0 && options.failClosedFontFetch) {
     throw new FontFetchError(
-      unresolved.join(", "),
+      required.join(", "),
       "",
-      `[Compiler] Unresolved fonts in fail-closed mode: ${unresolved.join(", ")}. Distributed renders require all fonts to be resolvable.`
+      `[Compiler] Unresolved fonts in fail-closed mode: ${required.join(", ")}. Distributed renders require all fonts to be resolvable.`
     );
   }
   if (!css) {
@@ -99935,7 +100319,17 @@ async function runCaptureHdrStage(input) {
 
 // ../producer/src/services/render/stages/encodeStage.ts
 init_src();
-import { copyFileSync as copyFileSync5, existsSync as existsSync32, mkdirSync as mkdirSync18, readdirSync as readdirSync11, rmSync as rmSync13, statSync as statSync11 } from "fs";
+init_dist2();
+import {
+  copyFileSync as copyFileSync5,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync18,
+  readdirSync as readdirSync11,
+  readFileSync as readFileSync15,
+  rmSync as rmSync13,
+  statSync as statSync11,
+  writeFileSync as writeFileSync11
+} from "fs";
 import { dirname as dirname18, join as join46 } from "path";
 
 // ../producer/src/services/render/stages/gifEncodeArgs.ts
@@ -99943,15 +100337,23 @@ import { join as join45 } from "path";
 function fpsToFfmpegArg2(fps) {
   return fps.den === 1 ? String(fps.num) : `${fps.num}/${fps.den}`;
 }
+var KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA = ["-reinit_filter", "0"];
+var WRITE_EVERY_FRAME_WHOLE = ["-gifflags", "0"];
+function framesInput(input, fpsArg) {
+  return [
+    "-framerate",
+    fpsArg,
+    ...KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA,
+    "-i",
+    join45(input.framesDir, input.framePattern)
+  ];
+}
 function buildGifPalettegenArgs(input) {
   const fpsArg = fpsToFfmpegArg2(input.fps);
   const transparency = input.preserveAlpha ? ":reserve_transparent=1" : "";
   return [
     "-y",
-    "-framerate",
-    fpsArg,
-    "-i",
-    join45(input.framesDir, input.framePattern),
+    ...framesInput(input, fpsArg),
     "-vf",
     `fps=${fpsArg},palettegen=stats_mode=diff${transparency}`,
     input.palettePath
@@ -99962,16 +100364,14 @@ function buildGifPaletteuseArgs(input) {
   const transparency = input.preserveAlpha ? ":alpha_threshold=128" : "";
   return [
     "-y",
-    "-framerate",
-    fpsArg,
-    "-i",
-    join45(input.framesDir, input.framePattern),
+    ...framesInput(input, fpsArg),
     "-i",
     input.palettePath,
     "-lavfi",
     `fps=${fpsArg} [x]; [x][1:v] paletteuse=dither=sierra2_4a${transparency}`,
     "-loop",
     String(input.loop),
+    ...input.wholeFrames ? WRITE_EVERY_FRAME_WHOLE : [],
     input.outputPath
   ];
 }
@@ -99985,19 +100385,38 @@ function resolveGifLoop(loop) {
   }
   return resolved;
 }
+function gifEncodeFailure(startTime, outputPath, error, failureReason) {
+  return {
+    success: false,
+    outputPath,
+    durationMs: Date.now() - startTime,
+    framesEncoded: 0,
+    fileSize: 0,
+    error,
+    failureReason
+  };
+}
+async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
+  const { outputPath } = argsInput;
+  const result = await runFfmpeg(buildGifPaletteuseArgs({ ...argsInput, wholeFrames: true }), run);
+  if (!result.success) {
+    const error = formatFfmpegError(result.exitCode, result.stderr);
+    return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
+  }
+  const gif = readFileSync15(outputPath);
+  if (!clearGifFramesBeforeNext(gif)) {
+    const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
+    return gifEncodeFailure(startTime, outputPath, error);
+  }
+  writeFileSync11(outputPath, gif);
+  return null;
+}
 async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
   const startTime = Date.now();
   const files = readdirSync11(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
-    return {
-      success: false,
-      outputPath,
-      durationMs: Date.now() - startTime,
-      framesEncoded: 0,
-      fileSize: 0,
-      error: "[FFmpeg] No frame files found in directory"
-    };
+    return gifEncodeFailure(startTime, outputPath, "[FFmpeg] No frame files found in directory");
   }
   const argsInput = {
     framesDir,
@@ -100009,35 +100428,17 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
     preserveAlpha: input.preserveAlpha
   };
   try {
-    const paletteResult = await runFfmpeg(buildGifPalettegenArgs(argsInput), {
-      signal: input.signal,
-      timeout: input.timeout
-    });
-    if (!paletteResult.success) {
-      return {
-        success: false,
-        outputPath,
-        durationMs: Date.now() - startTime,
-        framesEncoded: 0,
-        fileSize: 0,
-        error: formatFfmpegError(paletteResult.exitCode, paletteResult.stderr),
-        failureReason: paletteResult.failureReason
-      };
+    const run = { signal: input.signal, timeout: input.timeout };
+    for (const args of [buildGifPalettegenArgs(argsInput), buildGifPaletteuseArgs(argsInput)]) {
+      const result = await runFfmpeg(args, run);
+      if (!result.success) {
+        const error = formatFfmpegError(result.exitCode, result.stderr);
+        return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
+      }
     }
-    const gifResult = await runFfmpeg(buildGifPaletteuseArgs(argsInput), {
-      signal: input.signal,
-      timeout: input.timeout
-    });
-    if (!gifResult.success) {
-      return {
-        success: false,
-        outputPath,
-        durationMs: Date.now() - startTime,
-        framesEncoded: 0,
-        fileSize: 0,
-        error: formatFfmpegError(gifResult.exitCode, gifResult.stderr),
-        failureReason: gifResult.failureReason
-      };
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync15(outputPath)) !== false) {
+      const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
+      if (failure) return failure;
     }
     const fileSize = existsSync32(outputPath) ? statSync11(outputPath).size : 0;
     return {
@@ -101723,7 +102124,7 @@ async function executeRenderPipeline(input) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync15(htmlPath, "utf-8");
+    const rawEntry = readFileSync16(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
       const wrapperPath = join48(workDir, "standalone-entry.html");
       const projectIndexPath = join48(projectDir, "index.html");
@@ -101733,7 +102134,7 @@ async function executeRenderPipeline(input) {
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync15(projectIndexPath, "utf-8"),
+        readFileSync16(projectIndexPath, "utf-8"),
         entryFile,
         rawEntry
       );
@@ -101742,7 +102143,7 @@ async function executeRenderPipeline(input) {
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync11(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync12(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -103216,7 +103617,7 @@ async function executeRenderPipeline(input) {
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync11(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync12(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -103569,7 +103970,7 @@ import {
   mkdirSync as mkdirSync20,
   statSync as statSync14,
   mkdtempSync as mkdtempSync12,
-  writeFileSync as writeFileSync12,
+  writeFileSync as writeFileSync13,
   rmSync as rmSync16,
   createReadStream as createReadStream5
 } from "fs";
@@ -103585,7 +103986,7 @@ import { serve as serve3 } from "@hono/node-server";
 init_dist3();
 import {
   existsSync as existsSync34,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   statSync as statSync13,
   openSync as openSync8,
   fstatSync as fstatSync5,
@@ -103630,7 +104031,7 @@ function readEntryHtml(filePath) {
   }
   try {
     if (!fstatSync5(fd).isFile()) return null;
-    return readFileSync16(fd, "utf-8");
+    return readFileSync17(fd, "utf-8");
   } finally {
     closeSync9(fd);
   }
@@ -103984,7 +104385,7 @@ async function resolveInlineRenderHtml(body) {
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir8();
   const tempProjectDir = mkdtempSync12(join51(tempRoot, "producer-project-"));
-  writeFileSync12(join51(tempProjectDir, "index.html"), html, "utf-8");
+  writeFileSync13(join51(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -104434,11 +104835,11 @@ init_src();
 // ../producer/src/services/distributed/plan.ts
 init_dist2();
 init_src();
-import { cpSync as cpSync2, existsSync as existsSync39, mkdirSync as mkdirSync22, renameSync as renameSync8, rmSync as rmSync17, writeFileSync as writeFileSync14 } from "fs";
+import { cpSync as cpSync2, existsSync as existsSync39, mkdirSync as mkdirSync22, renameSync as renameSync8, rmSync as rmSync17, writeFileSync as writeFileSync15 } from "fs";
 import { join as join55, relative as relative8, sep as sep5 } from "path";
 
 // ../producer/src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync21, readFileSync as readFileSync17, readdirSync as readdirSync13, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync21, readFileSync as readFileSync18, readdirSync as readdirSync13, writeFileSync as writeFileSync14 } from "fs";
 import { join as join52, relative as relative6, resolve as resolve16 } from "path";
 
 // ../producer/src/services/distributed/planProtocol.ts
@@ -104482,7 +104883,7 @@ var FIELD_DELIMITER = Buffer.from([0]);
 init_src();
 import { execFile as execFileCallback } from "child_process";
 import { dirname as dirname23, join as join53 } from "path";
-import { existsSync as existsSync38, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync19 } from "fs";
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { promisify as promisify5 } from "util";
 var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME;
@@ -104518,13 +104919,13 @@ import {
   mkdirSync as mkdirSync24,
   mkdtempSync as mkdtempSync14,
   openSync as openSync9,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   readSync as readSync3,
   readdirSync as readdirSync15,
   renameSync as renameSync10,
   rmSync as rmSync19,
   statSync as statSync16,
-  writeFileSync as writeFileSync16
+  writeFileSync as writeFileSync17
 } from "fs";
 import { createHash as createHash14 } from "crypto";
 import { tmpdir as tmpdir9 } from "os";
@@ -104540,7 +104941,7 @@ import {
   renameSync as renameSync9,
   rmSync as rmSync18,
   statSync as statSync15,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
 import { dirname as dirname24, join as join57 } from "path";
 
@@ -104560,23 +104961,23 @@ import {
   existsSync as existsSync42,
   mkdirSync as mkdirSync25,
   mkdtempSync as mkdtempSync15,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   readdirSync as readdirSync16,
   rmSync as rmSync20,
   statSync as statSync17,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "fs";
 import { dirname as dirname26, join as join59 } from "path";
 
 // ../producer/src/services/distributed/renderChunk.ts
 init_src();
 import { randomBytes } from "crypto";
-import { existsSync as existsSync43, mkdirSync as mkdirSync26, readFileSync as readFileSync21, readdirSync as readdirSync17, rmSync as rmSync21, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync26, readFileSync as readFileSync22, readdirSync as readdirSync17, rmSync as rmSync21, writeFileSync as writeFileSync19 } from "fs";
 import { extname as extname8, join as join60 } from "path";
 init_src();
 
 // ../producer/src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync18, readFileSync as readFileSync22 } from "fs";
+import { readdirSync as readdirSync18, readFileSync as readFileSync23 } from "fs";
 import { createHash as createHash15 } from "crypto";
 import { join as join62, relative as relative10 } from "path";
 
@@ -104619,8 +105020,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.80" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.80" : "0.0.0-dev";
+var VERSION = true ? "0.8.82" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.82" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {