hyperframes 0.7.92 → 0.7.94

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.7.92" : "0.0.0-dev";
+    VERSION = true ? "0.7.94" : "0.0.0-dev";
   }
 });
 
@@ -52025,8 +52025,62 @@ function containsTimelineCall(node, timelineVar) {
 function rangeOf(node) {
   return typeof node.start === "number" && typeof node.end === "number" ? [node.start, node.end] : void 0;
 }
+function isSafeDefaultExpression(node, earlierParams) {
+  let safe = true;
+  const visit = (current2, parent, key2) => {
+    if (!isNode2(current2) || !safe) return;
+    if (!SAFE_DEFAULT_NODES.has(current2.type)) {
+      safe = false;
+      return;
+    }
+    if (current2.type === "UnaryExpression" && current2.operator === "delete") {
+      safe = false;
+      return;
+    }
+    if (current2.type === "Identifier") {
+      const nonValue = parent && key2 ? isNonValueIdentifierSlot(parent, key2) : false;
+      if (!nonValue && current2.name !== "undefined" && !earlierParams.has(current2.name)) {
+        safe = false;
+      }
+      return;
+    }
+    for (const childKey of Object.keys(current2)) {
+      if (SKIP_KEYS.has(childKey)) continue;
+      const child = current2[childKey];
+      if (Array.isArray(child)) {
+        for (const item of child) visit(item, current2, childKey);
+      } else {
+        visit(child, current2, childKey);
+      }
+    }
+  };
+  visit(node);
+  return safe;
+}
+function supportedParam(param, earlier) {
+  if (param.type === "Identifier") return { name: param.name };
+  if (param.type !== "AssignmentPattern" || param.left?.type !== "Identifier") return null;
+  if (!isSafeDefaultExpression(param.right, earlier)) return null;
+  return { name: param.left.name, defaultExpression: param.right };
+}
+function supportedParams(fn) {
+  if (SUPPORTED_PARAMS_CACHE.has(fn)) return SUPPORTED_PARAMS_CACHE.get(fn) ?? null;
+  const params = [];
+  const earlier = /* @__PURE__ */ new Set();
+  for (const param of fn.params ?? []) {
+    const parsed = supportedParam(param, earlier);
+    if (!parsed) {
+      SUPPORTED_PARAMS_CACHE.set(fn, null);
+      return null;
+    }
+    params.push(parsed);
+    earlier.add(parsed.name);
+  }
+  SUPPORTED_PARAMS_CACHE.set(fn, params);
+  return params;
+}
 function isShapeEligible(fn) {
-  return isFunctionNode(fn) && fn.body?.type === "BlockStatement" && !(fn.params ?? []).some((p2) => p2.type !== "Identifier");
+  return isFunctionNode(fn) && fn.body?.type === "BlockStatement" && supportedParams(fn) !== null;
 }
 function callsAny(node, names) {
   let hit = false;
@@ -52076,20 +52130,55 @@ function timelineBuildingNames(candidates, timelineVar) {
 function bump(counts, key2) {
   counts.set(key2, (counts.get(key2) ?? 0) + 1);
 }
+function undefinedIdentifier() {
+  return { type: "Identifier", name: "undefined" };
+}
+function isExplicitUndefined(node) {
+  return node?.type === "Identifier" && node.name === "undefined" || node?.type === "UnaryExpression" && node.operator === "void" && node.argument?.type === "Literal" && node.argument.value === 0;
+}
+function resolveHelperBindings(call, params) {
+  if (call.arguments?.some((arg) => arg?.type === "SpreadElement")) return null;
+  const bindings = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < params.length; i2++) {
+    const param = params[i2];
+    const arg = call.arguments?.[i2];
+    if (arg && !isExplicitUndefined(arg)) {
+      bindings.set(param.name, arg);
+    } else if (param.defaultExpression) {
+      bindings.set(param.name, substituteParams(cloneNode2(param.defaultExpression), bindings));
+    } else {
+      bindings.set(param.name, undefinedIdentifier());
+    }
+  }
+  return bindings;
+}
+function statementHelperCall(node, names) {
+  if (node.type !== "ExpressionStatement") return void 0;
+  const expression = node.expression;
+  if (expression?.type !== "CallExpression" || expression.callee?.type !== "Identifier") {
+    return void 0;
+  }
+  return names.has(expression.callee.name) ? expression : void 0;
+}
 function safelyDroppable(program, candidates) {
   const names = new Set(candidates.keys());
   const totalIds = /* @__PURE__ */ new Map();
   const stmtCalls = /* @__PURE__ */ new Map();
+  const unbindable = /* @__PURE__ */ new Set();
   walkNodes(program, (n2) => {
     if (n2.type === "Identifier" && names.has(n2.name)) bump(totalIds, n2.name);
-    const e3 = n2.type === "ExpressionStatement" ? n2.expression : void 0;
-    if (e3?.type === "CallExpression" && e3.callee?.type === "Identifier" && names.has(e3.callee.name)) {
-      bump(stmtCalls, e3.callee.name);
-    }
+    const call = statementHelperCall(n2, names);
+    if (!call) return;
+    bump(stmtCalls, call.callee.name);
+    const fn = candidates.get(call.callee.name);
+    const params = fn && supportedParams(fn);
+    if (!params || !resolveHelperBindings(call, params)) unbindable.add(call.callee.name);
   });
   const safe = /* @__PURE__ */ new Map();
   for (const [name, fn] of candidates) {
-    if ((totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) safe.set(name, fn);
+    if (!unbindable.has(name) && (totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) {
+      safe.set(name, fn);
+    }
   }
   return safe;
 }
@@ -52132,11 +52221,11 @@ function expandBody(bodyStmts, bindings, prov, ctx) {
 }
 function inlineHelper(call, ctx) {
   const fn = ctx.helpers.get(call.callee.name);
-  const bindings = /* @__PURE__ */ new Map();
-  (fn.params ?? []).forEach((p2, i2) => {
-    const arg = call.arguments?.[i2];
-    if (arg) bindings.set(p2.name, arg);
-  });
+  if (!fn) return null;
+  const params = supportedParams(fn);
+  if (!params) return null;
+  const bindings = resolveHelperBindings(call, params);
+  if (!bindings) return null;
   const prov = {
     kind: "helper",
     fn: call.callee.name,
@@ -54683,7 +54772,7 @@ function decodeUrlPathVariants(path2) {
   }
   return variants;
 }
-var recast, import_parser2, CANVAS_DIMENSIONS, VALID_CANVAS_RESOLUTIONS, RESOLUTION_ALIASES, ASPECT_AGNOSTIC_RESOLUTION_ALIASES, COMPOSITION_VARIABLE_TYPES, TIMELINE_COLORS, DEFAULT_DURATIONS, PROPERTY_GROUPS, PROP_TO_GROUP, FORBIDDEN_GSAP_PATTERNS, roundPercentage, SKIP_KEYS, FUNCTION_TYPES, GSAP_METHODS, MAX_DEPTH, MAX_ITERS, GSAP_METHODS2, QUERY_METHODS, ITERATION_METHODS, SCOPE_NODE_TYPES, CONST_NODES, MATH_FNS, MATH_CONSTS, BUILTIN_VAR_KEYS, DROPPED_VAR_KEYS, EXTRAS_KEYS, PERCENTAGE_KEY_RE, GSAP_DEFAULT_DURATION, DEFAULT_TYPEOF, EXCLUDED_TAGS, COMPOSITION_ATTRIBUTES, CANONICAL_AUTHORED_TIMING_ATTRIBUTES, DERIVED_TIMING_ATTRIBUTES, LEGACY_TIMING_ATTRIBUTES, ClipTimingWriteError, REFERENCE_ID_PATTERN, DERIVED_END_EQUALITY_EPSILON_SECONDS, MEDIA_TYPES, CompositionHtmlParseError, UHD_SQUARE_MIN, UHD_RECT_MIN, OK, FONT_ALIAS_MAP, FONT_ALIAS_KEYS;
+var recast, import_parser2, CANVAS_DIMENSIONS, VALID_CANVAS_RESOLUTIONS, RESOLUTION_ALIASES, ASPECT_AGNOSTIC_RESOLUTION_ALIASES, COMPOSITION_VARIABLE_TYPES, TIMELINE_COLORS, DEFAULT_DURATIONS, PROPERTY_GROUPS, PROP_TO_GROUP, FORBIDDEN_GSAP_PATTERNS, roundPercentage, SKIP_KEYS, FUNCTION_TYPES, GSAP_METHODS, MAX_DEPTH, MAX_ITERS, SAFE_DEFAULT_NODES, SUPPORTED_PARAMS_CACHE, GSAP_METHODS2, QUERY_METHODS, ITERATION_METHODS, SCOPE_NODE_TYPES, CONST_NODES, MATH_FNS, MATH_CONSTS, BUILTIN_VAR_KEYS, DROPPED_VAR_KEYS, EXTRAS_KEYS, PERCENTAGE_KEY_RE, GSAP_DEFAULT_DURATION, DEFAULT_TYPEOF, EXCLUDED_TAGS, COMPOSITION_ATTRIBUTES, CANONICAL_AUTHORED_TIMING_ATTRIBUTES, DERIVED_TIMING_ATTRIBUTES, LEGACY_TIMING_ATTRIBUTES, ClipTimingWriteError, REFERENCE_ID_PATTERN, DERIVED_END_EQUALITY_EPSILON_SECONDS, MEDIA_TYPES, CompositionHtmlParseError, UHD_SQUARE_MIN, UHD_RECT_MIN, OK, FONT_ALIAS_MAP, FONT_ALIAS_KEYS;
 var init_dist2 = __esm({
   "../parsers/dist/index.js"() {
     "use strict";
@@ -54791,6 +54880,23 @@ var init_dist2 = __esm({
     GSAP_METHODS = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
     MAX_DEPTH = 8;
     MAX_ITERS = 512;
+    SAFE_DEFAULT_NODES = /* @__PURE__ */ new Set([
+      "ArrayExpression",
+      "BinaryExpression",
+      "ChainExpression",
+      "ConditionalExpression",
+      "Identifier",
+      "Literal",
+      "LogicalExpression",
+      "MemberExpression",
+      "ObjectExpression",
+      "Property",
+      "SpreadElement",
+      "TemplateElement",
+      "TemplateLiteral",
+      "UnaryExpression"
+    ]);
+    SUPPORTED_PARAMS_CACHE = /* @__PURE__ */ new WeakMap();
     GSAP_METHODS2 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
     QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
     ITERATION_METHODS = /* @__PURE__ */ new Set(["forEach", "map"]);
@@ -58530,17 +58636,46 @@ function truncateTelemetryString(value, maxLength) {
 function redactUrlQueryStrings(value) {
   return value.replace(/\b(https?:\/\/[^\s?]+)\?[^\s]*/g, "$1?\u2026");
 }
+function redactKnownPaths(value, paths) {
+  if (typeof value !== "string")
+    return "";
+  let out = value;
+  for (const path2 of paths) {
+    if (typeof path2 !== "string" || path2.length === 0)
+      continue;
+    const basename31 = path2.split(/[\\/]/).pop() ?? "";
+    for (const literal2 of [path2, basename31].filter((v2) => v2.length > 2)) {
+      out = out.split(literal2).join("[path]");
+    }
+  }
+  return out;
+}
 function redactFilePaths(value) {
-  return value.replace(/file:\/\/[^\s'")]+/g, "[file-url]").replace(/\/Users\/[^\s'")]+/g, "[path]").replace(/\/(?:home|root|opt|app|workspace|srv|mnt)\/[^\s'")]+/g, "[path]").replace(/\/(?:private\/)?(?:var|tmp)\/[^\s'")]+/g, "[path]").replace(/[A-Za-z]:\\[^\s'")]+/g, "[path]");
+  return value.replace(/file:\/\/[^\s'")]+/g, "[file-url]").replace(RELATIVE_PATH, "[path]").replace(BARE_RELATIVE_PATH, "[path]").replace(ABSOLUTE_PATH, "[path]").replace(ASSET_BASENAME, "[file]");
 }
 function redactTelemetryString(value, maxLength = MAX_TELEMETRY_STRING_LENGTH) {
   return truncateTelemetryString(redactFilePaths(redactUrlQueryStrings(value)), maxLength);
 }
-var MAX_TELEMETRY_STRING_LENGTH;
+var MAX_TELEMETRY_STRING_LENGTH, SEGMENT, SEGMENT_NODOT, TOKEN_TAIL, ABSOLUTE_PATH, RELATIVE_PATH, ASSET_BASENAME, BARE_RELATIVE_PATH;
 var init_telemetryRedaction = __esm({
   "../core/dist/telemetryRedaction.js"() {
     "use strict";
     MAX_TELEMETRY_STRING_LENGTH = 240;
+    SEGMENT = String.raw`[^\s/\\'"]+`;
+    SEGMENT_NODOT = String.raw`[^\s/\\'".]+`;
+    TOKEN_TAIL = String.raw`[^\s'")]*`;
+    ABSOLUTE_PATH = new RegExp(String.raw`(?<![:\w/\\])(?:[A-Za-z]:)?(?:[\\/]${SEGMENT}){2,}${TOKEN_TAIL}`, "g");
+    RELATIVE_PATH = new RegExp(String.raw`(?<![\w/\\.])\.{1,2}(?:[\\/]${SEGMENT})+${TOKEN_TAIL}`, "g");
+    ASSET_BASENAME = /(?<![\w/\\])[^\s/\\'"]+\.(?:mp4|mov|mkv|webm|avi|m4v|mpe?g|ts|mp3|wav|aac|m4a|flac|ogg|opus|png|jpe?g|gif|webp|svg|html?|json|srt|vtt|ass)\b/gi;
+    BARE_RELATIVE_PATH = new RegExp([
+      // Two or more separators: `customer/acme/video.mp4`. No extension needed —
+      // that much structure is already a path.
+      String.raw`(?<![^\s'\"(=,\[])(?:${SEGMENT}[\\/]){2,}${SEGMENT}${TOKEN_TAIL}`,
+      // One separator, but the last segment carries a file extension:
+      // `assets/bgm.mp3`. That segment is dot-free on purpose — SEGMENT includes
+      // `.`, so a greedy one swallows the extension this rule needs.
+      String.raw`(?<![^\s'\"(=,\[])${SEGMENT}[\\/]${SEGMENT_NODOT}\.\w{1,8}\b${TOKEN_TAIL}`
+    ].join("|"), "g");
   }
 });
 
@@ -62432,6 +62567,7 @@ __export(dist_exports, {
   quantizeTimeToFrame: () => quantizeTimeToFrame,
   queryByAttr: () => queryByAttr2,
   readClipTiming: () => readClipTiming2,
+  redactKnownPaths: () => redactKnownPaths,
   redactTelemetryString: () => redactTelemetryString,
   removeElementFromHtml: () => removeElementFromHtml,
   resolveHfColorGradingVariables: () => resolveHfColorGradingVariables,
@@ -64060,7 +64196,7 @@ async function probeAutoBrowserGpuMode(options) {
   const ppt = await getPuppeteerOrNull();
   if (ppt === null) {
     logResolvedBrowserGpuMode("software", "puppeteer unavailable");
-    return "software";
+    return { mode: "software", cause: "probe-error" };
   }
   try {
     const info = await probeHardwareWebGlInfo(ppt, {
@@ -64070,20 +64206,37 @@ async function probeAutoBrowserGpuMode(options) {
     });
     const resolved2 = resolveWebGlProbeMode(info);
     logResolvedBrowserGpuMode(resolved2, describeWebGlProbe(info));
-    return resolved2;
+    return resolved2 === "hardware" ? { mode: "hardware" } : { mode: "software", cause: "no-gpu" };
   } catch (err) {
     logResolvedBrowserGpuMode("software", formatProbeFailure(err));
-    return "software";
+    return { mode: "software", cause: "probe-error" };
   }
 }
 function resolveBrowserGpuMode(mode, options = {}) {
-  if (mode !== "auto") return Promise.resolve(mode);
-  if (_autoBrowserGpuModeCache) return _autoBrowserGpuModeCache;
-  _autoBrowserGpuModeCache = probeAutoBrowserGpuMode(options);
-  return _autoBrowserGpuModeCache;
+  if (mode === "software") return Promise.resolve(mode);
+  _autoBrowserGpuModeCache ??= probeAutoBrowserGpuMode(options);
+  if (mode === "auto") return _autoBrowserGpuModeCache.then((probed) => probed.mode);
+  return _autoBrowserGpuModeCache.then((probed) => {
+    if (probed.mode === "software" && !_unverifiedHardwareGpuWarned) {
+      _unverifiedHardwareGpuWarned = true;
+      console.warn(
+        buildUnverifiedHardwareGpuWarning(options.platform ?? process.platform, probed.cause)
+      );
+    }
+    return "hardware";
+  });
+}
+function buildUnverifiedHardwareGpuWarning(platform10, cause) {
+  if (cause === "probe-error") {
+    return "[hyperframes] browserGpuMode=hardware was requested, but the GPU probe could not run, so hardware acceleration is UNVERIFIED \u2014 if Chrome falls back to software WebGL the capture will run at CPU speed. Honouring the explicit request anyway.\n  This is a probe failure, not evidence of a missing GPU: see the `browserGpuMode probe \u2192 software (probe failed ...)` line above for the underlying error, which usually means Chrome could not launch (bad HYPERFRAMES_BROWSER_PATH, missing shared libraries, or a denied sandbox) rather than a GPU problem.\n  Run `hyperframes doctor` to check the Chrome install.";
+  }
+  const remediation = platform10 === "linux" ? "Inside Docker, the container needs GPU passthrough: `--gpus all` with the NVIDIA Container Toolkit installed, or `--device /dev/dri` for Mesa/AMD/Intel. The image also needs the matching userspace driver + libEGL. Verify with `hyperframes render --browser-gpu` and watch for this warning disappearing." : "Check that the host exposes a GPU to this process and that the graphics drivers are installed.";
+  return `[hyperframes] browserGpuMode=hardware was requested, but the WebGL probe found no hardware GPU \u2014 Chrome will silently fall back to software WebGL and the capture will run at CPU speed. Honouring the explicit request anyway.
+  ${remediation}
+  Pass --no-browser-gpu to select deterministic SwiftShader instead of waiting on a hardware path that is not there.`;
 }
 function logResolvedBrowserGpuMode(resolved2, reason) {
-  console.error(`[hyperframes] browserGpuMode auto \u2192 ${resolved2} (${reason})`);
+  console.error(`[hyperframes] browserGpuMode probe \u2192 ${resolved2} (${reason})`);
 }
 function createBrowserLaunchFingerprint(chromeArgs, config) {
   const launchConfig = {
@@ -64306,7 +64459,7 @@ function getBrowserGpuArgs(mode, platform10) {
       return ["--enable-gpu-rasterization"];
   }
 }
-var _puppeteer, CACHED_HEADLESS_SHELL_EXECUTABLES, ENABLE_BROWSER_POOL, BEGINFRAME_ONLY_FLAGS, BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS, BEGINFRAME_PROBE_TIMEOUT_MS, BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS, _autoBrowserGpuModeCache, browserLeasePool, _cachedVramMb, CANVAS_DRAW_ELEMENT_FEATURE_FLAG, WEBGPU_FLAG;
+var _puppeteer, CACHED_HEADLESS_SHELL_EXECUTABLES, ENABLE_BROWSER_POOL, BEGINFRAME_ONLY_FLAGS, BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS, BEGINFRAME_PROBE_TIMEOUT_MS, BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS, _autoBrowserGpuModeCache, _unverifiedHardwareGpuWarned, browserLeasePool, _cachedVramMb, CANVAS_DRAW_ELEMENT_FEATURE_FLAG, WEBGPU_FLAG;
 var init_browserManager = __esm({
   "../engine/src/services/browserManager.ts"() {
     "use strict";
@@ -64336,6 +64489,7 @@ var init_browserManager = __esm({
     BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS = 10;
     BEGINFRAME_PROBE_TIMEOUT_MS = 2e3;
     BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS = 250;
+    _unverifiedHardwareGpuWarned = false;
     browserLeasePool = new BrowserLeasePool({
       launch: launchBrowser,
       close: async (browser) => browser.close(),
@@ -66612,6 +66766,50 @@ function formatHttpErrorDiagnostic(input2) {
   const statusText = input2.statusText ? ` ${input2.statusText}` : "";
   return `[Browser:HTTP${input2.status}] ${input2.method} ${sanitizeDiagnosticUrl(input2.url)} resource=${input2.resourceType}${statusText}`;
 }
+function warmupFrameTimeTicks(state, intervalMs) {
+  return state.ticks * intervalMs;
+}
+function deriveBeginFrameTimeTicks(state, warmupIntervalMs, captureIntervalMs) {
+  const legacyCaptureTimeTicks = (state.ticks + BEGIN_FRAME_CAPTURE_HEADROOM_INTERVALS) * captureIntervalMs;
+  const legacyCommitTimeTicks = deriveBeginFrameCommitTimeTicks(
+    legacyCaptureTimeTicks,
+    captureIntervalMs
+  );
+  const lastWarmupTimeTicks = Math.max(0, state.ticks - 1) * warmupIntervalMs;
+  if (legacyCommitTimeTicks > lastWarmupTimeTicks) return legacyCaptureTimeTicks;
+  const monotonicCaptureTimeTicks = warmupFrameTimeTicks(state, warmupIntervalMs) + BEGIN_FRAME_CAPTURE_HEADROOM_INTERVALS * captureIntervalMs;
+  return monotonicCaptureTimeTicks;
+}
+function deriveBeginFrameCommitTimeTicks(captureTimeTicks, captureIntervalMs) {
+  return captureTimeTicks - BEGIN_FRAME_COMMIT_LEAD_INTERVALS * captureIntervalMs;
+}
+function deriveBeginFrameProbeTimeTicks(captureTimeTicks, captureIntervalMs) {
+  return Math.max(0, captureTimeTicks - BEGIN_FRAME_PROBE_LEAD_INTERVALS * captureIntervalMs);
+}
+function deriveBeginFrameTimelineTicks(state, warmupIntervalMs, captureIntervalMs) {
+  const capture2 = deriveBeginFrameTimeTicks(state, warmupIntervalMs, captureIntervalMs);
+  return {
+    capture: capture2,
+    commit: deriveBeginFrameCommitTimeTicks(capture2, captureIntervalMs),
+    probe: deriveBeginFrameProbeTimeTicks(capture2, captureIntervalMs)
+  };
+}
+function prepareBeginFrameTimeline(session, state, warmupIntervalMs) {
+  const timeline = deriveBeginFrameTimelineTicks(
+    state,
+    warmupIntervalMs,
+    session.beginFrameIntervalMs
+  );
+  session.beginFrameTimeTicks = timeline.capture;
+  return {
+    timeline,
+    commitParams: {
+      frameTimeTicks: timeline.commit,
+      interval: session.beginFrameIntervalMs,
+      noDisplayUpdates: false
+    }
+  };
+}
 async function driveWarmupTicks(options, state) {
   const sleep5 = options.sleep ?? realSleep;
   while (true) {
@@ -67557,17 +67755,16 @@ async function initializeSession(session) {
   warmupState.running = false;
   await warmupLoopPromise.catch(() => {
   });
-  const baseTickCount = lockWarmupTicks ? LOCKED_WARMUP_TICKS : warmupState.ticks;
-  session.beginFrameTimeTicks = (baseTickCount + 10) * session.beginFrameIntervalMs;
+  const preparedBeginFrameTimeline = prepareBeginFrameTimeline(
+    session,
+    warmupState,
+    warmupIntervalMs
+  );
   await initDrawElementOrTransparentBackground(session, page, logInitPhase);
   await armStaticDedup(session, session.page, logInitPhase);
   await ensureRenderFrameSiblings(page);
   const commitCdp = await getCdpSession(page);
-  await commitCdp.send("HeadlessExperimental.beginFrame", {
-    frameTimeTicks: session.beginFrameTimeTicks - 6 * session.beginFrameIntervalMs,
-    interval: session.beginFrameIntervalMs,
-    noDisplayUpdates: false
-  });
+  await commitCdp.send("HeadlessExperimental.beginFrame", preparedBeginFrameTimeline.commitParams);
   session.isInitialized = true;
 }
 async function captureFrameErrorDiagnostics(session, frameIndex, time, error) {
@@ -68406,7 +68603,7 @@ function getCapturePerfSummary(session) {
     deNcprFallbacks: session.deNcprFallbacks ?? 0
   };
 }
-var DrawElementVerificationError, BROWSER_CONSOLE_BUFFER_SIZE, CAPTURE_SESSION_CLOSE_TIMEOUT_MS, LOCKED_WARMUP_TICKS, realSleep, HF_READY_DIAGNOSTIC_EXPR, LIVE_MAP_MARKERS, MAX_STATIC_DEDUP_ANALYSIS_FRAMES, STATIC_VERIFY_REFERENCE_STRIDE, STATIC_VERIFY_MAX_MS;
+var DrawElementVerificationError, BROWSER_CONSOLE_BUFFER_SIZE, CAPTURE_SESSION_CLOSE_TIMEOUT_MS, LOCKED_WARMUP_TICKS, realSleep, BEGIN_FRAME_CAPTURE_HEADROOM_INTERVALS, BEGIN_FRAME_COMMIT_LEAD_INTERVALS, BEGIN_FRAME_PROBE_LEAD_INTERVALS, HF_READY_DIAGNOSTIC_EXPR, LIVE_MAP_MARKERS, MAX_STATIC_DEDUP_ANALYSIS_FRAMES, STATIC_VERIFY_REFERENCE_STRIDE, STATIC_VERIFY_MAX_MS;
 var init_frameCapture = __esm({
   "../engine/src/services/frameCapture.ts"() {
     "use strict";
@@ -68437,6 +68634,9 @@ var init_frameCapture = __esm({
     CAPTURE_SESSION_CLOSE_TIMEOUT_MS = 5e3;
     LOCKED_WARMUP_TICKS = 60;
     realSleep = (ms) => new Promise((resolve77) => setTimeout(resolve77, ms));
+    BEGIN_FRAME_CAPTURE_HEADROOM_INTERVALS = 10;
+    BEGIN_FRAME_COMMIT_LEAD_INTERVALS = 6;
+    BEGIN_FRAME_PROBE_LEAD_INTERVALS = 5;
     HF_READY_DIAGNOSTIC_EXPR = `(function() {
   var hf = window.__hf;
   var player = window.__player;
@@ -70621,21 +70821,25 @@ var init_referenceResolver = __esm({
 // ../engine/src/utils/urlDownloader.ts
 import {
   closeSync,
+  createReadStream as createReadStream2,
   createWriteStream,
   existsSync as existsSync9,
   fsyncSync,
+  linkSync,
   mkdtempSync,
   mkdirSync as mkdirSync5,
   lstatSync,
   openSync,
-  renameSync as renameSync2,
+  readdirSync as readdirSync3,
+  rmdirSync,
   rmSync as rmSync2,
-  statSync as statSync4
+  statSync as statSync4,
+  unlinkSync
 } from "fs";
-import { createHash } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 import { BlockList, isIP } from "net";
 import { dirname as dirname6, extname as extname2, join as join9 } from "path";
-import { Readable } from "stream";
+import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 function signalScopeKey(signal) {
   if (!signal) return "none";
@@ -70647,8 +70851,29 @@ function signalScopeKey(signal) {
   }
   return String(scope);
 }
-function classifyHttpFailure(status, statusText) {
-  const message = `HTTP ${status}: ${statusText}`;
+function safeDownloadUrlIdentity(url) {
+  let canonical = url;
+  let host;
+  try {
+    const parsed = new URL(url);
+    canonical = `${parsed.origin}${parsed.pathname}`;
+    host = parsed.hostname.toLowerCase();
+  } catch {
+  }
+  return {
+    urlFingerprint: createHash("sha256").update(canonical).digest("hex"),
+    host
+  };
+}
+function writeUrlDownloadTelemetry(event) {
+  try {
+    process.stderr.write(`[hyperframes:download] ${JSON.stringify(event)}
+`);
+  } catch {
+  }
+}
+function classifyHttpFailure(status) {
+  const message = `HTTP ${status}`;
   if (status === 404 || status === 410) {
     return new UrlDownloadError("http_not_found", false, message, status);
   }
@@ -70659,15 +70884,22 @@ function classifyHttpFailure(status, statusText) {
 }
 function classifyDownloadFailure(error) {
   if (error instanceof UrlDownloadError) return error;
-  const message = error instanceof Error ? error.message : String(error);
   let current2 = error;
   for (let depth = 0; current2 && depth < 4; depth += 1) {
     if (isRetryableNetworkCause(current2)) {
-      return new UrlDownloadError("network", true, `Download failed: ${message}`);
+      return new UrlDownloadError(
+        "network",
+        true,
+        "Download failed due to a transient network error"
+      );
     }
     current2 = typeof current2 === "object" && current2 !== null && "cause" in current2 ? current2.cause : void 0;
   }
-  return new UrlDownloadError("filesystem", false, `Download failed: ${message}`);
+  return new UrlDownloadError(
+    "filesystem",
+    false,
+    "Download failed while writing the local artifact"
+  );
 }
 function isRetryableNetworkCause(error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -70686,31 +70918,155 @@ function assertPublicHttpsUrl(url) {
   try {
     parsed = new URL(url);
   } catch {
-    throw new Error(`[URLDownloader] Invalid URL: ${url}`);
+    throw new Error("[URLDownloader] Invalid URL");
   }
   if (parsed.protocol !== "https:") {
-    throw new Error(
-      `[URLDownloader] Only HTTPS URLs are permitted in compositions (got ${parsed.protocol}): ${url}`
-    );
+    throw new Error(`[URLDownloader] Only HTTPS URLs are permitted in compositions`);
   }
   if (isBlockedHost(parsed.hostname)) {
-    throw new Error(
-      `[URLDownloader] URL targets a private/reserved address and is not permitted: ${url}`
-    );
+    throw new Error("[URLDownloader] URL targets a private/reserved address and is not permitted");
   }
 }
-function getFilenameFromUrl(url) {
-  const hash2 = createHash("md5").update(url).digest("hex").slice(0, 12);
+function getFilenameFromUrl(url, validationScope) {
+  const physicalIdentity = validationScope === "" ? url : `${url}\0${validationScope}`;
+  const hash2 = createHash("md5").update(physicalIdentity).digest("hex").slice(0, 12);
   const urlObj = new URL(url);
   const ext = extname2(urlObj.pathname) || ".mp4";
   return `download_${hash2}${ext}`;
 }
-function hasCompleteFile(path2) {
-  if (!existsSync9(path2)) return false;
-  const entry = lstatSync(path2);
-  if (entry.isFile() && entry.size > 0) return true;
-  rmSync2(path2, { recursive: entry.isDirectory(), force: true });
-  return false;
+function sameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function sameCacheLockStatGeneration(left, right) {
+  return sameFileIdentity(left, right) && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && left.birthtimeMs === right.birthtimeMs;
+}
+function observeCachePathLock(lockPath) {
+  for (let pass = 0; pass < 3; pass += 1) {
+    const before3 = lstatSync(lockPath);
+    const owner = readdirSync3(lockPath).find((name) => name.startsWith(CACHE_LOCK_OWNER_PREFIX));
+    const after2 = lstatSync(lockPath);
+    if (sameCacheLockStatGeneration(before3, after2)) return { stats: after2, owner };
+  }
+  throw new UrlDownloadError("filesystem", true, "Cache lock changed repeatedly during inspection");
+}
+function sameCachePathLock(left, right) {
+  if (left.owner !== void 0 || right.owner !== void 0) {
+    return left.owner !== void 0 && left.owner === right.owner;
+  }
+  return sameFileIdentity(left.stats, right.stats);
+}
+function removeCacheLockDirectoryIfEmpty(lockPath) {
+  try {
+    rmdirSync(lockPath);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") throw error;
+  }
+}
+function releaseOwnedCachePathLock(lockPath, owner) {
+  try {
+    rmdirSync(join9(lockPath, owner));
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  removeCacheLockDirectoryIfEmpty(lockPath);
+}
+async function waitForCacheLock(signal) {
+  if (signal?.aborted) {
+    throw new UrlDownloadError("cancelled", false, "Download cancelled");
+  }
+  await new Promise((resolve77, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve77();
+    }, CACHE_LOCK_POLL_MS);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new UrlDownloadError("cancelled", false, "Download cancelled"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function acquireCachePathLock(localPath, timeoutMs, signal) {
+  const lockPath = `${localPath}.hf-lock`;
+  const startedAt = Date.now();
+  for (; ; ) {
+    if (signal?.aborted) {
+      throw new UrlDownloadError("cancelled", false, "Download cancelled");
+    }
+    let createdLock = false;
+    try {
+      mkdirSync5(lockPath);
+      createdLock = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    if (createdLock) {
+      const owner = `${CACHE_LOCK_OWNER_PREFIX}${randomUUID2()}`;
+      try {
+        mkdirSync5(join9(lockPath, owner));
+        const entries2 = readdirSync3(lockPath);
+        if (entries2.length === 1 && entries2[0] === owner) {
+          return () => releaseOwnedCachePathLock(lockPath, owner);
+        }
+        rmdirSync(join9(lockPath, owner));
+        removeCacheLockDirectoryIfEmpty(lockPath);
+        continue;
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+    }
+    let observedLock;
+    try {
+      observedLock = observeCachePathLock(lockPath);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    if (Date.now() - observedLock.stats.mtimeMs > CACHE_LOCK_STALE_MS) {
+      if (observedLock.owner) {
+        try {
+          rmdirSync(join9(lockPath, observedLock.owner));
+        } catch (error) {
+          if (error.code === "ENOENT") continue;
+          throw error;
+        }
+        removeCacheLockDirectoryIfEmpty(lockPath);
+        continue;
+      }
+      const reclaimPath = join9(lockPath, CACHE_LOCK_RECLAIM_NAME);
+      try {
+        mkdirSync5(reclaimPath);
+      } catch (error) {
+        const code = error.code;
+        if (code === "EEXIST" || code === "ENOENT") continue;
+        throw error;
+      }
+      try {
+        const currentLock = observeCachePathLock(lockPath);
+        if (sameCachePathLock(currentLock, observedLock)) {
+          rmdirSync(reclaimPath);
+          removeCacheLockDirectoryIfEmpty(lockPath);
+        } else {
+          rmdirSync(reclaimPath);
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      continue;
+    }
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new UrlDownloadError(
+        "timeout",
+        true,
+        `Download cache lock timeout after ${timeoutMs / 1e3}s`
+      );
+    }
+    await waitForCacheLock(signal);
+  }
 }
 function assertAllowedDownloadUrl(url, redirect) {
   try {
@@ -70753,31 +71109,335 @@ async function fetchWithValidatedRedirects(initialUrl, controller) {
     assertAllowedDownloadUrl(currentUrl, redirects > 0);
     const response = await fetch(currentUrl, {
       signal: controller.signal,
-      redirect: "manual"
+      redirect: "manual",
+      headers: { "accept-encoding": "identity" }
     });
-    if (!REDIRECT_STATUSES.has(response.status)) return response;
+    if (!REDIRECT_STATUSES.has(response.status)) return { response, finalUrl: currentUrl };
     await cancelResponseBody(response);
     currentUrl = resolveRedirectUrl(response, currentUrl, redirects);
   }
 }
-async function fetchToPartial(url, partialPath, controller) {
-  const response = await fetchWithValidatedRedirects(url, controller);
+async function fetchPublicHttpsText(url, options) {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes <= 0) {
+    throw new RangeError("maxBytes must be a positive safe integer");
+  }
+  assertPublicHttpsUrl(url);
+  const controller = new AbortController();
+  let timedOut = false;
+  let callerAborted = options.signal?.aborted ?? false;
+  const onCallerAbort = () => {
+    callerAborted = true;
+    controller.abort();
+  };
+  options.signal?.addEventListener("abort", onCallerAbort, { once: true });
+  const timeoutId = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    if (callerAborted) {
+      throw new UrlDownloadError("cancelled", false, "Text fetch cancelled");
+    }
+    const { response } = await fetchWithValidatedRedirects(url, controller);
+    if (!response.ok) {
+      await cancelResponseBody(response);
+      throw classifyHttpFailure(response.status);
+    }
+    if (!response.body) return "";
+    let declaredLength;
+    try {
+      declaredLength = parseDeclaredLength(response);
+    } catch (error) {
+      await cancelResponseBody(response);
+      throw error;
+    }
+    const contentEncoding = response.headers.get("content-encoding")?.trim().toLowerCase();
+    const expectedBytes = !contentEncoding || contentEncoding === "identity" ? declaredLength : void 0;
+    if (declaredLength !== void 0 && declaredLength > options.maxBytes) {
+      await cancelResponseBody(response);
+      throw new UrlDownloadError(
+        "length_mismatch",
+        false,
+        "Text response exceeded the configured byte limit",
+        response.status
+      );
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let receivedBytes = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      receivedBytes += value.byteLength;
+      if (receivedBytes > options.maxBytes) {
+        await reader.cancel();
+        throw new UrlDownloadError(
+          "length_mismatch",
+          false,
+          "Text response exceeded the configured byte limit",
+          response.status,
+          { receivedBytes }
+        );
+      }
+      chunks.push(value);
+    }
+    if (expectedBytes !== void 0 && receivedBytes !== expectedBytes) {
+      throw new UrlDownloadError(
+        "length_mismatch",
+        true,
+        "Text response byte count did not match its declared length",
+        response.status,
+        { expectedBytes, receivedBytes }
+      );
+    }
+    return new TextDecoder().decode(Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))));
+  } catch (error) {
+    if (callerAborted) {
+      throw new UrlDownloadError("cancelled", false, "Text fetch cancelled");
+    }
+    if (timedOut) {
+      throw new UrlDownloadError("timeout", true, `Text fetch timeout after ${timeoutMs / 1e3}s`);
+    }
+    throw classifyDownloadFailure(error);
+  } finally {
+    clearTimeout(timeoutId);
+    options.signal?.removeEventListener("abort", onCallerAbort);
+    controller.abort();
+  }
+}
+function parseDeclaredLength(response) {
+  const raw = response.headers.get("content-length");
+  if (raw === null) return void 0;
+  if (!/^\d+$/.test(raw.trim())) {
+    throw new UrlDownloadError(
+      "length_mismatch",
+      true,
+      "Download response Content-Length is malformed",
+      response.status,
+      { status: response.status }
+    );
+  }
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new UrlDownloadError(
+      "length_mismatch",
+      true,
+      "Download response Content-Length is out of range",
+      response.status,
+      { status: response.status }
+    );
+  }
+  return value;
+}
+function classifyRangeDisposition(response) {
+  const contentRange = response.headers.get("content-range");
+  if (response.status === 206) {
+    const match2 = contentRange?.match(/^bytes (\d+)-(\d+)\/(\d+|\*)$/i);
+    if (!match2) return "malformed_206";
+    const start2 = Number(match2[1]);
+    const end2 = Number(match2[2]);
+    const total2 = match2[3] === "*" ? void 0 : Number(match2[3]);
+    if (!Number.isSafeInteger(start2) || !Number.isSafeInteger(end2) || start2 < 0 || end2 < start2 || total2 !== void 0 && (!Number.isSafeInteger(total2) || total2 <= end2)) {
+      return "malformed_206";
+    }
+    return "unsolicited_206";
+  }
+  if (response.status !== 200 || contentRange === null) return "none";
+  const match = contentRange.match(/^bytes (\d+)-(\d+)\/(\d+)$/i);
+  const contentLength = response.headers.get("content-length")?.trim();
+  const contentEncoding = response.headers.get("content-encoding")?.trim().toLowerCase();
+  if (!match || !contentLength || !/^\d+$/.test(contentLength)) {
+    return "content_range_on_200";
+  }
+  const start = Number(match[1]);
+  const end = Number(match[2]);
+  const total = Number(match[3]);
+  const declaredLength = Number(contentLength);
+  return Number.isSafeInteger(start) && Number.isSafeInteger(end) && Number.isSafeInteger(total) && Number.isSafeInteger(declaredLength) && start === 0 && total > 0 && end === total - 1 && declaredLength === total && (!contentEncoding || contentEncoding === "identity") ? "full_object_200" : "content_range_on_200";
+}
+function looksLikeRemoteErrorDocument(prefix) {
+  const text2 = prefix.toString("utf8").replace(/^\uFEFF?\s*/, "").toLowerCase();
+  return text2.startsWith("<!doctype html") || text2.startsWith("<html") || text2.startsWith("<head") || text2.startsWith("<body") || text2.startsWith("<error") || /^\{\s*"(?:error|message|detail|code|status)"\s*:/i.test(text2) || /^<\?xml\b/.test(text2) && /<(?:html|error)\b/.test(text2);
+}
+function normalizeCallerSha256(value) {
+  if (value === void 0) return void 0;
+  const normalized2 = value.trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(normalized2)) {
+    throw new UrlDownloadError(
+      "hash_mismatch",
+      false,
+      "Caller-provided SHA-256 checksum is malformed"
+    );
+  }
+  return normalized2;
+}
+function expectedResponseSha256(response, callerSha256) {
+  if (callerSha256) return { value: callerSha256, encoding: "hex", source: "caller" };
+  const amazonChecksum = response.headers.get("x-amz-checksum-sha256")?.trim();
+  const amazonChecksumType = response.headers.get("x-amz-checksum-type")?.trim().toUpperCase();
+  if (amazonChecksum && amazonChecksumType !== "COMPOSITE") {
+    return { value: amazonChecksum, encoding: "base64", source: "server" };
+  }
+  const digest = response.headers.get("digest");
+  const sha256Digest = digest?.match(/(?:^|,)\s*sha-256=:?([^,:\s]+):?/i)?.[1];
+  return sha256Digest ? { value: sha256Digest, encoding: "base64", source: "server" } : null;
+}
+function checksumMismatchError(source, status, telemetry) {
+  return new UrlDownloadError(
+    "hash_mismatch",
+    source === "server",
+    "Download payload checksum did not match",
+    status,
+    telemetry,
+    true
+  );
+}
+async function fetchToPartial(url, partialPath, controller, options) {
+  const { response, finalUrl } = await fetchWithValidatedRedirects(url, controller);
+  const finalIdentity = safeDownloadUrlIdentity(finalUrl);
+  const rangeDisposition = classifyRangeDisposition(response);
+  if (rangeDisposition !== "none" && rangeDisposition !== "full_object_200") {
+    await cancelResponseBody(response);
+    throw new UrlDownloadError(
+      "range_protocol",
+      true,
+      rangeDisposition === "malformed_206" ? "Download received a malformed unsolicited partial response" : "Download received an unsolicited partial response",
+      response.status,
+      {
+        finalHost: finalIdentity.host,
+        status: response.status,
+        rangeDisposition
+      }
+    );
+  }
   if (!response.ok) {
     try {
       await response.body?.cancel();
     } catch {
     }
-    throw classifyHttpFailure(response.status, response.statusText);
+    const classified = classifyHttpFailure(response.status);
+    throw new UrlDownloadError(
+      classified.kind,
+      classified.retryable,
+      classified.message,
+      classified.status,
+      { finalHost: finalIdentity.host, status: response.status, rangeDisposition }
+    );
   }
   if (!response.body) {
-    throw new UrlDownloadError("empty_body", true, "Download response body is empty");
+    throw new UrlDownloadError(
+      "empty_body",
+      true,
+      "Download response body is empty",
+      response.status,
+      {
+        finalHost: finalIdentity.host,
+        status: response.status
+      }
+    );
   }
-  const fileStream = createWriteStream(partialPath, { flags: "wx" });
+  let declaredLength;
+  try {
+    declaredLength = parseDeclaredLength(response);
+  } catch (error) {
+    await cancelResponseBody(response);
+    if (error instanceof UrlDownloadError) {
+      throw new UrlDownloadError(error.kind, error.retryable, error.message, error.status, {
+        ...error.telemetry,
+        finalHost: finalIdentity.host,
+        rangeDisposition
+      });
+    }
+    throw error;
+  }
+  const contentEncoding = response.headers.get("content-encoding")?.trim().toLowerCase();
+  const expectedBytes = !contentEncoding || contentEncoding === "identity" ? declaredLength : void 0;
+  let receivedBytes = 0;
+  const sha256 = createHash("sha256");
+  const md5 = createHash("md5");
+  const prefixChunks = [];
+  let prefixBytes = 0;
+  const inspector = new Transform({
+    transform(chunk, _encoding, callback) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      receivedBytes += bytes.length;
+      sha256.update(bytes);
+      md5.update(bytes);
+      if (prefixBytes < 1024) {
+        const remaining = 1024 - prefixBytes;
+        const sample = bytes.subarray(0, remaining);
+        prefixChunks.push(sample);
+        prefixBytes += sample.length;
+      }
+      callback(null, bytes);
+    }
+  });
   const readableStream = Readable.fromWeb(response.body);
-  await pipeline(readableStream, fileStream);
-  if (statSync4(partialPath).size === 0) {
-    throw new UrlDownloadError("empty_body", true, "Download response body contained zero bytes");
+  const fileStream = createWriteStream(partialPath, { flags: "wx" });
+  await pipeline(readableStream, inspector, fileStream);
+  const localSize = statSync4(partialPath).size;
+  const sha256Bytes = sha256.digest();
+  const localSha256 = sha256Bytes.toString("hex");
+  const md5Base64 = md5.digest("base64");
+  const telemetry = {
+    finalHost: finalIdentity.host,
+    status: response.status,
+    expectedBytes,
+    receivedBytes,
+    rangeDisposition,
+    localSize,
+    localSha256
+  };
+  if (receivedBytes === 0 || localSize === 0) {
+    throw new UrlDownloadError(
+      "empty_body",
+      true,
+      "Download response body contained zero bytes",
+      response.status,
+      telemetry
+    );
+  }
+  if (localSize !== receivedBytes || expectedBytes !== void 0 && receivedBytes !== expectedBytes) {
+    throw new UrlDownloadError(
+      "length_mismatch",
+      true,
+      "Download response byte count did not match its declared length",
+      response.status,
+      telemetry
+    );
   }
+  const prefix = Buffer.concat(prefixChunks);
+  if (looksLikeRemoteErrorDocument(prefix)) {
+    throw new UrlDownloadError(
+      "invalid_payload",
+      false,
+      "Download returned an HTML or JSON error document",
+      response.status,
+      telemetry
+    );
+  }
+  const expectedSha256 = expectedResponseSha256(response, options.expectedSha256);
+  const checksumMatches = expectedSha256 === null || (expectedSha256.encoding === "base64" ? sha256Bytes.toString("base64") === expectedSha256.value : localSha256 === expectedSha256.value);
+  const contentMd5 = response.headers.get("content-md5")?.trim();
+  if (!checksumMatches) {
+    throw checksumMismatchError(expectedSha256?.source ?? "server", response.status, telemetry);
+  }
+  if (expectedSha256 === null && contentMd5 && md5Base64 !== contentMd5) {
+    throw checksumMismatchError("server", response.status, telemetry);
+  }
+  const etag = response.headers.get("etag")?.trim();
+  return {
+    finalHost: finalIdentity.host,
+    status: response.status,
+    expectedBytes,
+    receivedBytes,
+    rangeDisposition,
+    etagFingerprint: etag ? createHash("sha256").update(etag).digest("hex") : void 0,
+    etagWeak: etag ? /^W\//i.test(etag) : void 0,
+    localSize,
+    localSha256
+  };
 }
 function syncAndPublishPartial(partialPath, localPath) {
   const fd = openSync(partialPath, "r+");
@@ -70786,14 +71446,35 @@ function syncAndPublishPartial(partialPath, localPath) {
   } finally {
     closeSync(fd);
   }
-  if (hasCompleteFile(localPath)) return;
   try {
-    renameSync2(partialPath, localPath);
+    linkSync(partialPath, localPath);
+    unlinkSync(partialPath);
+    return "published";
   } catch (error) {
-    if (!hasCompleteFile(localPath)) throw error;
+    const code = error.code;
+    if (code !== "EEXIST") throw error;
+    let winner;
+    try {
+      winner = lstatSync(localPath);
+    } catch (inspectionError) {
+      if (inspectionError.code !== "ENOENT") throw inspectionError;
+      throw new UrlDownloadError(
+        "filesystem",
+        true,
+        "Concurrent cache artifact disappeared before validation"
+      );
+    }
+    if (!winner.isFile() || winner.size === 0) throw error;
+    return "race_reused";
   }
 }
-async function runDownloadAttempt(url, localPath, timeoutMs, signal) {
+function emitDownloadTelemetry(options, event) {
+  try {
+    options.onTelemetry?.(event);
+  } catch {
+  }
+}
+async function runDownloadAttempt(url, localPath, timeoutMs, attempt, options, signal) {
   const attemptDir = mkdtempSync(join9(dirname6(localPath), ".hf-download-"));
   const partialPath = join9(attemptDir, "payload");
   const controller = new AbortController();
@@ -70808,21 +71489,91 @@ async function runDownloadAttempt(url, localPath, timeoutMs, signal) {
     timedOut = true;
     controller.abort();
   }, timeoutMs);
+  const identity = safeDownloadUrlIdentity(url);
   try {
     if (callerAborted) {
       throw new UrlDownloadError("cancelled", false, "Download cancelled");
     }
-    await fetchToPartial(url, partialPath, controller);
-    syncAndPublishPartial(partialPath, localPath);
+    const integrity = await fetchToPartial(url, partialPath, controller, options);
+    let outcome = syncAndPublishPartial(partialPath, localPath);
+    let publishedIntegrity = integrity;
+    if (outcome === "race_reused") {
+      let inspection;
+      try {
+        inspection = await inspectExistingFile(localPath);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        throw new UrlDownloadError(
+          "filesystem",
+          true,
+          "Concurrent cache artifact disappeared before validation",
+          integrity.status,
+          integrity
+        );
+      }
+      publishedIntegrity = {
+        ...integrity,
+        localSize: inspection.localSize,
+        localSha256: inspection.localSha256
+      };
+      if (!localInspectionMatchesOptions(inspection, options)) {
+        if (looksLikeRemoteErrorDocument(inspection.prefix)) {
+          throw new UrlDownloadError(
+            "invalid_payload",
+            false,
+            "Concurrent download published an HTML or JSON error document",
+            integrity.status,
+            publishedIntegrity
+          );
+        }
+        throw checksumMismatchError("caller", integrity.status, publishedIntegrity);
+      }
+    }
+    emitDownloadTelemetry(options, {
+      urlFingerprint: identity.urlFingerprint,
+      initialHost: identity.host,
+      attempt,
+      outcome,
+      ...publishedIntegrity
+    });
     return localPath;
   } catch (error) {
     if (callerAborted) {
-      throw new UrlDownloadError("cancelled", false, "Download cancelled");
+      const classified2 = new UrlDownloadError("cancelled", false, "Download cancelled");
+      emitDownloadTelemetry(options, {
+        urlFingerprint: identity.urlFingerprint,
+        initialHost: identity.host,
+        attempt,
+        outcome: "attempt_failed",
+        failureKind: classified2.kind
+      });
+      throw classified2;
     }
     if (timedOut) {
-      throw new UrlDownloadError("timeout", true, `Download timeout after ${timeoutMs / 1e3}s`);
+      const classified2 = new UrlDownloadError(
+        "timeout",
+        true,
+        `Download timeout after ${timeoutMs / 1e3}s`
+      );
+      emitDownloadTelemetry(options, {
+        urlFingerprint: identity.urlFingerprint,
+        initialHost: identity.host,
+        attempt,
+        outcome: "attempt_failed",
+        failureKind: classified2.kind
+      });
+      throw classified2;
     }
-    throw classifyDownloadFailure(error);
+    const classified = classifyDownloadFailure(error);
+    emitDownloadTelemetry(options, {
+      urlFingerprint: identity.urlFingerprint,
+      initialHost: identity.host,
+      attempt,
+      outcome: "attempt_failed",
+      failureKind: classified.kind,
+      ...classified.telemetry
+    });
+    throw classified;
   } finally {
     clearTimeout(timeoutId);
     signal?.removeEventListener("abort", onCallerAbort);
@@ -70830,22 +71581,114 @@ async function runDownloadAttempt(url, localPath, timeoutMs, signal) {
     rmSync2(attemptDir, { recursive: true, force: true });
   }
 }
-async function downloadWithRetry(url, localPath, timeoutMs, signal, onTransientRetry) {
+async function downloadWithRetry(url, localPath, timeoutMs, signal, onTransientRetry, options = {}) {
   const maxTransientRetries = 1;
   for (let attempt = 0; ; attempt += 1) {
     try {
-      return await runDownloadAttempt(url, localPath, timeoutMs, signal);
+      return await runDownloadAttempt(url, localPath, timeoutMs, attempt + 1, options, signal);
     } catch (error) {
       const classified = classifyDownloadFailure(error);
-      if (!classified.retryable || attempt >= maxTransientRetries) throw classified;
-      onTransientRetry?.(classified);
+      if (!classified.locallyRetryable || attempt >= maxTransientRetries) throw classified;
+      if (classified.retryable) onTransientRetry?.(classified);
+      const identity = safeDownloadUrlIdentity(url);
+      emitDownloadTelemetry(options, {
+        urlFingerprint: identity.urlFingerprint,
+        initialHost: identity.host,
+        attempt: attempt + 1,
+        outcome: "retrying",
+        failureKind: classified.kind,
+        ...classified.telemetry
+      });
+    }
+  }
+}
+async function inspectExistingFile(path2) {
+  const sha256 = createHash("sha256");
+  const prefixChunks = [];
+  let prefixBytes = 0;
+  let localSize = 0;
+  for await (const chunk of createReadStream2(path2)) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    localSize += bytes.length;
+    sha256.update(bytes);
+    if (prefixBytes < 1024) {
+      const sample = bytes.subarray(0, 1024 - prefixBytes);
+      prefixChunks.push(sample);
+      prefixBytes += sample.length;
     }
   }
+  return {
+    localSize,
+    localSha256: sha256.digest("hex"),
+    prefix: Buffer.concat(prefixChunks)
+  };
+}
+function localInspectionMatchesOptions(inspection, options) {
+  const expectedSha256 = options.expectedSha256?.trim().toLowerCase();
+  return inspection.localSize > 0 && !looksLikeRemoteErrorDocument(inspection.prefix) && (!expectedSha256 || inspection.localSha256 === expectedSha256);
+}
+function sameCacheEntry(before3, after2) {
+  return sameFileIdentity(before3, after2) && before3.size === after2.size && before3.mtimeMs === after2.mtimeMs;
+}
+async function reuseOrInvalidateCachedFile(url, localPath, timeoutMs, signal, options) {
+  const releaseLock = await acquireCachePathLock(localPath, timeoutMs, signal);
+  try {
+    for (let pass = 0; pass < 3; pass += 1) {
+      let before3;
+      try {
+        before3 = lstatSync(localPath);
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      if (!before3.isFile() || before3.size === 0) {
+        rmSync2(localPath, { recursive: before3.isDirectory(), force: true });
+        return false;
+      }
+      let inspection;
+      try {
+        inspection = await inspectExistingFile(localPath);
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      let after2;
+      try {
+        after2 = lstatSync(localPath);
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      if (!sameCacheEntry(before3, after2)) continue;
+      if (localInspectionMatchesOptions(inspection, options)) {
+        const identity = safeDownloadUrlIdentity(url);
+        emitDownloadTelemetry(options, {
+          urlFingerprint: identity.urlFingerprint,
+          initialHost: identity.host,
+          attempt: 0,
+          outcome: "cache_hit",
+          receivedBytes: inspection.localSize,
+          localSize: inspection.localSize,
+          localSha256: inspection.localSha256,
+          rangeDisposition: "none"
+        });
+        return true;
+      }
+      rmSync2(localPath, { force: true });
+      return false;
+    }
+    return false;
+  } finally {
+    releaseLock();
+  }
 }
-async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransientRetry) {
+async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransientRetry, options = {}) {
   assertPublicHttpsUrl(url);
+  const expectedSha256 = normalizeCallerSha256(options.expectedSha256);
+  const normalizedOptions = { ...options, expectedSha256 };
   const cacheKey = `${url}\0${destDir}`;
-  const inFlightKey = `${cacheKey}\0${timeoutMs}\0${signalScopeKey(signal)}`;
+  const validationScope = expectedSha256 ?? "";
+  const inFlightKey = `${cacheKey}\0${timeoutMs}\0${signalScopeKey(signal)}\0${validationScope}`;
   const inFlight2 = inFlightDownloads.get(inFlightKey);
   if (inFlight2) {
     return inFlight2;
@@ -70853,10 +71696,35 @@ async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransient
   if (!existsSync9(destDir)) {
     mkdirSync5(destDir, { recursive: true });
   }
-  const filename = getFilenameFromUrl(url);
+  const filename = getFilenameFromUrl(url, validationScope);
   const localPath = join9(destDir, filename);
-  if (hasCompleteFile(localPath)) return localPath;
-  const downloadPromise = downloadWithRetry(url, localPath, timeoutMs, signal, onTransientRetry);
+  const downloadPromise = (async () => {
+    const cacheStartedAt = Date.now();
+    const reused = await reuseOrInvalidateCachedFile(
+      url,
+      localPath,
+      timeoutMs,
+      signal,
+      normalizedOptions
+    );
+    const remainingTimeoutMs = timeoutMs - (Date.now() - cacheStartedAt);
+    if (remainingTimeoutMs <= 0) {
+      throw new UrlDownloadError(
+        "timeout",
+        true,
+        `Download cache inspection timeout after ${timeoutMs / 1e3}s`
+      );
+    }
+    if (reused) return localPath;
+    return downloadWithRetry(
+      url,
+      localPath,
+      remainingTimeoutMs,
+      signal,
+      onTransientRetry,
+      normalizedOptions
+    );
+  })();
   const trackedDownload = downloadPromise.finally(() => {
     inFlightDownloads.delete(inFlightKey);
   });
@@ -70866,7 +71734,7 @@ async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransient
 function isHttpUrl(path2) {
   return path2.startsWith("http://") || path2.startsWith("https://");
 }
-var inFlightDownloads, signalScopes, nextSignalScope, UrlDownloadError, RETRYABLE_NETWORK_CODES, NON_PUBLIC_IPV4_ADDRESSES, NON_PUBLIC_IPV6_ADDRESSES, REDIRECT_STATUSES, MAX_REDIRECTS;
+var inFlightDownloads, signalScopes, nextSignalScope, UrlDownloadError, RETRYABLE_NETWORK_CODES, NON_PUBLIC_IPV4_ADDRESSES, NON_PUBLIC_IPV6_ADDRESSES, CACHE_LOCK_POLL_MS, CACHE_LOCK_STALE_MS, CACHE_LOCK_RECLAIM_NAME, CACHE_LOCK_OWNER_PREFIX, REDIRECT_STATUSES, MAX_REDIRECTS;
 var init_urlDownloader = __esm({
   "../engine/src/utils/urlDownloader.ts"() {
     "use strict";
@@ -70874,16 +71742,20 @@ var init_urlDownloader = __esm({
     signalScopes = /* @__PURE__ */ new WeakMap();
     nextSignalScope = 1;
     UrlDownloadError = class extends Error {
-      constructor(kind, retryable, message, status) {
+      constructor(kind, retryable, message, status, telemetry, locallyRetryable = retryable) {
         super(message);
         this.kind = kind;
         this.retryable = retryable;
         this.status = status;
+        this.telemetry = telemetry;
+        this.locallyRetryable = locallyRetryable;
         this.name = "UrlDownloadError";
       }
       kind;
       retryable;
       status;
+      telemetry;
+      locallyRetryable;
     };
     RETRYABLE_NETWORK_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "EAI_AGAIN"]);
     NON_PUBLIC_IPV4_ADDRESSES = new BlockList();
@@ -70919,6 +71791,10 @@ var init_urlDownloader = __esm({
     ]) {
       NON_PUBLIC_IPV6_ADDRESSES.addSubnet(network, prefix, "ipv6");
     }
+    CACHE_LOCK_POLL_MS = 10;
+    CACHE_LOCK_STALE_MS = 5 * 6e4;
+    CACHE_LOCK_RECLAIM_NAME = ".hf-reclaim";
+    CACHE_LOCK_OWNER_PREFIX = ".hf-owner-";
     REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
     MAX_REDIRECTS = 5;
   }
@@ -75531,8 +76407,62 @@ function containsTimelineCall2(node, timelineVar) {
 function rangeOf2(node) {
   return typeof node.start === "number" && typeof node.end === "number" ? [node.start, node.end] : void 0;
 }
+function isSafeDefaultExpression2(node, earlierParams) {
+  let safe = true;
+  const visit = (current2, parent, key2) => {
+    if (!isNode3(current2) || !safe) return;
+    if (!SAFE_DEFAULT_NODES2.has(current2.type)) {
+      safe = false;
+      return;
+    }
+    if (current2.type === "UnaryExpression" && current2.operator === "delete") {
+      safe = false;
+      return;
+    }
+    if (current2.type === "Identifier") {
+      const nonValue = parent && key2 ? isNonValueIdentifierSlot2(parent, key2) : false;
+      if (!nonValue && current2.name !== "undefined" && !earlierParams.has(current2.name)) {
+        safe = false;
+      }
+      return;
+    }
+    for (const childKey of Object.keys(current2)) {
+      if (SKIP_KEYS2.has(childKey)) continue;
+      const child = current2[childKey];
+      if (Array.isArray(child)) {
+        for (const item of child) visit(item, current2, childKey);
+      } else {
+        visit(child, current2, childKey);
+      }
+    }
+  };
+  visit(node);
+  return safe;
+}
+function supportedParam2(param, earlier) {
+  if (param.type === "Identifier") return { name: param.name };
+  if (param.type !== "AssignmentPattern" || param.left?.type !== "Identifier") return null;
+  if (!isSafeDefaultExpression2(param.right, earlier)) return null;
+  return { name: param.left.name, defaultExpression: param.right };
+}
+function supportedParams2(fn) {
+  if (SUPPORTED_PARAMS_CACHE2.has(fn)) return SUPPORTED_PARAMS_CACHE2.get(fn) ?? null;
+  const params = [];
+  const earlier = /* @__PURE__ */ new Set();
+  for (const param of fn.params ?? []) {
+    const parsed = supportedParam2(param, earlier);
+    if (!parsed) {
+      SUPPORTED_PARAMS_CACHE2.set(fn, null);
+      return null;
+    }
+    params.push(parsed);
+    earlier.add(parsed.name);
+  }
+  SUPPORTED_PARAMS_CACHE2.set(fn, params);
+  return params;
+}
 function isShapeEligible2(fn) {
-  return isFunctionNode3(fn) && fn.body?.type === "BlockStatement" && !(fn.params ?? []).some((p2) => p2.type !== "Identifier");
+  return isFunctionNode3(fn) && fn.body?.type === "BlockStatement" && supportedParams2(fn) !== null;
 }
 function callsAny2(node, names) {
   let hit = false;
@@ -75582,20 +76512,55 @@ function timelineBuildingNames2(candidates, timelineVar) {
 function bump2(counts, key2) {
   counts.set(key2, (counts.get(key2) ?? 0) + 1);
 }
+function undefinedIdentifier2() {
+  return { type: "Identifier", name: "undefined" };
+}
+function isExplicitUndefined2(node) {
+  return node?.type === "Identifier" && node.name === "undefined" || node?.type === "UnaryExpression" && node.operator === "void" && node.argument?.type === "Literal" && node.argument.value === 0;
+}
+function resolveHelperBindings2(call, params) {
+  if (call.arguments?.some((arg) => arg?.type === "SpreadElement")) return null;
+  const bindings = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < params.length; i2++) {
+    const param = params[i2];
+    const arg = call.arguments?.[i2];
+    if (arg && !isExplicitUndefined2(arg)) {
+      bindings.set(param.name, arg);
+    } else if (param.defaultExpression) {
+      bindings.set(param.name, substituteParams2(cloneNode3(param.defaultExpression), bindings));
+    } else {
+      bindings.set(param.name, undefinedIdentifier2());
+    }
+  }
+  return bindings;
+}
+function statementHelperCall2(node, names) {
+  if (node.type !== "ExpressionStatement") return void 0;
+  const expression = node.expression;
+  if (expression?.type !== "CallExpression" || expression.callee?.type !== "Identifier") {
+    return void 0;
+  }
+  return names.has(expression.callee.name) ? expression : void 0;
+}
 function safelyDroppable2(program, candidates) {
   const names = new Set(candidates.keys());
   const totalIds = /* @__PURE__ */ new Map();
   const stmtCalls = /* @__PURE__ */ new Map();
+  const unbindable = /* @__PURE__ */ new Set();
   walkNodes2(program, (n2) => {
     if (n2.type === "Identifier" && names.has(n2.name)) bump2(totalIds, n2.name);
-    const e3 = n2.type === "ExpressionStatement" ? n2.expression : void 0;
-    if (e3?.type === "CallExpression" && e3.callee?.type === "Identifier" && names.has(e3.callee.name)) {
-      bump2(stmtCalls, e3.callee.name);
-    }
+    const call = statementHelperCall2(n2, names);
+    if (!call) return;
+    bump2(stmtCalls, call.callee.name);
+    const fn = candidates.get(call.callee.name);
+    const params = fn && supportedParams2(fn);
+    if (!params || !resolveHelperBindings2(call, params)) unbindable.add(call.callee.name);
   });
   const safe = /* @__PURE__ */ new Map();
   for (const [name, fn] of candidates) {
-    if ((totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) safe.set(name, fn);
+    if (!unbindable.has(name) && (totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) {
+      safe.set(name, fn);
+    }
   }
   return safe;
 }
@@ -75638,11 +76603,11 @@ function expandBody2(bodyStmts, bindings, prov, ctx) {
 }
 function inlineHelper2(call, ctx) {
   const fn = ctx.helpers.get(call.callee.name);
-  const bindings = /* @__PURE__ */ new Map();
-  (fn.params ?? []).forEach((p2, i2) => {
-    const arg = call.arguments?.[i2];
-    if (arg) bindings.set(p2.name, arg);
-  });
+  if (!fn) return null;
+  const params = supportedParams2(fn);
+  if (!params) return null;
+  const bindings = resolveHelperBindings2(call, params);
+  if (!bindings) return null;
   const prov = {
     kind: "helper",
     fn: call.callee.name,
@@ -77117,7 +78082,7 @@ function extractGsapLabels(script) {
     return [];
   }
 }
-var PROPERTY_GROUPS2, PROP_TO_GROUP2, SKIP_KEYS2, FUNCTION_TYPES2, GSAP_METHODS3, MAX_DEPTH2, MAX_ITERS2, roundPercentage2, GSAP_METHODS22, QUERY_METHODS2, ITERATION_METHODS2, SCOPE_NODE_TYPES2, CONST_NODES2, MATH_FNS2, MATH_CONSTS2, BUILTIN_VAR_KEYS2, DROPPED_VAR_KEYS2, EXTRAS_KEYS2, PERCENTAGE_KEY_RE2, GSAP_DEFAULT_DURATION2;
+var PROPERTY_GROUPS2, PROP_TO_GROUP2, SKIP_KEYS2, FUNCTION_TYPES2, GSAP_METHODS3, MAX_DEPTH2, MAX_ITERS2, SAFE_DEFAULT_NODES2, SUPPORTED_PARAMS_CACHE2, roundPercentage2, GSAP_METHODS22, QUERY_METHODS2, ITERATION_METHODS2, SCOPE_NODE_TYPES2, CONST_NODES2, MATH_FNS2, MATH_CONSTS2, BUILTIN_VAR_KEYS2, DROPPED_VAR_KEYS2, EXTRAS_KEYS2, PERCENTAGE_KEY_RE2, GSAP_DEFAULT_DURATION2;
 var init_gsapParserAcorn = __esm({
   "../parsers/dist/gsapParserAcorn.js"() {
     "use strict";
@@ -77144,6 +78109,23 @@ var init_gsapParserAcorn = __esm({
     GSAP_METHODS3 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
     MAX_DEPTH2 = 8;
     MAX_ITERS2 = 512;
+    SAFE_DEFAULT_NODES2 = /* @__PURE__ */ new Set([
+      "ArrayExpression",
+      "BinaryExpression",
+      "ChainExpression",
+      "ConditionalExpression",
+      "Identifier",
+      "Literal",
+      "LogicalExpression",
+      "MemberExpression",
+      "ObjectExpression",
+      "Property",
+      "SpreadElement",
+      "TemplateElement",
+      "TemplateLiteral",
+      "UnaryExpression"
+    ]);
+    SUPPORTED_PARAMS_CACHE2 = /* @__PURE__ */ new WeakMap();
     roundPercentage2 = (percentage) => Math.round(percentage * 10) / 10;
     GSAP_METHODS22 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
     QUERY_METHODS2 = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
@@ -77184,7 +78166,7 @@ __export(dist_exports2, {
 });
 import postcss2 from "postcss";
 import postcss22 from "postcss";
-import { existsSync as existsSync22, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "fs";
 import { dirname as dirname7, extname as extname3, join as join22, relative as relative3, resolve as resolve8 } from "path";
 import { execFile } from "child_process";
 import { existsSync as existsSync11 } from "fs";
@@ -79013,6 +79995,7 @@ async function probeIsHevc(ffprobePath, filePath) {
       "stream=codec_name",
       "-of",
       "json",
+      "--",
       filePath
     ]);
     return hasHevcStream(JSON.parse(stdout2));
@@ -79169,7 +80152,7 @@ async function lintProject(projectDir, entryFile) {
   if (!entryFile && existsSync22(compositionsDir)) {
     const collectHtmlFiles = (dir, rel) => {
       const out = [];
-      for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      for (const entry of readdirSync4(dir, { withFileTypes: true })) {
         const relPath = rel ? `${rel}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
           if (!rel && entry.name === "components") continue;
@@ -79230,7 +80213,7 @@ function lintProjectAudioFiles(projectDir, htmlSources) {
   const findings = [];
   let audioFiles;
   try {
-    audioFiles = readdirSync3(projectDir).filter(
+    audioFiles = readdirSync4(projectDir).filter(
       (f3) => AUDIO_EXTENSIONS.has(extname3(f3).toLowerCase())
     );
   } catch {
@@ -79349,7 +80332,7 @@ function lintTextureMaskAssetNotFound(projectDir, htmlSources) {
 function lintMultipleRootCompositions(projectDir) {
   const findings = [];
   try {
-    const rootHtmlFiles = readdirSync3(projectDir).filter(
+    const rootHtmlFiles = readdirSync4(projectDir).filter(
       (file) => file.endsWith(".html") && !file.startsWith("._")
     );
     const rootCompositions = [];
@@ -83972,13 +84955,13 @@ var init_htmlTemplate = __esm({
 });
 
 // ../engine/src/services/extractionCache.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
 import {
   existsSync as existsSync13,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync6,
-  readdirSync as readdirSync4,
-  renameSync as renameSync3,
+  readdirSync as readdirSync5,
+  renameSync as renameSync2,
   rmSync as rmSync3,
   statSync as statSync5,
   utimesSync,
@@ -84020,7 +85003,7 @@ function lookupCacheEntry(rootDir, input2) {
   return { entry: { dir, keyHash }, hit: complete };
 }
 function partialCacheEntryDir(entry) {
-  return `${entry.dir}.partial-${process.pid}-${randomUUID2().slice(0, 8)}`;
+  return `${entry.dir}.partial-${process.pid}-${randomUUID3().slice(0, 8)}`;
 }
 function isTargetExistsRenameError(err) {
   const code = err.code;
@@ -84038,7 +85021,7 @@ function publishCacheEntry(entry, partialDir) {
     return { dir: partialDir, published: false };
   }
   try {
-    renameSync3(partialDir, entry.dir);
+    renameSync2(partialDir, entry.dir);
     return { dir: entry.dir, published: true };
   } catch (err) {
     if (!isTargetExistsRenameError(err)) return { dir: partialDir, published: false };
@@ -84051,7 +85034,7 @@ function publishCacheEntry(entry, partialDir) {
     return { dir: partialDir, published: false };
   }
   try {
-    renameSync3(partialDir, entry.dir);
+    renameSync2(partialDir, entry.dir);
     return { dir: entry.dir, published: true };
   } catch {
     return adoptPublishedWinner(entry, partialDir) ?? { dir: partialDir, published: false };
@@ -84080,7 +85063,7 @@ function directorySizeBytes(path2) {
   let total = 0;
   let children;
   try {
-    children = readdirSync4(path2);
+    children = readdirSync5(path2);
   } catch {
     return 0;
   }
@@ -84138,7 +85121,7 @@ function gcExtractionCache(rootDir, opts) {
   try {
     const now = Date.now();
     const entries2 = [];
-    for (const child of readdirSync4(rootDir, { withFileTypes: true })) {
+    for (const child of readdirSync5(rootDir, { withFileTypes: true })) {
       if (!child.isDirectory() || !isCacheLikeChild(child.name)) continue;
       const entry = collectGcEntry(
         join11(rootDir, child.name),
@@ -84168,7 +85151,7 @@ function rehydrateCacheEntry(entry, options) {
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${options.format}`;
   const framePaths = /* @__PURE__ */ new Map();
   const suffix = `.${options.format}`;
-  const files = readdirSync4(entry.dir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(suffix)).sort();
+  const files = readdirSync5(entry.dir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(suffix)).sort();
   files.forEach((file, idx) => {
     framePaths.set(idx, join11(entry.dir, file));
   });
@@ -84197,7 +85180,7 @@ var init_extractionCache = __esm({
 });
 
 // ../engine/src/services/videoFrameExtractor.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync14, linkSync, mkdirSync as mkdirSync7, readdirSync as readdirSync5, rmSync as rmSync4 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync14, linkSync as linkSync2, mkdirSync as mkdirSync7, readdirSync as readdirSync6, rmSync as rmSync4 } from "fs";
 import { isAbsolute as isAbsolute4, join as join12, posix as posix3, resolve as resolve10, sep as sep3 } from "path";
 function isVideoFrameFormat(value) {
   return typeof value === "string" && VIDEO_FRAME_FORMATS.includes(value);
@@ -84281,6 +85264,14 @@ function classifyVideoExtractionError(error) {
         diagnostic
       );
     }
+    if (error.kind === "invalid_payload") {
+      return new VideoSourceExtractionError(
+        "invalid_media",
+        false,
+        "Video source download returned a non-media payload",
+        diagnostic
+      );
+    }
     if (error.retryable) {
       return new VideoSourceExtractionError(
         "download_transient",
@@ -84578,7 +85569,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
     );
   }
   const framePaths = /* @__PURE__ */ new Map();
-  const files = readdirSync5(videoOutputDir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(`.${format}`)).sort();
+  const files = readdirSync6(videoOutputDir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(`.${format}`)).sort();
   files.forEach((file, index) => {
     framePaths.set(index, join12(videoOutputDir, file));
   });
@@ -84755,7 +85746,7 @@ function resolveFrameFormat(metadata, requested) {
 }
 function extractedFrameFileNames(outputDir, format) {
   const suffix = `.${format}`;
-  return readdirSync5(outputDir).filter((file) => file.startsWith(FRAME_FILENAME_PREFIX) && file.endsWith(suffix)).sort();
+  return readdirSync6(outputDir).filter((file) => file.startsWith(FRAME_FILENAME_PREFIX) && file.endsWith(suffix)).sort();
 }
 function extractedFramesFromDirectory(work, outputDir, srcPath, fps) {
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${work.format}`;
@@ -84779,7 +85770,7 @@ function frameFileName(frameNumber, format) {
 }
 function linkOrCopyFrame(src, dest) {
   try {
-    linkSync(src, dest);
+    linkSync2(src, dest);
   } catch {
     copyFileSync2(src, dest);
   }
@@ -84964,7 +85955,8 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
           downloadDir,
           void 0,
           signal,
-          () => recordTransientRetries(1)
+          () => recordTransientRetries(1),
+          { onTelemetry: writeUrlDownloadTelemetry }
         );
       }
       if (!existsSync14(videoPath)) {
@@ -86021,7 +87013,7 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { readFileSync as readFileSync6, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync6, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
 import { randomBytes } from "crypto";
 function parseWavLayout(buffer) {
   if (buffer.length < 12 || buffer.toString("ascii", 0, 4) !== "RIFF") return null;
@@ -86083,7 +87075,7 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
     }
     const tempPath = `${wavPath}.${randomBytes(6).toString("hex")}.tmp`;
     writeFileSync5(tempPath, buffer);
-    renameSync4(tempPath, wavPath);
+    renameSync3(tempPath, wavPath);
     return true;
   } catch {
     return false;
@@ -86224,15 +87216,17 @@ function probeFailure(message, elementId) {
     detail: boundedDetail(`Audio probe failed for element ${elementId}: ${message}`)
   };
 }
-function downloadFailure(message, elementId) {
-  const invalidSource = /(?:invalid URL|only HTTPS|private\/reserved|HTTP (?:400|401|403|404|405|410|422)\b)/i.test(
+function downloadFailure(error, elementId) {
+  const message = error instanceof Error ? error.message : String(error);
+  const invalidSource = error instanceof UrlDownloadError ? error.kind === "http_not_found" || error.kind === "http_rejected" || error.kind === "invalid_payload" || error.kind === "cancelled" : /(?:invalid URL|only HTTPS|private\/reserved|HTTP (?:400|401|403|404|405|410|422)\b)/i.test(
     message
   );
+  const retryable = error instanceof UrlDownloadError ? error.retryable : !invalidSource;
   return {
     stage: "download",
     reason: "download_failed",
     owner: invalidSource ? "user" : "system",
-    retryable: !invalidSource,
+    retryable,
     elementId,
     detail: boundedDetail(`Download failed for audio element ${elementId}: ${message}`)
   };
@@ -86579,11 +87573,11 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         if (isHttpUrl(srcPath)) {
           try {
-            srcPath = await downloadToTemp(srcPath, workDir);
+            srcPath = await downloadToTemp(srcPath, workDir, void 0, signal, void 0, {
+              onTelemetry: writeUrlDownloadTelemetry
+            });
           } catch (err) {
-            failures.push(
-              downloadFailure(err instanceof Error ? err.message : String(err), element.id)
-            );
+            failures.push(downloadFailure(err, element.id));
             return;
           }
         }
@@ -86863,7 +87857,7 @@ var init_readWebGlVendorInfoFromCanvas = __esm({
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus, freemem } from "os";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync7 } from "fs";
 import { copyFile, readFile, rename } from "fs/promises";
 import { join as join15 } from "path";
 import { getHeapStatistics } from "v8";
@@ -87289,7 +88283,7 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
     if (!existsSync16(task.outputDir)) {
       continue;
     }
-    const files = readdirSync6(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
+    const files = readdirSync7(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
       const sourcePath = join15(task.outputDir, file);
       const targetPath = join15(outputDir, file);
@@ -88804,7 +89798,7 @@ var init_shaderTransitions = __esm({
 });
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync18, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
 import { join as join17 } from "path";
 import { homedir as homedir3 } from "os";
 function linearToPQ(L2) {
@@ -88923,7 +89917,7 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
 function resolveHeadedChromePath() {
   const baseDir = join17(homedir3(), ".cache", "puppeteer", "chrome");
   if (!existsSync18(baseDir)) return void 0;
-  const versions = readdirSync7(baseDir).sort().reverse();
+  const versions = readdirSync8(baseDir).sort().reverse();
   for (const version2 of versions) {
     const candidates = [
       join17(
@@ -89086,6 +90080,7 @@ __export(src_exports, {
   decodePng: () => decodePng,
   decodePngToRgb48le: () => decodePngToRgb48le,
   defaultExtractCacheDir: () => defaultExtractCacheDir,
+  deriveBeginFrameProbeTimeTicks: () => deriveBeginFrameProbeTimeTicks,
   detectGpuEncoder: () => detectGpuEncoder,
   detectTransfer: () => detectTransfer,
   diffGpuParityFrames: () => diffGpuParityFrames,
@@ -89105,6 +90100,7 @@ __export(src_exports, {
   extractVideoFramesRange: () => extractVideoFramesRange,
   extractVideoMetadata: () => extractVideoMetadata,
   extractionFrameCountForDuration: () => extractionFrameCountForDuration,
+  fetchPublicHttpsText: () => fetchPublicHttpsText,
   float16ToPqRgb: () => float16ToPqRgb,
   formatFfmpegError: () => formatFfmpegError,
   getCapturePerfSummary: () => getCapturePerfSummary,
@@ -89178,6 +90174,7 @@ __export(src_exports, {
   roundedRectAlpha: () => roundedRectAlpha,
   runFfmpeg: () => runFfmpeg,
   runVideoExtractionWithRetry: () => runVideoExtractionWithRetry,
+  safeDownloadUrlIdentity: () => safeDownloadUrlIdentity,
   sampleRgb48le: () => sampleRgb48le,
   scaleProtocolTimeoutForComposition: () => scaleProtocolTimeoutForComposition,
   selectVerifySampleIndicesForTask: () => selectVerifySampleIndicesForTask,
@@ -89190,7 +90187,8 @@ __export(src_exports, {
   validateEngineConfigSnapshot: () => validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples: () => verifyDiskDrawElementSamples,
   verifyGpuParity: () => verifyGpuParity,
-  writeCapturedFrame: () => writeCapturedFrame
+  writeCapturedFrame: () => writeCapturedFrame,
+  writeUrlDownloadTelemetry: () => writeUrlDownloadTelemetry
 });
 var init_src = __esm({
   "../engine/src/index.ts"() {
@@ -89748,10 +90746,10 @@ var init_canary2 = __esm({
 
 // src/telemetry/transport.ts
 import { spawn as spawn5 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function enqueue(event, properties, distinctId) {
   eventQueue.push({
-    uuid: randomUUID3(),
+    uuid: randomUUID4(),
     event,
     distinctId,
     properties,
@@ -93231,12 +94229,12 @@ var init_ffmpeg = __esm({
 });
 
 // src/utils/download.ts
-import { createWriteStream as createWriteStream2, renameSync as renameSync5, unlinkSync } from "fs";
+import { createWriteStream as createWriteStream2, renameSync as renameSync4, unlinkSync as unlinkSync2 } from "fs";
 import { get as httpsGet } from "https";
 import { pipeline as pipeline2 } from "stream/promises";
 function removePartialFile(path2) {
   try {
-    unlinkSync(path2);
+    unlinkSync2(path2);
   } catch {
   }
 }
@@ -93267,7 +94265,7 @@ function downloadFile(url, dest, options = {}) {
         const file = createWriteStream2(tmp);
         responsePipelineStarted = true;
         pipeline2(res, file).then(() => {
-          renameSync5(tmp, dest);
+          renameSync4(tmp, dest);
           resolve77();
         }).catch((err) => {
           removePartialFile(tmp);
@@ -93500,10 +94498,10 @@ __export(transcribe_exports, {
   wrapWhisperTimeoutError: () => wrapWhisperTimeoutError
 });
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync14, mkdirSync as mkdirSync12, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync14, mkdirSync as mkdirSync12, unlinkSync as unlinkSync3 } from "fs";
 import { join as join21, extname as extname5 } from "path";
 import { tmpdir as tmpdir3 } from "os";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function detectLanguage(whisperPath, modelPath2, wavPath) {
   try {
     const output = execFileSync5(whisperPath, ["--model", modelPath2, "--detect-language", wavPath], {
@@ -93573,6 +94571,7 @@ function getMediaDurationSeconds(filePath) {
         "format=duration",
         "-of",
         "default=noprint_wrappers=1:nokey=1",
+        "--",
         filePath
       ],
       { encoding: "utf-8", timeout: 1e4 }
@@ -93644,7 +94643,7 @@ function isVideoFile(filePath) {
   return VIDEO_EXTENSIONS.has(extname5(filePath).toLowerCase());
 }
 function tempWavPath() {
-  return join21(tmpdir3(), `hyperframes-audio-${process.pid}-${randomUUID4()}.wav`);
+  return join21(tmpdir3(), `hyperframes-audio-${process.pid}-${randomUUID5()}.wav`);
 }
 function extractAudio(videoPath) {
   const ffmpegPath = findFFmpeg();
@@ -93670,7 +94669,7 @@ function isWav16kMono(filePath) {
     if (!ffprobePath) return false;
     const raw = execFileSync5(
       ffprobePath,
-      ["-v", "quiet", "-print_format", "json", "-show_streams", filePath],
+      ["-v", "quiet", "-print_format", "json", "-show_streams", "--", filePath],
       { encoding: "utf-8", timeout: 1e4 }
     );
     const parsed = JSON.parse(raw);
@@ -93802,7 +94801,7 @@ async function transcribe(inputPath, outputDir, options) {
   const speechOnsetSeconds = detectSpeechOnset(wavPath);
   if (wavPath !== inputPath) {
     try {
-      unlinkSync2(wavPath);
+      unlinkSync3(wavPath);
     } catch {
     }
   }
@@ -93872,7 +94871,7 @@ __export(normalize_exports, {
   stripBeforeOnset: () => stripBeforeOnset,
   wordsToCues: () => wordsToCues
 });
-import { readFileSync as readFileSync15, readdirSync as readdirSync8, writeFileSync as writeFileSync9 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { extname as extname6, join as join23 } from "path";
 function detectFormat(filePath) {
   const ext = extname6(filePath).toLowerCase();
@@ -94150,7 +95149,7 @@ function patchCaptionHtml(dir, words) {
   const wordsJson = JSON.stringify(words, null, 2).replace(/\n/g, "\n          ");
   let htmlFiles;
   try {
-    htmlFiles = readdirSync8(dir, { withFileTypes: true, recursive: true }).filter((e3) => e3.isFile() && e3.name.endsWith(".html")).map((e3) => join23(e3.parentPath, e3.name));
+    htmlFiles = readdirSync9(dir, { withFileTypes: true, recursive: true }).filter((e3) => e3.isFile() && e3.name.endsWith(".html")).map((e3) => join23(e3.parentPath, e3.name));
   } catch {
     return;
   }
@@ -94640,9 +95639,9 @@ import { execFile as execFile3 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import {
   existsSync as existsSync27,
-  readdirSync as readdirSync9,
+  readdirSync as readdirSync10,
   readFileSync as readFileSync18,
-  renameSync as renameSync6,
+  renameSync as renameSync5,
   statSync as statSync8,
   writeFileSync as writeFileSync11
 } from "fs";
@@ -94655,7 +95654,7 @@ function isCoreSkill(name) {
 function listFilesSorted(dir) {
   const out = [];
   const walk = (d2) => {
-    for (const name of readdirSync9(d2)) {
+    for (const name of readdirSync10(d2)) {
       if (name === ".DS_Store") continue;
       const p2 = join26(d2, name);
       if (statSync8(p2).isDirectory()) walk(p2);
@@ -94681,7 +95680,7 @@ function hashSkillBundle(skillDir) {
   return { hash: h3.digest("hex").slice(0, 16), files: files.length };
 }
 function buildManifest(skillsRoot, meta) {
-  const names = readdirSync9(skillsRoot).filter((n2) => existsSync27(join26(skillsRoot, n2, "SKILL.md"))).sort();
+  const names = readdirSync10(skillsRoot).filter((n2) => existsSync27(join26(skillsRoot, n2, "SKILL.md"))).sort();
   const skills = {};
   for (const name of names) skills[name] = hashSkillBundle(join26(skillsRoot, name));
   return { source: meta.source, skills };
@@ -94697,7 +95696,7 @@ function agentFromDir(dir) {
 }
 function listSubdirs(dir) {
   try {
-    return readdirSync9(dir, { withFileTypes: true }).filter((e3) => e3.isDirectory() || e3.isSymbolicLink()).map((e3) => e3.name);
+    return readdirSync10(dir, { withFileTypes: true }).filter((e3) => e3.isDirectory() || e3.isSymbolicLink()).map((e3) => e3.name);
   } catch {
     return [];
   }
@@ -94837,7 +95836,7 @@ function pruneOrphanedLockEntries(names, scope, opts = {}) {
   const mode = statSync8(path2).mode & 511;
   const tmp = `${path2}.tmp`;
   writeFileSync11(tmp, JSON.stringify(lock, null, 2), { mode });
-  renameSync6(tmp, path2);
+  renameSync5(tmp, path2);
   return pruned;
 }
 function findRepoManifest(cwd = process.cwd()) {
@@ -95053,7 +96052,7 @@ var init_agentDirs_generated = __esm({
 });
 
 // src/utils/skillsMirror.ts
-import { cpSync, existsSync as existsSync28, mkdirSync as mkdirSync13, readdirSync as readdirSync10, rmSync as rmSync7, symlinkSync } from "fs";
+import { cpSync, existsSync as existsSync28, mkdirSync as mkdirSync13, readdirSync as readdirSync11, rmSync as rmSync7, symlinkSync } from "fs";
 import { homedir as homedir7 } from "os";
 import { dirname as dirname11, isAbsolute as isAbsolute7, join as join27, relative as relative7 } from "path";
 function resolveBases(home, env) {
@@ -95069,7 +96068,7 @@ function resolveBases(home, env) {
   };
 }
 function listSkillDirs(store) {
-  return readdirSync10(store, { withFileTypes: true }).filter(
+  return readdirSync11(store, { withFileTypes: true }).filter(
     (e3) => (e3.isDirectory() || e3.isSymbolicLink()) && existsSync28(join27(store, e3.name, "SKILL.md"))
   ).map((e3) => e3.name);
 }
@@ -97981,7 +98980,7 @@ var init_chunk_W2SBTCO2 = __esm({
   }
 });
 
-// ../studio-server/dist/chunk-I2USK772.js
+// ../studio-server/dist/chunk-6H3V3WGJ.js
 import { existsSync as existsSync33, statSync as statSync10 } from "fs";
 import { relative as relative8, resolve as resolve19, sep as sep5 } from "path";
 import { execFile as execFile5 } from "child_process";
@@ -98048,6 +99047,7 @@ async function probeMediaMetadata(filePath, runner = execFileRunner) {
       "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample:stream_disposition=attached_pic",
       "-of",
       "json",
+      "--",
       filePath
     ],
     { timeout: 15e3, maxBuffer: 1024 * 1024 }
@@ -98184,8 +99184,8 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
   return map;
 }
 var execFileRunner, VIDEO_EXT, IMAGE_EXT, AUDIO_EXT, ALPHA_PIX_FMT_RE, BROWSER_HOSTILE_CODECS, PROXY_VARIANT_CONFIG, defaultProbeCache, MAX_PROBE_CACHE_ENTRIES, VIDEO_SRC_RE, PROBE_CONCURRENCY2;
-var init_chunk_I2USK772 = __esm({
-  "../studio-server/dist/chunk-I2USK772.js"() {
+var init_chunk_6H3V3WGJ = __esm({
+  "../studio-server/dist/chunk-6H3V3WGJ.js"() {
     "use strict";
     init_assets();
     init_assetResolution();
@@ -98244,20 +99244,20 @@ var init_chunk_I2USK772 = __esm({
   }
 });
 
-// ../studio-server/dist/chunk-IQAVZUQP.js
+// ../studio-server/dist/chunk-ZPI6QXJH.js
 import { spawn as spawn8 } from "child_process";
-import { createHash as createHash6, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
 import {
   existsSync as existsSync210,
   mkdirSync as mkdirSync15,
   realpathSync as realpathSync4,
-  renameSync as renameSync7,
+  renameSync as renameSync6,
   statSync as statSync22,
   unlinkSync as unlinkSync22,
   utimesSync as utimesSync2
 } from "fs";
 import { basename as basename4, dirname as dirname14, isAbsolute as isAbsolute8, join as join29, relative as relative9, resolve as resolve20, sep as sep6 } from "path";
-import { existsSync as existsSync34, readdirSync as readdirSync11, statSync as statSync11, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync34, readdirSync as readdirSync12, statSync as statSync11, unlinkSync as unlinkSync4 } from "fs";
 import { extname as extname8, join as join30 } from "path";
 function positiveEnvNumber(name, fallback) {
   const parsed = Number(process.env[name]);
@@ -98283,7 +99283,7 @@ function shouldSkipSweep(cacheDir, now, minSweepIntervalMs) {
 function readCacheInventory(cacheDir, protectedPaths, now, staleTempMs) {
   const entries2 = [];
   const staleTemps = [];
-  for (const dirent of readdirSync11(cacheDir, { withFileTypes: true })) {
+  for (const dirent of readdirSync12(cacheDir, { withFileTypes: true })) {
     if (!dirent.isFile()) continue;
     const path2 = join30(cacheDir, dirent.name);
     const stat3 = statSync11(path2);
@@ -98309,7 +99309,7 @@ function evictCacheEntries(entries2, staleTemps, now, maxIdleMs, maxBytes) {
   let bytesAfter = bytesBefore;
   const removed = [];
   const remove2 = (entry, countsTowardBudget) => {
-    unlinkSync3(entry.path);
+    unlinkSync4(entry.path);
     removed.push(entry.path);
     if (countsTowardBudget) bytesAfter -= entry.size;
   };
@@ -98570,10 +99570,10 @@ async function transcodeToCache(absoluteSourcePath, cachePath2, variant) {
     if (existsSync210(cachePath2)) return cachePath2;
     const cacheDir = dirname14(cachePath2);
     mkdirSync15(cacheDir, { recursive: true });
-    const tempPath = join29(cacheDir, `.tmp-${randomUUID5()}-${basename4(cachePath2)}`);
+    const tempPath = join29(cacheDir, `.tmp-${randomUUID6()}-${basename4(cachePath2)}`);
     try {
       await runFfmpeg2(absoluteSourcePath, tempPath, variant);
-      renameSync7(tempPath, cachePath2);
+      renameSync6(tempPath, cachePath2);
       maintainProxyCache(cacheDir);
       return cachePath2;
     } finally {
@@ -98610,10 +99610,10 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264") {
   return promise;
 }
 var DEFAULT_MAX_BYTES, DEFAULT_STALE_TEMP_MS, DEFAULT_MIN_SWEEP_INTERVAL_MS, PROXY_EXTENSIONS, lastSweepAt, PROXY_PARAMS_VERSION, CACHE_DIR_NAME, MAX_CONCURRENT_TRANSCODES, MAX_QUEUED_TRANSCODES, STDERR_TAIL_MAX_CHARS, TRANSCODE_TIMEOUT_MS, FAILURE_CACHE_TTL_MS, MAX_FAILURE_CACHE_ENTRIES, DEFAULT_PROXY_WAIT_TIMEOUT_MS, ProxyTranscodeError, FfmpegUnavailableError, FfmpegMissingFilterError, ProxyCapacityError, ProxySourceOutsideProjectError, ProxyWaitTimeoutError, activeTranscodes, waitQueue, inFlight, failedTranscodes, hdrFilterCheck;
-var init_chunk_IQAVZUQP = __esm({
-  "../studio-server/dist/chunk-IQAVZUQP.js"() {
+var init_chunk_ZPI6QXJH = __esm({
+  "../studio-server/dist/chunk-ZPI6QXJH.js"() {
     "use strict";
-    init_chunk_I2USK772();
+    init_chunk_6H3V3WGJ();
     init_ffBinaries();
     DEFAULT_MAX_BYTES = 10 * 1024 * 1024 * 1024;
     DEFAULT_STALE_TEMP_MS = 60 * 60 * 1e3;
@@ -98681,7 +99681,7 @@ var init_chunk_IQAVZUQP = __esm({
   }
 });
 
-// ../studio-server/dist/chunk-JOZUTP73.js
+// ../studio-server/dist/chunk-LHYV3WLZ.js
 import { resolve as resolve21 } from "path";
 function isAutoProxyEnabled(adapter2) {
   return adapter2.autoProxy !== false;
@@ -98728,11 +99728,11 @@ async function injectMediaCodecMap(html, adapter2, projectDir, compSrcPath, prob
   if (!isAutoProxyEnabled(adapter2)) return html;
   return injectMediaCodecMapIntoHtml(html, projectDir, [{ html, compSrcPath }], probeCache);
 }
-var init_chunk_JOZUTP73 = __esm({
-  "../studio-server/dist/chunk-JOZUTP73.js"() {
+var init_chunk_LHYV3WLZ = __esm({
+  "../studio-server/dist/chunk-LHYV3WLZ.js"() {
     "use strict";
-    init_chunk_IQAVZUQP();
-    init_chunk_I2USK772();
+    init_chunk_ZPI6QXJH();
+    init_chunk_6H3V3WGJ();
   }
 });
 
@@ -102421,7 +103421,7 @@ var init_gsapWriterAcorn = __esm({
 
 // ../core/dist/fonts/systemFontLocator.js
 import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync35, lstatSync as lstatSync3, readdirSync as readdirSync12, realpathSync as realpathSync5 } from "fs";
+import { existsSync as existsSync35, lstatSync as lstatSync3, readdirSync as readdirSync13, realpathSync as realpathSync5 } from "fs";
 import { homedir as homedir9, platform as platform5 } from "os";
 import { join as join31, resolve as resolve22 } from "path";
 function getAllowedFontDirs() {
@@ -102516,7 +103516,7 @@ function collectFontFileEntries(dir, depth = 0) {
     return [];
   const entries2 = [];
   try {
-    for (const entry of readdirSync12(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync13(dir, { withFileTypes: true })) {
       const fullPath = join31(dir, entry.name);
       if (entry.isDirectory()) {
         entries2.push(...collectFontFileEntries(fullPath, depth + 1));
@@ -105455,7 +106455,7 @@ import { Hono as Hono2 } from "hono";
 import { readFile as readFile2 } from "fs/promises";
 import { join as join210 } from "path";
 import { join as join32 } from "path";
-import { readdirSync as readdirSync13 } from "fs";
+import { readdirSync as readdirSync14 } from "fs";
 import { createHash as createHash7 } from "crypto";
 import { lstatSync as lstatSync4, readFileSync as readFileSync21, readdirSync as readdirSync22 } from "fs";
 import { extname as extname9, isAbsolute as isAbsolute9, relative as relative10, resolve as resolve23 } from "path";
@@ -105473,7 +106473,7 @@ import {
   unlinkSync as unlinkSync23,
   rmSync as rmSync22,
   statSync as statSync12,
-  renameSync as renameSync8,
+  renameSync as renameSync7,
   readdirSync as readdirSync42
 } from "fs";
 import { resolve as resolve32, dirname as dirname22, join as join62 } from "path";
@@ -105484,10 +106484,10 @@ import { spawnSync } from "child_process";
 import { mkdtempSync as mkdtempSync3, rmSync as rmSync9, writeFileSync as writeFileSync22 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { basename as basename5, join as join42 } from "path";
-import { mkdirSync as mkdirSync22, readdirSync as readdirSync32, readFileSync as readFileSync32, unlinkSync as unlinkSync4, writeFileSync as writeFileSync32 } from "fs";
+import { mkdirSync as mkdirSync22, readdirSync as readdirSync32, readFileSync as readFileSync32, unlinkSync as unlinkSync5, writeFileSync as writeFileSync32 } from "fs";
 import { Buffer as Buffer2 } from "buffer";
 import { join as join52, relative as relative22 } from "path";
-import { createHash as createHash22, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID7 } from "crypto";
 import { existsSync as existsSync37, readFileSync as readFileSync42, realpathSync as realpathSync6 } from "fs";
 import { randomUUID as randomUUID22 } from "crypto";
 import { dirname as dirname15, relative as relative32, resolve as resolve24, sep as sep7 } from "path";
@@ -105532,7 +106532,7 @@ function isInHiddenOrVendorDir(relPath) {
 }
 function walkDir(dir, prefix = "") {
   const files = [];
-  for (const entry of readdirSync13(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (IGNORE_DIRS.has(entry.name) || shouldIgnoreDir(rel)) continue;
     if (entry.isDirectory()) {
@@ -105838,6 +106838,7 @@ function validateUploadedMedia(filePath, runner = spawnSync) {
     "stream=codec_type",
     "-of",
     "json",
+    "--",
     filePath
   ]);
   if (result.error?.code === "ENOENT") {
@@ -105929,7 +106930,7 @@ function pruneBackups(backupDir, backupKey, keepPerFile) {
   });
   for (const file of matches2.slice(keep)) {
     try {
-      unlinkSync4(file);
+      unlinkSync5(file);
     } catch {
     }
   }
@@ -105939,7 +106940,7 @@ function fileContentVersion(content) {
 }
 function createWriteToken(requestToken) {
   const token = requestToken?.trim();
-  return token && token.length <= 200 ? token : randomUUID6();
+  return token && token.length <= 200 ? token : randomUUID7();
 }
 function recordFileWriteReceipt(absPath, receipt) {
   const now = Date.now();
@@ -108048,7 +109049,7 @@ function registerFileRoutes(api, adapter2) {
       return c3.json({ error: "already exists" }, 409);
     }
     ensureDir(newAbs);
-    renameSync8(res.absPath, newAbs);
+    renameSync7(res.absPath, newAbs);
     const updatedFiles = updateReferences(res.project.dir, res.filePath, body.newPath);
     return c3.json({ ok: true, path: body.newPath, updatedReferences: updatedFiles });
   });
@@ -109650,9 +110651,9 @@ var init_dist9 = __esm({
     init_chunk_X62ASOGO();
     init_chunk_VPA335OG();
     init_chunk_W2SBTCO2();
-    init_chunk_JOZUTP73();
-    init_chunk_IQAVZUQP();
-    init_chunk_I2USK772();
+    init_chunk_LHYV3WLZ();
+    init_chunk_ZPI6QXJH();
+    init_chunk_6H3V3WGJ();
     init_chunk_6XMC64FJ();
     init_chunk_4ETS2LXI();
     init_dist3();
@@ -110193,7 +111194,7 @@ __export(manager_exports2, {
   withInstallLock: () => withInstallLock
 });
 import { execSync as execSync4, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync38, mkdirSync as mkdirSync17, readdirSync as readdirSync14, rmSync as rmSync10, statSync as statSync13, utimesSync as utimesSync3 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync17, readdirSync as readdirSync15, rmSync as rmSync10, statSync as statSync13, utimesSync as utimesSync3 } from "fs";
 import { basename as basename6 } from "path";
 import { homedir as homedir11 } from "os";
 import { join as join35 } from "path";
@@ -110392,7 +111393,7 @@ function findFromPuppeteerCache() {
   if (!executable) return void 0;
   let versions;
   try {
-    versions = [...readdirSync14(PUPPETEER_CACHE_DIR)].sort(compareVersionDirsDescending);
+    versions = [...readdirSync15(PUPPETEER_CACHE_DIR)].sort(compareVersionDirsDescending);
   } catch {
     return void 0;
   }
@@ -111093,7 +112094,7 @@ var init_logger = __esm({
 // ../producer/src/services/fileServer.ts
 import { Hono as Hono3 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { existsSync as existsSync40, realpathSync as realpathSync7, statSync as statSync14, createReadStream as createReadStream2 } from "fs";
+import { existsSync as existsSync40, realpathSync as realpathSync7, statSync as statSync14, createReadStream as createReadStream3 } from "fs";
 import { readFile as readFile3 } from "fs/promises";
 import { Readable as Readable2 } from "stream";
 import { join as join36, extname as extname10, resolve as resolve27, sep as sep9 } from "path";
@@ -111490,7 +112491,7 @@ function createFileServer2(options) {
     if (rangeRequest.kind === "satisfiable") {
       const { start, end } = rangeRequest;
       const length = end - start + 1;
-      const stream2 = createReadStream2(filePath, { start, end });
+      const stream2 = createReadStream3(filePath, { start, end });
       const webStream2 = Readable2.toWeb(stream2);
       return new Response(webStream2, {
         status: 206,
@@ -111502,7 +112503,7 @@ function createFileServer2(options) {
         }
       });
     }
-    const stream = createReadStream2(filePath);
+    const stream = createReadStream3(filePath);
     const webStream = Readable2.toWeb(stream);
     return new Response(webStream, {
       status: 200,
@@ -112144,8 +113145,8 @@ import {
   mkdtempSync as mkdtempSync4,
   openSync as openSync5,
   readSync as readSync2,
-  readdirSync as readdirSync15,
-  renameSync as renameSync9,
+  readdirSync as readdirSync16,
+  renameSync as renameSync8,
   rmSync as rmSync12
 } from "fs";
 import { basename as basename9, dirname as dirname18, extname as extname11, join as join39, resolve as resolve29 } from "path";
@@ -112170,7 +113171,7 @@ function assertReadableNonEmptyFile(path2) {
 function collectDirectoryFiles(root) {
   const files = [];
   const visit = (directory) => {
-    for (const entry of readdirSync15(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync16(directory, { withFileTypes: true })) {
       const path2 = join39(directory, entry.name);
       if (entry.isDirectory()) visit(path2);
       else if (entry.isFile()) files.push(path2);
@@ -112185,7 +113186,7 @@ var init_artifactTransaction = __esm({
     "use strict";
     defaultFileSystem = {
       existsSync: existsSync43,
-      renameSync: renameSync9,
+      renameSync: renameSync8,
       rmSync: rmSync12
     };
     ArtifactTransaction = class {
@@ -113444,9 +114445,11 @@ var init_ffprobe2 = __esm({
 // ../producer/src/utils/urlDownloader.ts
 var urlDownloader_exports = {};
 __export(urlDownloader_exports, {
-  assertPublicHttpsUrl: () => assertPublicHttpsUrl,
   downloadToTemp: () => downloadToTemp,
-  isHttpUrl: () => isHttpUrl
+  fetchPublicHttpsText: () => fetchPublicHttpsText,
+  isHttpUrl: () => isHttpUrl,
+  safeDownloadUrlIdentity: () => safeDownloadUrlIdentity,
+  writeUrlDownloadTelemetry: () => writeUrlDownloadTelemetry
 });
 var init_urlDownloader2 = __esm({
   "../producer/src/utils/urlDownloader.ts"() {
@@ -116632,7 +117635,7 @@ __export(fontCompression_exports, {
   fontToDataUri: () => fontToDataUri
 });
 import { createHash as createHash10 } from "crypto";
-import { existsSync as existsSync44, mkdirSync as mkdirSync19, readFileSync as readFileSync26, renameSync as renameSync10, rmSync as rmSync13, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync44, mkdirSync as mkdirSync19, readFileSync as readFileSync26, renameSync as renameSync9, rmSync as rmSync13, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir12, tmpdir as tmpdir5 } from "os";
 import { dirname as dirname19, join as join41 } from "path";
 async function compressToWoff2(input2) {
@@ -116663,7 +117666,7 @@ function cacheCompression(path2, compressed) {
   try {
     mkdirSync19(dirname19(path2), { recursive: true });
     writeFileSync15(tmpPath, compressed, { flag: "wx", mode: 420 });
-    renameSync10(tmpPath, path2);
+    renameSync9(tmpPath, path2);
   } catch {
   } finally {
     try {
@@ -117488,7 +118491,7 @@ import {
   existsSync as existsSync46,
   mkdirSync as mkdirSync21,
   readFileSync as readFileSync28,
-  renameSync as renameSync11,
+  renameSync as renameSync10,
   rmSync as rmSync14,
   statSync as statSync15
 } from "fs";
@@ -117661,7 +118664,7 @@ async function ensurePreparedWebm(input2) {
         throw new Error("Animated GIF transcode produced an empty output");
       }
       if (!isUsableFile(input2.cachePath)) {
-        renameSync11(tmpPath, input2.cachePath);
+        renameSync10(tmpPath, input2.cachePath);
       } else {
         rmSync14(tmpPath, { force: true });
       }
@@ -117980,8 +118983,11 @@ var init_assetMediaType = __esm({
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { createReadStream as createReadStream3, existsSync as existsSync48, mkdirSync as mkdirSync23, readFileSync as readFileSync29 } from "fs";
+import { createReadStream as createReadStream4, existsSync as existsSync48, mkdirSync as mkdirSync23, readFileSync as readFileSync29 } from "fs";
 import { join as join45, dirname as dirname21, resolve as resolve31, basename as basename10 } from "path";
+function logRemoteDownloadTelemetry(event) {
+  defaultLogger.info("[Compiler] Remote asset download integrity", { ...event });
+}
 function parseSubCompHtmlForValidity(html) {
   return parseHTML(html).document;
 }
@@ -118141,7 +119147,9 @@ async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagNa
   if (isHttpUrl(src)) {
     if (!existsSync48(downloadDir)) mkdirSync23(downloadDir, { recursive: true });
     try {
-      filePath = await downloadToTemp(src, downloadDir);
+      filePath = await downloadToTemp(src, downloadDir, void 0, void 0, void 0, {
+        onTelemetry: logRemoteDownloadTelemetry
+      });
     } catch {
       return { duration: 0, resolvedPath: src };
     }
@@ -118669,12 +119677,17 @@ async function downloadAndRewriteUrls(urlSet, html, remoteDir, warnLabel, logLab
   await Promise.all(
     [...urlSet].map(async (url) => {
       try {
-        const localPath = await downloadToTemp(url, remoteDir);
+        const localPath = await downloadToTemp(url, remoteDir, void 0, void 0, void 0, {
+          onTelemetry: logRemoteDownloadTelemetry
+        });
         urlToLocal.set(url, localPath);
       } catch (err) {
-        defaultLogger.warn(
-          `[Compiler] ${warnLabel} ${url} \u2014 using original URL as fallback. ${err instanceof Error ? err.message : String(err)}`
-        );
+        const identity = safeDownloadUrlIdentity(url);
+        defaultLogger.warn(`[Compiler] ${warnLabel} \u2014 using original URL as fallback.`, {
+          urlFingerprint: identity.urlFingerprint,
+          host: identity.host,
+          error: err instanceof Error ? err.message : String(err)
+        });
       }
     })
   );
@@ -118705,7 +119718,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
     urlSet,
     html,
     join45(downloadDir, REMOTE_MEDIA_SUBDIR),
-    "Remote media download failed for",
+    "Remote media download failed",
     "Localized remote media source(s)"
   );
 }
@@ -118720,7 +119733,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
     urlSet,
     html,
     join45(downloadDir, REMOTE_MEDIA_SUBDIR),
-    "Remote image download failed for",
+    "Remote image download failed",
     "Localized remote image source(s)"
   );
 }
@@ -118735,7 +119748,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
     urlSet,
     html,
     join45(downloadDir, REMOTE_MEDIA_SUBDIR),
-    "Remote background-image download failed for",
+    "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
     // replaceAll; this handles the unquoted url(https://..) form.
@@ -118751,40 +119764,18 @@ function isGoogleFontsUrl(href) {
   }
 }
 async function fetchExternalStylesheetCss(href) {
+  const identity = safeDownloadUrlIdentity(href);
   try {
-    assertPublicHttpsUrl(href);
-  } catch {
-    return null;
-  }
-  try {
-    const response = await fetch(href, {
-      signal: AbortSignal.timeout(15e3)
+    return await fetchPublicHttpsText(href, {
+      maxBytes: MAX_STYLESHEET_BYTES,
+      timeoutMs: 15e3
     });
-    if (!response.ok) {
-      defaultLogger.warn(
-        `[Compiler] External stylesheet fetch failed for ${href} \u2014 HTTP ${response.status}`
-      );
-      return null;
-    }
-    const contentLength = response.headers.get("content-length");
-    if (contentLength && parseInt(contentLength, 10) > MAX_STYLESHEET_BYTES) {
-      defaultLogger.warn(
-        `[Compiler] External stylesheet too large (${contentLength} bytes): ${href}`
-      );
-      return null;
-    }
-    const text2 = await response.text();
-    if (text2.length > MAX_STYLESHEET_BYTES) {
-      defaultLogger.warn(
-        `[Compiler] External stylesheet too large (${text2.length} bytes): ${href}`
-      );
-      return null;
-    }
-    return text2;
   } catch (err) {
-    defaultLogger.warn(
-      `[Compiler] External stylesheet fetch failed for ${href} \u2014 ${err instanceof Error ? err.message : String(err)}`
-    );
+    defaultLogger.warn("[Compiler] External stylesheet fetch failed \u2014 preserving link tag.", {
+      urlFingerprint: identity.urlFingerprint,
+      host: identity.host,
+      error: err instanceof Error ? err.message : String(err)
+    });
     return null;
   }
 }
@@ -118840,13 +119831,16 @@ async function inlineExternalFontStylesheets(html) {
     if (css === null) continue;
     const fontFaceBlocks = extractFontFaceBlocks(css);
     if (fontFaceBlocks.length === 0) continue;
-    const inlineStyle = `<style>/* Inlined from ${href} */
+    const identity = safeDownloadUrlIdentity(href);
+    const inlineStyle = `<style>/* Inlined external font stylesheet */
 ${fontFaceBlocks.join("\n")}
 </style>`;
     result = result.replace(fullMatch, inlineStyle);
-    defaultLogger.info(
-      `[Compiler] Inlined ${fontFaceBlocks.length} @font-face rule(s) from external stylesheet: ${href}`
-    );
+    defaultLogger.info("[Compiler] Inlined external @font-face rule(s)", {
+      count: fontFaceBlocks.length,
+      urlFingerprint: identity.urlFingerprint,
+      host: identity.host
+    });
   }
   return result;
 }
@@ -118887,7 +119881,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
     urlSet,
     processed,
     join45(downloadDir, REMOTE_MEDIA_SUBDIR),
-    "Remote font download failed for",
+    "Remote font download failed",
     "Localized remote font face(s)",
     (h3, url, relPath) => h3.replaceAll(`url(${url})`, `url("${relPath}")`)
   );
@@ -118895,7 +119889,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
 async function readLocalFont(absPath) {
   const chunks = [];
   let totalBytes = 0;
-  for await (const chunk of createReadStream3(absPath)) {
+  for await (const chunk of createReadStream4(absPath)) {
     const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
     totalBytes += buffer.length;
     if (totalBytes > MAX_LOCAL_FONT_DATA_URI_BYTES) {
@@ -119799,9 +120793,9 @@ async function runProbeStage(input2) {
     if (probeSession.launchCaptureMode === "beginframe") {
       const probeTimeoutMs = Number(process.env.PRODUCER_BEGINFRAME_PROBE_TIMEOUT_MS) > 0 ? Number(process.env.PRODUCER_BEGINFRAME_PROBE_TIMEOUT_MS) : 3e4;
       const livenessStart = Date.now();
-      const probeTick = Math.max(
-        0,
-        probeSession.beginFrameTimeTicks - 5 * probeSession.beginFrameIntervalMs
+      const probeTick = deriveBeginFrameProbeTimeTicks(
+        probeSession.beginFrameTimeTicks,
+        probeSession.beginFrameIntervalMs
       );
       const alive = await probeBeginFrameLiveness(
         probeSession.page,
@@ -123319,7 +124313,7 @@ var init_gifEncodeArgs = __esm({
 });
 
 // ../producer/src/services/render/stages/encodeStage.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync53, mkdirSync as mkdirSync26, readdirSync as readdirSync16, rmSync as rmSync16, statSync as statSync16 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync53, mkdirSync as mkdirSync26, readdirSync as readdirSync17, rmSync as rmSync16, statSync as statSync16 } from "fs";
 import { dirname as dirname24, join as join59 } from "path";
 function resolveGifLoop(loop) {
   const resolved2 = loop ?? 0;
@@ -123330,7 +124324,7 @@ function resolveGifLoop(loop) {
 }
 async function encodeGifFromDir(framesDir, framePattern, outputPath, input2) {
   const startTime = Date.now();
-  const files = readdirSync16(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
+  const files = readdirSync17(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
     return {
@@ -123419,7 +124413,7 @@ async function runEncodeStage(input2) {
   if (isPngSequence) {
     updateJobStatus(job, "encoding", "Writing PNG sequence", 75, onProgress);
     if (!existsSync53(outputPath)) mkdirSync26(outputPath, { recursive: true });
-    const captured = readdirSync16(framesDir).filter((name) => name.endsWith(".png")).sort();
+    const captured = readdirSync17(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
         `[Render] png-sequence output requested but no PNGs were captured to ${framesDir}`
@@ -123582,6 +124576,10 @@ function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, tar
 function formatSeconds(sec) {
   return sec.toFixed(6);
 }
+function sanitizeProbeFailure(reason, paths) {
+  const message = reason instanceof Error ? reason.message : String(reason);
+  return redactTelemetryString(redactKnownPaths(message, paths));
+}
 async function padOrTrimAudioToVideoFrameCount(input2) {
   const probeVideo2 = input2.probeVideoFrameInfo ?? ((videoPath) => defaultProbeVideoFrameInfo(videoPath, input2.signal));
   const probeAudio = input2.probeAudioInfo ?? defaultProbeAudioInfo;
@@ -123590,12 +124588,16 @@ async function padOrTrimAudioToVideoFrameCount(input2) {
     probeVideo2(input2.videoPath),
     probeAudio(input2.audioPath, input2.signal)
   ]);
+  const probePaths = [input2.videoPath, input2.audioPath, input2.outputPath];
   if (videoResult.status === "rejected") {
     return failResult(
       input2.outputPath,
       0,
       audioResult.status === "fulfilled" ? audioResult.value.durationSeconds : 0,
-      `audioPadTrim: failed to probe video: ${videoResult.reason.message}`
+      `audioPadTrim: failed to probe video: ${sanitizeProbeFailure(
+        videoResult.reason,
+        probePaths
+      )}`
     );
   }
   if (audioResult.status === "rejected") {
@@ -123603,7 +124605,10 @@ async function padOrTrimAudioToVideoFrameCount(input2) {
       input2.outputPath,
       0,
       0,
-      `audioPadTrim: failed to probe audio: ${audioResult.reason.message}`
+      `audioPadTrim: failed to probe audio: ${sanitizeProbeFailure(
+        audioResult.reason,
+        probePaths
+      )}`
     );
   }
   const videoInfo = videoResult.value;
@@ -123678,6 +124683,7 @@ async function defaultProbeVideoFrameInfo(videoPath, signal) {
       "stream=nb_frames,r_frame_rate",
       "-of",
       "json",
+      "--",
       videoPath
     ],
     signal
@@ -123698,6 +124704,7 @@ async function defaultProbeVideoFrameInfo(videoPath, signal) {
       "stream=nb_read_packets,r_frame_rate",
       "-of",
       "json",
+      "--",
       videoPath
     ],
     signal
@@ -123737,7 +124744,10 @@ async function defaultRunFfmpeg(args, signal) {
   };
 }
 async function runFfprobeJson(args, signal) {
-  const proc = spawn11(getFfprobeBinary(), args);
+  if (!args.includes("--")) {
+    throw new Error('[audioPadTrim] ffprobe args must terminate options with "--".');
+  }
+  const proc = spawn11(getFfprobeBinary(), args, { stdio: ["ignore", "pipe", "pipe"] });
   trackChildProcess(proc);
   let stdout2 = "";
   proc.stdout.on("data", (data2) => {
@@ -123755,7 +124765,9 @@ async function runFfprobeJson(args, signal) {
     throw outcome.error ?? new Error(outcome.stderr);
   }
   if (outcome.reason !== "exit" || outcome.exitCode !== 0) {
-    throw new Error(`ffprobe ${outcome.reason}: ${outcome.stderr}`);
+    const probed = args[args.length - 1];
+    const scrubbed = redactKnownPaths(outcome.stderr, probed === void 0 ? [] : [probed]);
+    throw new Error(`ffprobe ${outcome.reason}: ${redactTelemetryString(scrubbed, 2e3)}`);
   }
   try {
     return JSON.parse(stdout2);
@@ -123768,6 +124780,7 @@ var init_audioPadTrim = __esm({
   "../producer/src/services/render/audioPadTrim.ts"() {
     "use strict";
     init_src();
+    init_dist3();
     AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
   }
 });
@@ -123845,7 +124858,7 @@ import {
   mkdirSync as mkdirSync27,
   mkdtempSync as mkdtempSync7,
   readFileSync as readFileSync31,
-  readdirSync as readdirSync17,
+  readdirSync as readdirSync18,
   rmSync as rmSync18,
   statSync as statSync17,
   writeFileSync as writeFileSync17,
@@ -123855,7 +124868,7 @@ import {
 import { tmpdir as tmpdir8 } from "os";
 import { join as join60, dirname as dirname25, resolve as resolve33 } from "path";
 import { totalmem as totalmem2 } from "os";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function sampleDirectoryBytes(dir) {
   let total = 0;
@@ -123865,7 +124878,7 @@ function sampleDirectoryBytes(dir) {
     if (!current2) continue;
     let entries2 = [];
     try {
-      entries2 = readdirSync17(current2);
+      entries2 = readdirSync18(current2);
     } catch {
       continue;
     }
@@ -124214,7 +125227,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
 }
 function createRenderJob(config) {
   return {
-    id: randomUUID7(),
+    id: randomUUID8(),
     config: {
       ...config,
       fps: toFps(config.fps),
@@ -126607,7 +127620,7 @@ import {
   mkdtempSync as mkdtempSync8,
   writeFileSync as writeFileSync18,
   rmSync as rmSync19,
-  createReadStream as createReadStream4
+  createReadStream as createReadStream5
 } from "fs";
 import { resolve as resolve35, dirname as dirname27, join as join64 } from "path";
 import { tmpdir as tmpdir9 } from "os";
@@ -127166,7 +128179,7 @@ function createRenderHandlers(options = {}) {
       return c3.json({ success: false, error: "Output artifact file missing" }, 404);
     }
     const stats = statSync19(artifact.path);
-    return new Response(createReadStream4(artifact.path), {
+    return new Response(createReadStream5(artifact.path), {
       headers: {
         "content-type": "video/mp4",
         "content-length": String(stats.size),
@@ -127437,7 +128450,7 @@ var init_planHash = __esm({
 });
 
 // ../producer/src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync58, mkdirSync as mkdirSync29, readFileSync as readFileSync34, readdirSync as readdirSync18, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync58, mkdirSync as mkdirSync29, readFileSync as readFileSync34, readdirSync as readdirSync19, writeFileSync as writeFileSync19 } from "fs";
 import { join as join65, relative as relative12, resolve as resolve36 } from "path";
 function stripUndefined(value) {
   if (Array.isArray(value)) return value.map(stripUndefined);
@@ -127457,7 +128470,7 @@ function listPlanFiles(planDir) {
   const results = [];
   const rootResolved = resolve36(planDir);
   function walk(dir) {
-    const entries2 = readdirSync18(dir, { withFileTypes: true });
+    const entries2 = readdirSync19(dir, { withFileTypes: true });
     for (const entry of entries2) {
       const full2 = join65(dir, entry.name);
       if (entry.isDirectory()) {
@@ -127868,7 +128881,7 @@ var init_shared2 = __esm({
 
 // ../producer/src/services/distributed/planSize.ts
 import { createHash as createHash15 } from "crypto";
-import { lstatSync as lstatSync5, readdirSync as readdirSync19 } from "fs";
+import { lstatSync as lstatSync5, readdirSync as readdirSync20 } from "fs";
 import { extname as extname13, join as join67, relative as relative13 } from "path";
 function hashComponent(value) {
   return createHash15("sha256").update(value).digest("hex").slice(0, 12);
@@ -127950,7 +128963,7 @@ function recordFile(result, components, rootDir, rootKind, filePath) {
 function walkRegularFiles(dir, visit) {
   let entries2;
   try {
-    entries2 = readdirSync19(dir, { withFileTypes: true });
+    entries2 = readdirSync20(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -128007,7 +129020,7 @@ var init_planSize = __esm({
 });
 
 // ../producer/src/services/distributed/plan.ts
-import { cpSync as cpSync3, existsSync as existsSync60, mkdirSync as mkdirSync30, renameSync as renameSync12, rmSync as rmSync20, writeFileSync as writeFileSync20 } from "fs";
+import { cpSync as cpSync3, existsSync as existsSync60, mkdirSync as mkdirSync30, renameSync as renameSync11, rmSync as rmSync20, writeFileSync as writeFileSync20 } from "fs";
 import { join as join68, relative as relative14, sep as sep10 } from "path";
 function applyDistributedAudioWarningPolicy(job, audioError, audioFailures = [], log2 = defaultLogger) {
   const failureOwner = audioFailures.length === 0 ? void 0 : audioFailures.some((failure) => failure.owner === "system") ? "system" : "user";
@@ -128357,12 +129370,12 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   const videoFramesDst = join68(planDir, "video-frames");
   if (existsSync60(videoFramesDst)) rmSync20(videoFramesDst, { recursive: true, force: true });
   if (existsSync60(stagedVideoFrames)) {
-    renameSync12(stagedVideoFrames, videoFramesDst);
+    renameSync11(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync30(videoFramesDst, { recursive: true });
   }
   if (existsSync60(finalCompiledDir)) rmSync20(finalCompiledDir, { recursive: true, force: true });
-  renameSync12(compiledDir, finalCompiledDir);
+  renameSync11(compiledDir, finalCompiledDir);
   const planVideosJson = buildPlanVideosJson({
     videos: composition.videos,
     compositionEnd: job.duration ?? Number.NaN,
@@ -128383,7 +129396,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   );
   const planAudioPath = join68(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult.hasAudio && existsSync60(audioResult.audioOutputPath)) {
-    renameSync12(audioResult.audioOutputPath, planAudioPath);
+    renameSync11(audioResult.audioOutputPath, planAudioPath);
   }
   const maxParallel = config.maxParallelChunks ?? DEFAULT_MAX_PARALLEL_CHUNKS;
   const { chunkCount, effectiveChunkSize } = resolveChunkPlan(
@@ -128609,10 +129622,10 @@ var init_planV2Layout = __esm({
 import {
   copyFileSync as copyFileSync7,
   existsSync as existsSync61,
-  linkSync as linkSync2,
+  linkSync as linkSync3,
   mkdirSync as mkdirSync31,
   mkdtempSync as mkdtempSync9,
-  renameSync as renameSync13,
+  renameSync as renameSync12,
   rmSync as rmSync21,
   statSync as statSync20,
   writeFileSync as writeFileSync21
@@ -128659,7 +129672,7 @@ var init_planV2Publisher = __esm({
           throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
         }
         this.destinationDir = destinationDir;
-        this.#linkFile = options.linkFile ?? linkSync2;
+        this.#linkFile = options.linkFile ?? linkSync3;
         mkdirSync31(dirname29(destinationDir), { recursive: true });
         this.temporaryDir = mkdtempSync9(join70(dirname29(destinationDir), ".plan-v2-publish-"));
       }
@@ -128683,7 +129696,7 @@ var init_planV2Publisher = __esm({
             if (!canFallbackToCopy(error)) throw error;
             copyFileSync7(blob.sourcePath, temporaryPath);
           }
-          renameSync13(temporaryPath, destinationPath);
+          renameSync12(temporaryPath, destinationPath);
         } finally {
           rmSync21(stagingDir, { recursive: true, force: true });
         }
@@ -128697,7 +129710,7 @@ var init_planV2Publisher = __esm({
           }
         }
         writeFileSync21(join70(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
-        renameSync13(this.temporaryDir, this.destinationDir);
+        renameSync12(this.temporaryDir, this.destinationDir);
         this.#committed = true;
       }
       async abort() {
@@ -128720,8 +129733,8 @@ import {
   openSync as openSync7,
   readFileSync as readFileSync36,
   readSync as readSync4,
-  readdirSync as readdirSync20,
-  renameSync as renameSync14,
+  readdirSync as readdirSync21,
+  renameSync as renameSync13,
   rmSync as rmSync23,
   statSync as statSync21,
   writeFileSync as writeFileSync23
@@ -128758,7 +129771,7 @@ function listFiles(root) {
   const files = [];
   const rootResolved = resolve37(root);
   function walk(dir) {
-    for (const entry of readdirSync20(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync21(dir, { withFileTypes: true })) {
       const absolutePath = join71(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
@@ -128803,10 +129816,10 @@ function assertValidExtractionCacheCompleteSentinel(path2) {
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
   const videoRoot = join71(executionPlanDir, "video-frames");
   if (!existsSync63(videoRoot)) return;
-  for (const videoEntry of readdirSync20(videoRoot, { withFileTypes: true })) {
+  for (const videoEntry of readdirSync21(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
     const videoDir = join71(videoRoot, videoEntry.name);
-    if (readdirSync20(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
+    if (readdirSync21(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
       const sentinelPath = join71(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
@@ -128843,7 +129856,7 @@ function artifactTargets(path2, videoDependencies) {
 function listVideoFramePaths(executionPlanDir, videos) {
   return videos.extracted.map((video) => {
     const outputDir = resolveExtractedVideoOutputDir(executionPlanDir, video.videoId);
-    const frameNames = readdirSync20(outputDir).sort();
+    const frameNames = readdirSync21(outputDir).sort();
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
@@ -128964,7 +129977,7 @@ function writeBlob(sourcePath, destinationPath) {
   const temporaryPath = join71(temporaryDir, "blob");
   try {
     copyFileSync8(sourcePath, temporaryPath);
-    renameSync14(temporaryPath, destinationPath);
+    renameSync13(temporaryPath, destinationPath);
   } finally {
     rmSync23(temporaryDir, { recursive: true, force: true });
   }
@@ -129056,7 +130069,7 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
-    renameSync14(tempDir, planV2Dir);
+    renameSync13(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
     rmSync23(tempDir, { recursive: true, force: true });
@@ -129310,7 +130323,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir) {
       canonicalJsonStringify({ manifest, target }),
       "utf-8"
     );
-    renameSync14(tempDir, destinationDir);
+    renameSync13(tempDir, destinationDir);
   } catch (error) {
     rmSync23(tempDir, { recursive: true, force: true });
     throw error;
@@ -129378,7 +130391,7 @@ import {
   existsSync as existsSync64,
   mkdirSync as mkdirSync34,
   readFileSync as readFileSync37,
-  readdirSync as readdirSync21,
+  readdirSync as readdirSync23,
   rmSync as rmSync24,
   statSync as statSync24,
   writeFileSync as writeFileSync24
@@ -129589,7 +130602,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
         `[assemble] png-sequence chunk must be a directory: ${chunkDir} (got a file)`
       );
     }
-    const frames = readdirSync21(chunkDir).filter((name) => name.endsWith(".png")).sort();
+    const frames = readdirSync23(chunkDir).filter((name) => name.endsWith(".png")).sort();
     if (frames.length === 0) {
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
@@ -129609,7 +130622,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
     cpSync4(audioPath, sidecar);
   }
   let fileSize = 0;
-  for (const name of readdirSync21(outputPath)) {
+  for (const name of readdirSync23(outputPath)) {
     try {
       fileSize += statSync24(join73(outputPath, name)).size;
     } catch {
@@ -129637,7 +130650,7 @@ var init_assemble = __esm({
 
 // ../producer/src/services/distributed/renderChunk.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync65, mkdirSync as mkdirSync35, readFileSync as readFileSync38, readdirSync as readdirSync23, rmSync as rmSync25, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync65, mkdirSync as mkdirSync35, readFileSync as readFileSync38, readdirSync as readdirSync24, rmSync as rmSync25, writeFileSync as writeFileSync25 } from "fs";
 import { extname as extname14, join as join74 } from "path";
 function validatePlanVideosForChunk(value) {
   try {
@@ -129691,7 +130704,10 @@ async function runCaptureWithScreenshotFallback(input2) {
 async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBeginFrameLiveness) {
   if (session.launchCaptureMode !== "beginframe") return false;
   const timeoutMs = Number(process.env.PRODUCER_BEGINFRAME_PROBE_TIMEOUT_MS) > 0 ? Number(process.env.PRODUCER_BEGINFRAME_PROBE_TIMEOUT_MS) : 3e4;
-  const probeTick = Math.max(0, session.beginFrameTimeTicks - 5 * session.beginFrameIntervalMs);
+  const probeTick = deriveBeginFrameProbeTimeTicks(
+    session.beginFrameTimeTicks,
+    session.beginFrameIntervalMs
+  );
   return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
@@ -129704,7 +130720,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
       );
     }
     const ext = (extname14(v2.framePattern) || ".jpg").toLowerCase();
-    const frames = readdirSync23(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort();
+    const frames = readdirSync24(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort();
     const framePaths = /* @__PURE__ */ new Map();
     for (let i2 = 0; i2 < frames.length; i2++) {
       const frameName = frames[i2];
@@ -129734,7 +130750,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
 }
 function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync38(outputPath));
-  const entries2 = readdirSync23(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
+  const entries2 = readdirSync24(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries2.map(
     (name) => `${name}\0${sha256Hex(readFileSync38(join74(outputPath, name)))}`
   );
@@ -130259,7 +131275,7 @@ var init_planV2Execution = __esm({
 });
 
 // ../producer/src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync24, readFileSync as readFileSync39 } from "fs";
+import { readdirSync as readdirSync25, readFileSync as readFileSync39 } from "fs";
 import { createHash as createHash17 } from "crypto";
 import { join as join76, relative as relative16 } from "path";
 var init_projectHash = __esm({
@@ -130961,7 +131977,7 @@ __export(studioServer_exports, {
 });
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE4 } from "hono/streaming";
-import { existsSync as existsSync67, readFileSync as readFileSync40, writeFileSync as writeFileSync26, statSync as statSync25, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync40, writeFileSync as writeFileSync26, statSync as statSync25, unlinkSync as unlinkSync6 } from "fs";
 import { resolve as resolve38, join as join78, basename as basename11 } from "path";
 async function loadStudioProducer() {
   return isDevMode() ? await Promise.resolve().then(() => (init_src2(), src_exports2)) : await Promise.resolve().then(() => (init_src2(), src_exports2));
@@ -131200,7 +132216,7 @@ function createStudioServer(options) {
     async transformPreviewHtml({ html, project: project2 }) {
       const { injectDeterministicFontFaces: injectDeterministicFontFaces2 } = await Promise.resolve().then(() => (init_deterministicFonts(), deterministicFonts_exports));
       const { prepareAnimatedGifInputs: prepareAnimatedGifInputs2 } = await Promise.resolve().then(() => (init_animatedGifPrep(), animatedGifPrep_exports));
-      const { downloadToTemp: downloadToTemp2 } = await Promise.resolve().then(() => (init_urlDownloader2(), urlDownloader_exports));
+      const { downloadToTemp: downloadToTemp2, writeUrlDownloadTelemetry: writeUrlDownloadTelemetry2 } = await Promise.resolve().then(() => (init_urlDownloader2(), urlDownloader_exports));
       const gifOutputDir = join78(project2.dir, ".hyperframes", "prepared-assets", "gif");
       const gifDownloadDir = join78(project2.dir, ".hyperframes", "prepared-assets", "downloads");
       const prepared = await prepareAnimatedGifInputs2(html, {
@@ -131209,7 +132225,13 @@ function createStudioServer(options) {
         outputDir: gifOutputDir,
         outputSrcPrefix: ".hyperframes/prepared-assets/gif",
         cacheDir: gifOutputDir,
-        sourceAssets: await downloadRemoteGifImageSources(html, gifDownloadDir, downloadToTemp2)
+        sourceAssets: await downloadRemoteGifImageSources(
+          html,
+          gifDownloadDir,
+          (url, destDir) => downloadToTemp2(url, destDir, void 0, void 0, void 0, {
+            onTelemetry: writeUrlDownloadTelemetry2
+          })
+        )
       });
       return injectDeterministicFontFaces2(prepared.html);
     },
@@ -131242,7 +132264,7 @@ function createStudioServer(options) {
           for (const suffix of ["", ".meta.json"]) {
             const fp = suffix ? opts.outputPath.replace(/\.(mp4|webm|mov)$/, suffix) : opts.outputPath;
             try {
-              if (existsSync67(fp)) unlinkSync5(fp);
+              if (existsSync67(fp)) unlinkSync6(fp);
             } catch {
             }
           }
@@ -131621,7 +132643,7 @@ import {
   readFileSync as readFileSync41,
   readlinkSync,
   symlinkSync as symlinkSync3,
-  unlinkSync as unlinkSync6
+  unlinkSync as unlinkSync7
 } from "fs";
 import { resolve as resolve39, dirname as dirname33, basename as basename12, join as join79 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
@@ -131955,7 +132977,7 @@ function linkProjectIntoStudioData(dir, projectsDir, projectName) {
       try {
         const stat3 = lstatSync7(symlinkPath);
         if (stat3.isSymbolicLink() && resolve39(readlinkSync(symlinkPath)) !== resolve39(dir)) {
-          unlinkSync6(symlinkPath);
+          unlinkSync7(symlinkPath);
         }
       } catch {
       }
@@ -131971,7 +132993,7 @@ function removeSymlinkOnExit(createdSymlink, symlinkPath) {
   if (!createdSymlink) return;
   process.on("exit", () => {
     try {
-      if (existsSync68(symlinkPath)) unlinkSync6(symlinkPath);
+      if (existsSync68(symlinkPath)) unlinkSync7(symlinkPath);
     } catch {
     }
   });
@@ -132541,7 +133563,7 @@ import {
   cpSync as cpSync5,
   writeFileSync as writeFileSync27,
   readFileSync as readFileSync43,
-  readdirSync as readdirSync25
+  readdirSync as readdirSync26
 } from "fs";
 import { resolve as resolve40, basename as basename13, join as join80, dirname as dirname34 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
@@ -132561,7 +133583,7 @@ function probeVideo(filePath) {
     if (!ffprobePath) return void 0;
     const raw = execFileSync8(
       ffprobePath,
-      ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", filePath],
+      ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", "--", filePath],
       { encoding: "utf-8", timeout: 15e3 }
     );
     const parsed = JSON.parse(raw);
@@ -132692,7 +133714,7 @@ function listHtmlFiles(dir) {
   const files = [];
   const ignoredDirs = /* @__PURE__ */ new Set([".git", "dist", "node_modules"]);
   function walk(currentDir) {
-    for (const entry of readdirSync25(currentDir, { withFileTypes: true })) {
+    for (const entry of readdirSync26(currentDir, { withFileTypes: true })) {
       const entryPath = join80(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoredDirs.has(entry.name)) walk(entryPath);
@@ -132738,7 +133760,7 @@ function writeTailwindSupport(destDir) {
   }
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
-  const htmlFiles = readdirSync25(dir, { withFileTypes: true, recursive: true }).filter((e3) => e3.isFile() && e3.name.endsWith(".html")).map((e3) => join80(e3.parentPath, e3.name));
+  const htmlFiles = readdirSync26(dir, { withFileTypes: true, recursive: true }).filter((e3) => e3.isFile() && e3.name.endsWith(".html")).map((e3) => join80(e3.parentPath, e3.name));
   for (const file of htmlFiles) {
     let content = readFileSync43(file, "utf-8");
     if (videoFilename) {
@@ -132926,7 +133948,7 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
   writeDefaultPackageJson(destDir, name);
   const sharedDir = getSharedTemplateDir();
   if (existsSync69(sharedDir)) {
-    for (const entry of readdirSync25(sharedDir, { withFileTypes: true })) {
+    for (const entry of readdirSync26(sharedDir, { withFileTypes: true })) {
       const src = join80(sharedDir, entry.name);
       const dest = resolve40(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
@@ -133145,7 +134167,7 @@ var init_init = __esm({
           const templateId2 = exampleFlag ?? "blank";
           const name2 = args.name ?? "my-video";
           const destDir2 = resolve40(name2);
-          if (existsSync69(destDir2) && readdirSync25(destDir2).length > 0) {
+          if (existsSync69(destDir2) && readdirSync26(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             failCommand();
           }
@@ -133226,7 +134248,7 @@ var init_init = __esm({
             await patchTranscript(destDir2, transcriptFile2);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
-          for (const f3 of readdirSync25(destDir2).filter((f4) => !f4.startsWith("."))) {
+          for (const f3 of readdirSync26(destDir2).filter((f4) => !f4.startsWith("."))) {
             console.log(`  ${c.accent(f3)}`);
           }
           if (!skipSkills) {
@@ -133286,7 +134308,7 @@ var init_init = __esm({
           name = nameResult;
         }
         const destDir = resolve40(name);
-        if (existsSync69(destDir) && readdirSync25(destDir).length > 0) {
+        if (existsSync69(destDir) && readdirSync26(destDir).length > 0) {
           const overwrite = await ue({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -133418,7 +134440,7 @@ ${c.dim("Use --example blank for offline use.")}`
         if (existsSync69(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
-        const files = readdirSync25(destDir);
+        const files = readdirSync26(destDir);
         Se(files.map((f3) => c.accent(f3)).join("\n"), c.success(`Created ${name}/`));
         if (!skipSkills) {
           await keepSkillsCurrent(destDir);
@@ -133882,14 +134904,14 @@ var init_catalog = __esm({
 var init_mediaProxyPreview = __esm({
   "../studio-server/dist/helpers/mediaProxyPreview.js"() {
     "use strict";
-    init_chunk_JOZUTP73();
-    init_chunk_IQAVZUQP();
-    init_chunk_I2USK772();
+    init_chunk_LHYV3WLZ();
+    init_chunk_ZPI6QXJH();
+    init_chunk_6H3V3WGJ();
   }
 });
 
 // src/utils/compositionServer.ts
-import { createReadStream as createReadStream5, existsSync as existsSync71, statSync as statSync26 } from "fs";
+import { createReadStream as createReadStream6, existsSync as existsSync71, statSync as statSync26 } from "fs";
 import { resolve as resolve44, dirname as dirname35 } from "path";
 import { Readable as Readable3 } from "stream";
 import { fileURLToPath as fileURLToPath10 } from "url";
@@ -133937,7 +134959,7 @@ function buildRangeResponse(filePath, contentType, rangeHeader) {
   const size = statSync26(filePath).size;
   const last = size - 1;
   const match = rangeHeader ? /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim()) : null;
-  const body = (start2, end2) => size === 0 ? null : Readable3.toWeb(createReadStream5(filePath, { start: start2, end: end2 }));
+  const body = (start2, end2) => size === 0 ? null : Readable3.toWeb(createReadStream6(filePath, { start: start2, end: end2 }));
   if (!match) {
     return new Response(body(0, last), {
       status: 200,
@@ -134004,8 +135026,8 @@ var init_compositionServer = __esm({
 var init_proxyTranscoder = __esm({
   "../studio-server/dist/helpers/proxyTranscoder.js"() {
     "use strict";
-    init_chunk_IQAVZUQP();
-    init_chunk_I2USK772();
+    init_chunk_ZPI6QXJH();
+    init_chunk_6H3V3WGJ();
   }
 });
 
@@ -134013,7 +135035,7 @@ var init_proxyTranscoder = __esm({
 var init_mediaCodecMap = __esm({
   "../studio-server/dist/helpers/mediaCodecMap.js"() {
     "use strict";
-    init_chunk_I2USK772();
+    init_chunk_6H3V3WGJ();
   }
 });
 
@@ -134576,7 +135598,7 @@ var init_present = __esm({
 function isAuthError(err) {
   return err instanceof AuthError;
 }
-var AuthError, ErrNotConfigured, ErrInvalidStore, ErrUnauthenticated, ErrApi, ErrOAuthNotConfigured, ErrRefreshFailed;
+var AuthError, ErrNotConfigured, ErrInvalidStore, ErrUnauthenticated, ErrApi, ErrOAuthNotConfigured, ErrRefreshFailed, ErrDeviceAuthFailed;
 var init_errors = __esm({
   "src/auth/errors.ts"() {
     "use strict";
@@ -134616,6 +135638,11 @@ var init_errors = __esm({
       detail ? `Failed to refresh OAuth tokens: ${detail}` : "Failed to refresh OAuth tokens",
       "Run `hyperframes auth login` to re-authenticate."
     );
+    ErrDeviceAuthFailed = (detail) => new AuthError(
+      "DEVICE_AUTH_FAILED",
+      `Device authorization failed: ${detail}`,
+      "Run `hyperframes auth login --device` to start a new code."
+    );
   }
 });
 
@@ -135325,6 +136352,9 @@ function tokenEndpoint() {
 function revokeEndpoint() {
   return process.env["HYPERFRAMES_OAUTH_REVOKE_URL"] || DEFAULT_REVOKE_URL;
 }
+function deviceAuthorizationEndpoint() {
+  return process.env["HYPERFRAMES_OAUTH_DEVICE_URL"] || DEFAULT_DEVICE_AUTHORIZATION_URL;
+}
 function resolveClientId() {
   const override = process.env["HYPERFRAMES_OAUTH_CLIENT_ID"];
   const id = override && override.length > 0 ? override : DEFAULT_CLIENT_ID;
@@ -135380,6 +136410,127 @@ async function startAuthorizationCodeFlow(opts = {}) {
   await persistOAuth(tokens, { preserveMissing: false });
   return { tokens };
 }
+async function startDeviceAuthorizationFlow(opts = {}) {
+  const runtime = {
+    clientId: resolveClientId(),
+    fetchImpl: opts.fetchImpl ?? fetch,
+    sleepImpl: opts.sleepImpl ?? ((ms) => new Promise((resolve77) => setTimeout(resolve77, ms))),
+    now: opts.now ?? Date.now,
+    requestTimeoutMs: opts.requestTimeoutMs ?? DEVICE_REQUEST_TIMEOUT_MS
+  };
+  const issuance = await requestDeviceAuthorization(runtime, opts.scope ?? DEFAULT_SCOPES);
+  await opts.onChallenge?.({
+    userCode: issuance.userCode,
+    verificationUri: issuance.verificationUri,
+    ...issuance.verificationUriComplete ? { verificationUriComplete: issuance.verificationUriComplete } : {}
+  });
+  return await pollDeviceToken(runtime, issuance);
+}
+async function requestDeviceAuthorization(runtime, scope) {
+  return await withDeviceRequestTimeout(
+    runtime,
+    "could not reach the authorization server",
+    async (signal) => {
+      const response = await runtime.fetchImpl(deviceAuthorizationEndpoint(), {
+        method: "POST",
+        headers: {
+          "content-type": "application/x-www-form-urlencoded",
+          accept: "application/json"
+        },
+        body: new URLSearchParams({ client_id: runtime.clientId, scope }).toString(),
+        signal
+      });
+      if (!response.ok) {
+        throw ErrDeviceAuthFailed(`authorization server returned HTTP ${response.status}`);
+      }
+      return parseDeviceAuthorizationResponse(await readJsonOrDeviceError(response));
+    }
+  );
+}
+async function pollDeviceToken(runtime, issuance) {
+  const deadline = runtime.now() + Math.min(issuance.expiresIn, MAX_DEVICE_FLOW_SECONDS) * 1e3;
+  let intervalSeconds = issuance.interval;
+  while (runtime.now() < deadline) {
+    const remainingMs = deadline - runtime.now();
+    if (remainingMs <= 0) break;
+    await runtime.sleepImpl(Math.min(intervalSeconds * 1e3, remainingMs));
+    const result = await requestDeviceToken(runtime, issuance.deviceCode);
+    if (result.tokens) return result.tokens;
+    if (result.slowDown) {
+      intervalSeconds = Math.min(
+        Math.max(intervalSeconds + 5, result.retryAfterSeconds ?? 0),
+        MAX_DEVICE_POLL_SECONDS
+      );
+    }
+  }
+  throw ErrDeviceAuthFailed("the code expired");
+}
+async function requestDeviceToken(runtime, deviceCode) {
+  return await withDeviceRequestTimeout(
+    runtime,
+    "lost contact with the authorization server",
+    async (signal) => {
+      const response = await runtime.fetchImpl(tokenEndpoint(), {
+        method: "POST",
+        headers: {
+          "content-type": "application/x-www-form-urlencoded",
+          accept: "application/json"
+        },
+        body: new URLSearchParams({
+          grant_type: DEVICE_CODE_GRANT_TYPE,
+          device_code: deviceCode,
+          client_id: runtime.clientId
+        }).toString(),
+        signal
+      });
+      return await evaluateDevicePollResponse(response, runtime.now());
+    }
+  );
+}
+async function evaluateDevicePollResponse(response, nowMs) {
+  if (response.ok) {
+    return { tokens: parseTokenResponse(await readJsonOrDeviceError(response)) };
+  }
+  const error = await readDeviceOAuthError(response);
+  switch (error) {
+    case "authorization_pending":
+      return {};
+    case "slow_down":
+      return { slowDown: true, retryAfterSeconds: retryAfterSeconds(response, nowMs) };
+    case "access_denied":
+      throw ErrDeviceAuthFailed("access was denied");
+    case "expired_token":
+      throw ErrDeviceAuthFailed("the code expired");
+    default:
+      if (response.status === 429) {
+        return { slowDown: true, retryAfterSeconds: retryAfterSeconds(response, nowMs) };
+      }
+      throw ErrDeviceAuthFailed(`authorization server returned HTTP ${response.status}`);
+  }
+}
+async function withDeviceRequestTimeout(runtime, networkError, operation) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), runtime.requestTimeoutMs);
+  try {
+    return await operation(controller.signal);
+  } catch (err) {
+    if (controller.signal.aborted) {
+      throw ErrDeviceAuthFailed("authorization server request timed out");
+    }
+    if (isAuthError(err)) throw err;
+    throw ErrDeviceAuthFailed(networkError);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function retryAfterSeconds(response, nowMs) {
+  const value = response.headers.get("retry-after")?.trim();
+  if (!value) return void 0;
+  if (/^\d+$/.test(value)) return Math.min(Number(value), MAX_DEVICE_POLL_SECONDS);
+  const retryAt = Date.parse(value);
+  if (!Number.isFinite(retryAt)) return void 0;
+  return Math.min(Math.max(Math.ceil((retryAt - nowMs) / 1e3), 0), MAX_DEVICE_POLL_SECONDS);
+}
 async function refreshTokens(refresh_token, opts = {}) {
   const clientId = resolveClientId();
   const fetchImpl = opts.fetchImpl ?? fetch;
@@ -135540,6 +136691,146 @@ async function persistOAuth(tokens, opts) {
   const oauth = opts.preserveMissing ? { ...existing.oauth, ...tokens } : { ...tokens };
   await writeStore({ ...existing, oauth });
 }
+async function persistVerifiedOAuthSession(tokens, user) {
+  let credentials = {};
+  try {
+    ({ credentials } = await readStore());
+  } catch {
+    credentials = {};
+  }
+  const next = {
+    ...credentials,
+    oauth: { ...tokens }
+  };
+  if (user.email || user.first_name || user.last_name || user.username) {
+    next.user = {
+      ...credentials.user,
+      email: user.email,
+      first_name: user.first_name,
+      last_name: user.last_name,
+      username: user.username
+    };
+  } else {
+    delete next.user;
+  }
+  await writeStore(next);
+}
+function parseDeviceAuthorizationResponse(payload) {
+  const data2 = requireDeviceAuthorizationRecord(payload);
+  const deviceCode = stringField(data2, "device_code");
+  const userCode = stringField(data2, "user_code");
+  const verificationUri = requiredSafeVerificationUri(data2, "verification_uri");
+  const verificationUriComplete = optionalSafeVerificationUri(data2, "verification_uri_complete");
+  const expiresIn = strictNumericField(data2, "expires_in");
+  const interval = strictNumericField(data2, "interval");
+  requireSafeDeviceCode(deviceCode);
+  requireSafeDeviceCode(userCode);
+  const timing2 = normalizeDeviceAuthorizationTiming(data2, expiresIn, interval);
+  return {
+    deviceCode,
+    userCode,
+    verificationUri,
+    ...verificationUriComplete ? { verificationUriComplete } : {},
+    ...timing2
+  };
+}
+function requireSafeDeviceCode(value) {
+  if (!value || !isHeaderSafe(value)) {
+    throw ErrDeviceAuthFailed("authorization server returned an invalid response");
+  }
+}
+function normalizeDeviceAuthorizationTiming(data2, expiresIn, interval) {
+  if (!isPositiveNumber(expiresIn) || data2["interval"] !== void 0 && !isPositiveNumber(interval)) {
+    throw ErrDeviceAuthFailed("authorization server returned invalid timing values");
+  }
+  return {
+    expiresIn,
+    interval: Math.min(
+      Math.max(Math.ceil(interval ?? MIN_DEVICE_POLL_SECONDS), MIN_DEVICE_POLL_SECONDS),
+      MAX_DEVICE_POLL_SECONDS
+    )
+  };
+}
+function requiredSafeVerificationUri(data2, key2) {
+  const value = normalizeSafeVerificationUri(stringField(data2, key2));
+  if (!value) throw ErrDeviceAuthFailed("authorization server returned an unsafe verification URL");
+  return value;
+}
+function optionalSafeVerificationUri(data2, key2) {
+  if (data2[key2] === void 0) return void 0;
+  return requiredSafeVerificationUri(data2, key2);
+}
+function requireDeviceAuthorizationRecord(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw ErrDeviceAuthFailed("authorization server returned an invalid response");
+  }
+  return payload;
+}
+function isPositiveNumber(value) {
+  return value !== void 0 && value > 0;
+}
+function normalizeSafeVerificationUri(value) {
+  if (!value || !isHeaderSafe(value)) return void 0;
+  try {
+    const url = new URL(value);
+    if (url.username || url.password) return void 0;
+    const allowed = url.protocol === "https:" || url.protocol === "http:" && ["127.0.0.1", "localhost"].includes(url.hostname);
+    return allowed ? url.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readJsonOrDeviceError(res) {
+  return await readBoundedDeviceJson(res);
+}
+async function readDeviceOAuthError(res) {
+  try {
+    const payload = await readBoundedDeviceJson(res);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return void 0;
+    const error = payload["error"];
+    return typeof error === "string" ? error : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function strictNumericField(obj, key2) {
+  const value = obj[key2];
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+async function readBoundedDeviceJson(res) {
+  if (!res.body) throw ErrDeviceAuthFailed("authorization server returned no data");
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > MAX_DEVICE_RESPONSE_BYTES) {
+        await reader.cancel();
+        throw ErrDeviceAuthFailed("authorization server response was too large");
+      }
+      chunks.push(value);
+    }
+    const body = new Uint8Array(total);
+    let offset2 = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset2);
+      offset2 += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder().decode(body));
+  } catch (err) {
+    if (isAuthError(err)) throw err;
+    throw ErrDeviceAuthFailed("authorization server returned non-JSON data");
+  } finally {
+    reader.releaseLock();
+  }
+}
 async function readJsonOrThrow(res) {
   try {
     return await res.json();
@@ -135554,7 +136845,7 @@ async function safeText2(res) {
     return "";
   }
 }
-var REVOKE_TIMEOUT_MS, MIN_EXPIRES_IN_SECONDS, DEFAULT_CLIENT_ID, DEFAULT_SCOPES, DEFAULT_AUTHORIZE_URL, DEFAULT_TOKEN_URL, DEFAULT_REVOKE_URL;
+var REVOKE_TIMEOUT_MS, MIN_EXPIRES_IN_SECONDS, DEFAULT_CLIENT_ID, DEFAULT_SCOPES, DEFAULT_AUTHORIZE_URL, DEFAULT_TOKEN_URL, DEFAULT_REVOKE_URL, DEFAULT_DEVICE_AUTHORIZATION_URL, DEVICE_CODE_GRANT_TYPE, MAX_DEVICE_FLOW_SECONDS, MIN_DEVICE_POLL_SECONDS, MAX_DEVICE_POLL_SECONDS, MAX_DEVICE_RESPONSE_BYTES, DEVICE_REQUEST_TIMEOUT_MS;
 var init_oauth = __esm({
   "src/auth/oauth.ts"() {
     "use strict";
@@ -135573,6 +136864,13 @@ var init_oauth = __esm({
     DEFAULT_AUTHORIZE_URL = "https://app.heygen.com/oauth/authorize";
     DEFAULT_TOKEN_URL = "https://api2.heygen.com/v1/oauth/token";
     DEFAULT_REVOKE_URL = "https://api2.heygen.com/v1/oauth/revoke";
+    DEFAULT_DEVICE_AUTHORIZATION_URL = "https://api2.heygen.com/v1/oauth/device_authorization";
+    DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+    MAX_DEVICE_FLOW_SECONDS = 30 * 60;
+    MIN_DEVICE_POLL_SECONDS = 5;
+    MAX_DEVICE_POLL_SECONDS = 60;
+    MAX_DEVICE_RESPONSE_BYTES = 64 * 1024;
+    DEVICE_REQUEST_TIMEOUT_MS = 15e3;
   }
 });
 
@@ -135591,7 +136889,7 @@ var init_auth = __esm({
 });
 
 // src/utils/projectLink.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { existsSync as existsSync75, mkdirSync as mkdirSync39, readFileSync as readFileSync46, writeFileSync as writeFileSync28 } from "fs";
 import { homedir as homedir16 } from "os";
 import { join as join83, resolve as resolve47 } from "path";
@@ -135642,7 +136940,7 @@ function ensureProjectId(absDir) {
   const path2 = resolve47(absDir);
   const existing = links[path2];
   if (existing) return existing.projectId;
-  const projectId = randomUUID8();
+  const projectId = randomUUID9();
   links[path2] = { projectId, url: "" };
   writeProjectLinks(links);
   return projectId;
@@ -135680,7 +136978,7 @@ var init_projectLink = __esm({
 
 // src/utils/publishProject.ts
 import { basename as basename14, dirname as dirname37, join as join84, posix as posix5, relative as relative18, resolve as resolve48 } from "path";
-import { existsSync as existsSync76, readdirSync as readdirSync26, readFileSync as readFileSync47, statSync as statSync27 } from "fs";
+import { existsSync as existsSync76, readdirSync as readdirSync27, readFileSync as readFileSync47, statSync as statSync27 } from "fs";
 import AdmZip from "adm-zip";
 import ignore2 from "ignore";
 function isRecord8(value) {
@@ -135792,7 +137090,7 @@ function createProjectIgnore(rootDir) {
   return matcher;
 }
 function collectProjectFiles(rootDir, currentDir, paths, matcher) {
-  for (const entry of readdirSync26(currentDir, { withFileTypes: true })) {
+  for (const entry of readdirSync27(currentDir, { withFileTypes: true })) {
     if (shouldIgnoreSegment(entry.name)) continue;
     const absolutePath = join84(currentDir, entry.name);
     const relativePath = relative18(rootDir, absolutePath).replaceAll("\\", "/");
@@ -137495,6 +138793,7 @@ function probeWebmAlpha(filePath) {
         "stream=codec_name:stream_tags=alpha_mode",
         "-of",
         "json",
+        "--",
         filePath
       ],
       { encoding: "utf-8", timeout: 15e3 }
@@ -138042,7 +139341,7 @@ __export(render_exports, {
   renderLocal: () => renderLocal,
   resolveBrowserGpuForCli: () => resolveBrowserGpuForCli
 });
-import { mkdtempSync as mkdtempSync12, readdirSync as readdirSync27, readFileSync as readFileSync53, statSync as statSync29, writeFileSync as writeFileSync30, rmSync as rmSync27 } from "fs";
+import { mkdtempSync as mkdtempSync12, readdirSync as readdirSync28, readFileSync as readFileSync53, statSync as statSync29, writeFileSync as writeFileSync30, rmSync as rmSync27 } from "fs";
 import { freemem as freemem5, tmpdir as tmpdir12 } from "os";
 import { resolve as resolve54, dirname as dirname41, join as join88, basename as basename16 } from "path";
 import { execFileSync as execFileSync11, spawn as spawn15 } from "child_process";
@@ -138725,7 +140024,7 @@ function printRenderComplete(outputPath, elapsedMs, quiet, outputDurationSeconds
     isDirectory = stat3.isDirectory();
     if (stat3.isDirectory()) {
       let total = 0;
-      for (const entry of readdirSync27(outputPath, { withFileTypes: true })) {
+      for (const entry of readdirSync28(outputPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         try {
           total += statSync29(join88(outputPath, entry.name)).size;
@@ -139141,7 +140440,7 @@ __export(staticProjectServer_exports, {
   serveStaticProjectHtml: () => serveStaticProjectHtml
 });
 import { createServer as createServer2 } from "http";
-import { createReadStream as createReadStream6, existsSync as existsSync80, statSync as statSync30 } from "fs";
+import { createReadStream as createReadStream7, existsSync as existsSync80, statSync as statSync30 } from "fs";
 import { isAbsolute as isAbsolute14, relative as relative20, resolve as resolve55 } from "path";
 function serveFileWithRange(filePath, rangeHeader, res, contentType = getMimeType(filePath)) {
   const size = statSync30(filePath).size;
@@ -139167,7 +140466,7 @@ function serveFileWithRange(filePath, rangeHeader, res, contentType = getMimeTyp
     headers["Content-Range"] = `bytes ${start}-${end}/${size}`;
   }
   headers["Content-Length"] = String(end - start + 1);
-  const stream = createReadStream6(filePath, { start, end });
+  const stream = createReadStream7(filePath, { start, end });
   stream.on("open", () => {
     res.writeHead(status, headers);
     stream.pipe(res);
@@ -139709,7 +141008,7 @@ var init_motionAudit = __esm({
 });
 
 // src/utils/motionSpec.ts
-import { existsSync as existsSync81, readFileSync as readFileSync54, readdirSync as readdirSync28 } from "fs";
+import { existsSync as existsSync81, readFileSync as readFileSync54, readdirSync as readdirSync29 } from "fs";
 import { basename as basename17, join as join89 } from "path";
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -139753,7 +141052,7 @@ function parseMotionSpec(raw) {
 }
 function findMotionSpec(projectDir) {
   if (!existsSync81(projectDir)) return null;
-  const entries2 = readdirSync28(projectDir);
+  const entries2 = readdirSync29(projectDir);
   const sidecars = entries2.filter((name) => name.endsWith(".motion.json")).sort();
   if (!sidecars[0]) return null;
   if (sidecars.length === 1) return join89(projectDir, sidecars[0]);
@@ -143727,8 +145026,62 @@ function containsTimelineCall3(node, timelineVar) {
 function rangeOf3(node) {
   return typeof node.start === "number" && typeof node.end === "number" ? [node.start, node.end] : void 0;
 }
+function isSafeDefaultExpression3(node, earlierParams) {
+  let safe = true;
+  const visit = (current2, parent, key2) => {
+    if (!isNode4(current2) || !safe) return;
+    if (!SAFE_DEFAULT_NODES3.has(current2.type)) {
+      safe = false;
+      return;
+    }
+    if (current2.type === "UnaryExpression" && current2.operator === "delete") {
+      safe = false;
+      return;
+    }
+    if (current2.type === "Identifier") {
+      const nonValue = parent && key2 ? isNonValueIdentifierSlot3(parent, key2) : false;
+      if (!nonValue && current2.name !== "undefined" && !earlierParams.has(current2.name)) {
+        safe = false;
+      }
+      return;
+    }
+    for (const childKey of Object.keys(current2)) {
+      if (SKIP_KEYS3.has(childKey)) continue;
+      const child = current2[childKey];
+      if (Array.isArray(child)) {
+        for (const item of child) visit(item, current2, childKey);
+      } else {
+        visit(child, current2, childKey);
+      }
+    }
+  };
+  visit(node);
+  return safe;
+}
+function supportedParam3(param, earlier) {
+  if (param.type === "Identifier") return { name: param.name };
+  if (param.type !== "AssignmentPattern" || param.left?.type !== "Identifier") return null;
+  if (!isSafeDefaultExpression3(param.right, earlier)) return null;
+  return { name: param.left.name, defaultExpression: param.right };
+}
+function supportedParams3(fn) {
+  if (SUPPORTED_PARAMS_CACHE3.has(fn)) return SUPPORTED_PARAMS_CACHE3.get(fn) ?? null;
+  const params = [];
+  const earlier = /* @__PURE__ */ new Set();
+  for (const param of fn.params ?? []) {
+    const parsed = supportedParam3(param, earlier);
+    if (!parsed) {
+      SUPPORTED_PARAMS_CACHE3.set(fn, null);
+      return null;
+    }
+    params.push(parsed);
+    earlier.add(parsed.name);
+  }
+  SUPPORTED_PARAMS_CACHE3.set(fn, params);
+  return params;
+}
 function isShapeEligible3(fn) {
-  return isFunctionNode6(fn) && fn.body?.type === "BlockStatement" && !(fn.params ?? []).some((p2) => p2.type !== "Identifier");
+  return isFunctionNode6(fn) && fn.body?.type === "BlockStatement" && supportedParams3(fn) !== null;
 }
 function callsAny3(node, names) {
   let hit = false;
@@ -143778,20 +145131,55 @@ function timelineBuildingNames3(candidates, timelineVar) {
 function bump3(counts, key2) {
   counts.set(key2, (counts.get(key2) ?? 0) + 1);
 }
+function undefinedIdentifier3() {
+  return { type: "Identifier", name: "undefined" };
+}
+function isExplicitUndefined3(node) {
+  return node?.type === "Identifier" && node.name === "undefined" || node?.type === "UnaryExpression" && node.operator === "void" && node.argument?.type === "Literal" && node.argument.value === 0;
+}
+function resolveHelperBindings3(call, params) {
+  if (call.arguments?.some((arg) => arg?.type === "SpreadElement")) return null;
+  const bindings = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < params.length; i2++) {
+    const param = params[i2];
+    const arg = call.arguments?.[i2];
+    if (arg && !isExplicitUndefined3(arg)) {
+      bindings.set(param.name, arg);
+    } else if (param.defaultExpression) {
+      bindings.set(param.name, substituteParams3(cloneNode4(param.defaultExpression), bindings));
+    } else {
+      bindings.set(param.name, undefinedIdentifier3());
+    }
+  }
+  return bindings;
+}
+function statementHelperCall3(node, names) {
+  if (node.type !== "ExpressionStatement") return void 0;
+  const expression = node.expression;
+  if (expression?.type !== "CallExpression" || expression.callee?.type !== "Identifier") {
+    return void 0;
+  }
+  return names.has(expression.callee.name) ? expression : void 0;
+}
 function safelyDroppable3(program, candidates) {
   const names = new Set(candidates.keys());
   const totalIds = /* @__PURE__ */ new Map();
   const stmtCalls = /* @__PURE__ */ new Map();
+  const unbindable = /* @__PURE__ */ new Set();
   walkNodes3(program, (n2) => {
     if (n2.type === "Identifier" && names.has(n2.name)) bump3(totalIds, n2.name);
-    const e3 = n2.type === "ExpressionStatement" ? n2.expression : void 0;
-    if (e3?.type === "CallExpression" && e3.callee?.type === "Identifier" && names.has(e3.callee.name)) {
-      bump3(stmtCalls, e3.callee.name);
-    }
+    const call = statementHelperCall3(n2, names);
+    if (!call) return;
+    bump3(stmtCalls, call.callee.name);
+    const fn = candidates.get(call.callee.name);
+    const params = fn && supportedParams3(fn);
+    if (!params || !resolveHelperBindings3(call, params)) unbindable.add(call.callee.name);
   });
   const safe = /* @__PURE__ */ new Map();
   for (const [name, fn] of candidates) {
-    if ((totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) safe.set(name, fn);
+    if (!unbindable.has(name) && (totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) {
+      safe.set(name, fn);
+    }
   }
   return safe;
 }
@@ -143834,11 +145222,11 @@ function expandBody3(bodyStmts, bindings, prov, ctx) {
 }
 function inlineHelper3(call, ctx) {
   const fn = ctx.helpers.get(call.callee.name);
-  const bindings = /* @__PURE__ */ new Map();
-  (fn.params ?? []).forEach((p2, i2) => {
-    const arg = call.arguments?.[i2];
-    if (arg) bindings.set(p2.name, arg);
-  });
+  if (!fn) return null;
+  const params = supportedParams3(fn);
+  if (!params) return null;
+  const bindings = resolveHelperBindings3(call, params);
+  if (!bindings) return null;
   const prov = {
     kind: "helper",
     fn: call.callee.name,
@@ -145157,7 +146545,7 @@ function parseGsapScriptAcorn3(script) {
     return { animations: [], timelineVar: "tl", preamble: "", postamble: "" };
   }
 }
-var recast3, import_parser4, PROPERTY_GROUPS6, PROP_TO_GROUP6, roundPercentage5, SKIP_KEYS3, FUNCTION_TYPES3, GSAP_METHODS6, MAX_DEPTH3, MAX_ITERS3, GSAP_METHODS23, QUERY_METHODS5, ITERATION_METHODS5, SCOPE_NODE_TYPES5, CONST_NODES4, MATH_FNS4, MATH_CONSTS4, BUILTIN_VAR_KEYS5, DROPPED_VAR_KEYS5, EXTRAS_KEYS5, PERCENTAGE_KEY_RE5, GSAP_DEFAULT_DURATION5;
+var recast3, import_parser4, PROPERTY_GROUPS6, PROP_TO_GROUP6, roundPercentage5, SKIP_KEYS3, FUNCTION_TYPES3, GSAP_METHODS6, MAX_DEPTH3, MAX_ITERS3, SAFE_DEFAULT_NODES3, SUPPORTED_PARAMS_CACHE3, GSAP_METHODS23, QUERY_METHODS5, ITERATION_METHODS5, SCOPE_NODE_TYPES5, CONST_NODES4, MATH_FNS4, MATH_CONSTS4, BUILTIN_VAR_KEYS5, DROPPED_VAR_KEYS5, EXTRAS_KEYS5, PERCENTAGE_KEY_RE5, GSAP_DEFAULT_DURATION5;
 var init_gsapParserExports = __esm({
   "../parsers/dist/gsapParserExports.js"() {
     "use strict";
@@ -145187,6 +146575,23 @@ var init_gsapParserExports = __esm({
     GSAP_METHODS6 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
     MAX_DEPTH3 = 8;
     MAX_ITERS3 = 512;
+    SAFE_DEFAULT_NODES3 = /* @__PURE__ */ new Set([
+      "ArrayExpression",
+      "BinaryExpression",
+      "ChainExpression",
+      "ConditionalExpression",
+      "Identifier",
+      "Literal",
+      "LogicalExpression",
+      "MemberExpression",
+      "ObjectExpression",
+      "Property",
+      "SpreadElement",
+      "TemplateElement",
+      "TemplateLiteral",
+      "UnaryExpression"
+    ]);
+    SUPPORTED_PARAMS_CACHE3 = /* @__PURE__ */ new WeakMap();
     GSAP_METHODS23 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
     QUERY_METHODS5 = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
     ITERATION_METHODS5 = /* @__PURE__ */ new Set(["forEach", "map"]);
@@ -146555,7 +147960,7 @@ __export(info_exports, {
   examples: () => examples16,
   orientation: () => orientation
 });
-import { readFileSync as readFileSync60, readdirSync as readdirSync29, statSync as statSync33 } from "fs";
+import { readFileSync as readFileSync60, readdirSync as readdirSync30, statSync as statSync33 } from "fs";
 import { join as join98 } from "path";
 function orientation(width, height) {
   if (width > height) return "landscape";
@@ -146569,7 +147974,7 @@ function durationFromHtml(html, fallback) {
 }
 function totalSize(dir) {
   let total = 0;
-  for (const entry of readdirSync29(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync30(dir, { withFileTypes: true })) {
     const path2 = join98(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path2);
@@ -148018,7 +149423,7 @@ __export(synthesize_exports, {
   synthesize: () => synthesize
 });
 import { execFileSync as execFileSync14 } from "child_process";
-import { existsSync as existsSync95, writeFileSync as writeFileSync38, mkdirSync as mkdirSync48, readdirSync as readdirSync30, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync95, writeFileSync as writeFileSync38, mkdirSync as mkdirSync48, readdirSync as readdirSync31, unlinkSync as unlinkSync8 } from "fs";
 import { join as join104, dirname as dirname50, basename as basename20 } from "path";
 import { homedir as homedir19 } from "os";
 function ensureSynthScript() {
@@ -148027,10 +149432,10 @@ function ensureSynthScript() {
     writeFileSync38(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename20(SCRIPT_PATH);
     try {
-      for (const entry of readdirSync30(SCRIPT_DIR)) {
+      for (const entry of readdirSync31(SCRIPT_DIR)) {
         if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
           try {
-            unlinkSync7(join104(SCRIPT_DIR, entry));
+            unlinkSync8(join104(SCRIPT_DIR, entry));
           } catch {
           }
         }
@@ -148875,7 +150280,7 @@ __export(upgrade_exports, {
   upgradeProjectPins: () => upgradeProjectPins
 });
 import { execFileSync as execFileSync16 } from "child_process";
-import { existsSync as existsSync99, readFileSync as readFileSync66, writeFileSync as writeFileSync39, renameSync as renameSync15 } from "fs";
+import { existsSync as existsSync99, readFileSync as readFileSync66, writeFileSync as writeFileSync39, renameSync as renameSync14 } from "fs";
 import { resolve as resolve65 } from "path";
 async function confirmUpgrade() {
   const shouldUpgrade = await ue({ message: "Upgrade now?" });
@@ -148948,7 +150353,7 @@ async function upgradeProjectPins(dir, opts) {
     const tmp = `${pkgPath}.tmp`;
     writeFileSync39(tmp, `${JSON.stringify(raw, null, 2)}
 `, "utf-8");
-    renameSync15(tmp, pkgPath);
+    renameSync14(tmp, pkgPath);
   }
   return { changed: rewrite.changed, from: rewrite.fromVersions, to: latest, path: pkgPath };
 }
@@ -149215,7 +150620,7 @@ __export(feedback_exports, {
   default: () => feedback_default,
   examples: () => examples26
 });
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { resolve as resolve66 } from "path";
 import open from "open";
 function normalizeComment(raw) {
@@ -149368,7 +150773,7 @@ var init_feedback2 = __esm({
         }
         const comment = normalizeComment(args.comment);
         const doctorSummary = await getDoctorSummary();
-        const feedbackId = randomUUID9();
+        const feedbackId = randomUUID10();
         const config = readConfig();
         const joinKeys = buildTelemetryJoinKeys({
           feedbackId,
@@ -149593,7 +150998,7 @@ __export(contactSheet_exports, {
   createSvgContactSheet: () => createSvgContactSheet
 });
 import sharp from "sharp";
-import { readdirSync as readdirSync31, readFileSync as readFileSync67, writeFileSync as writeFileSync40, unlinkSync as unlinkSync8, existsSync as existsSync100 } from "fs";
+import { readdirSync as readdirSync33, readFileSync as readFileSync67, writeFileSync as writeFileSync40, unlinkSync as unlinkSync9, existsSync as existsSync100 } from "fs";
 import { join as join106, extname as extname19, basename as basename21, dirname as dirname53 } from "path";
 async function createContactSheet(imagePaths, outputPath, opts = {}) {
   const {
@@ -149681,7 +151086,7 @@ async function createContactSheetPages(imagePaths, outputBasePath, opts = {}, la
 }
 async function createScrollContactSheet(screenshotsDir, outputPath, budget = {}) {
   if (!existsSync100(screenshotsDir)) return [];
-  const scrollFiles = readdirSync31(screenshotsDir).filter((f3) => f3.startsWith("scroll-") && f3.endsWith(".png")).sort();
+  const scrollFiles = readdirSync33(screenshotsDir).filter((f3) => f3.startsWith("scroll-") && f3.endsWith(".png")).sort();
   if (scrollFiles.length === 0) return [];
   const paths = scrollFiles.map((f3) => join106(screenshotsDir, f3));
   const labels = scrollFiles.map((f3) => {
@@ -149698,7 +151103,7 @@ async function createScrollContactSheet(screenshotsDir, outputPath, budget = {})
 }
 async function createSnapshotContactSheet(snapshotsDir, outputPath, budget = {}) {
   if (!existsSync100(snapshotsDir)) return [];
-  const snapshotFiles = readdirSync31(snapshotsDir).filter((f3) => f3.startsWith("frame-") && f3.endsWith(".png")).sort();
+  const snapshotFiles = readdirSync33(snapshotsDir).filter((f3) => f3.startsWith("frame-") && f3.endsWith(".png")).sort();
   if (snapshotFiles.length === 0) return [];
   const paths = snapshotFiles.map((f3) => join106(snapshotsDir, f3));
   const labels = snapshotFiles.map((f3) => {
@@ -149716,7 +151121,7 @@ async function createSnapshotContactSheet(snapshotsDir, outputPath, budget = {})
 async function createAssetContactSheet(assetsDir, outputPath, budget = {}) {
   if (!existsSync100(assetsDir)) return [];
   const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
-  const assetFiles = readdirSync31(assetsDir).filter((f3) => imageExts.has(extname19(f3).toLowerCase()) && !f3.includes("contact-sheet")).sort();
+  const assetFiles = readdirSync33(assetsDir).filter((f3) => imageExts.has(extname19(f3).toLowerCase()) && !f3.includes("contact-sheet")).sort();
   if (assetFiles.length === 0) return [];
   const paths = assetFiles.map((f3) => join106(assetsDir, f3));
   return createContactSheetPages(paths, outputPath, {
@@ -149735,7 +151140,7 @@ async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget
   const seen = /* @__PURE__ */ new Set();
   const svgPaths = [];
   for (const dir of dirsToScan) {
-    for (const f3 of readdirSync31(dir).filter((f4) => f4.endsWith(".svg")).sort()) {
+    for (const f3 of readdirSync33(dir).filter((f4) => f4.endsWith(".svg")).sort()) {
       if (!seen.has(f3)) {
         seen.add(f3);
         svgPaths.push(join106(dir, f3));
@@ -149782,7 +151187,7 @@ async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget
   } finally {
     for (const tmp of tmpPaths) {
       try {
-        unlinkSync8(tmp);
+        unlinkSync9(tmp);
       } catch {
       }
     }
@@ -155954,7 +157359,7 @@ var require_node_domexception = __commonJS({
 });
 
 // ../../node_modules/.bun/fetch-blob@3.2.0/node_modules/fetch-blob/from.js
-import { statSync as statSync35, createReadStream as createReadStream7, promises as fs3 } from "fs";
+import { statSync as statSync35, createReadStream as createReadStream8, promises as fs3 } from "fs";
 import { basename as basename23 } from "path";
 var import_node_domexception, stat, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, BlobDataItem;
 var init_from = __esm({
@@ -156006,7 +157411,7 @@ var init_from = __esm({
         if (mtimeMs > this.lastModified) {
           throw new import_node_domexception.default("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
         }
-        yield* createReadStream7(this.#path, {
+        yield* createReadStream8(this.#path, {
           start: this.#start,
           end: this.#start + this.size - 1
         });
@@ -157673,7 +159078,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry3();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID10 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID11 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -157946,7 +159351,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID10();
+          const boundary = await randomUUID11();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -189703,8 +191108,8 @@ async function captureSnapshots(projectDir, opts) {
       const snapshotDir = opts.outputDir ?? join107(projectDir, "snapshots");
       mkdirSync49(snapshotDir, { recursive: true });
       try {
-        const { readdirSync: readdirSync38 } = await import("fs");
-        for (const file of readdirSync38(snapshotDir)) {
+        const { readdirSync: readdirSync39 } = await import("fs");
+        for (const file of readdirSync39(snapshotDir)) {
           if (/\.(png|jpg|jpeg)$/i.test(file)) {
             rmSync30(join107(snapshotDir, file), { force: true });
           }
@@ -190159,6 +191564,7 @@ function probeMedia2(mediaPath, ffprobePath) {
       "stream=color_space,color_transfer,color_primaries,pix_fmt,duration:format=duration",
       "-of",
       "json",
+      "--",
       mediaPath
     ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "pipe"] });
     const parsed = asRecord(JSON.parse(raw));
@@ -191614,7 +193020,7 @@ __export(compare_exports, {
   parseCompareArgs: () => parseCompareArgs,
   prepareCompareVariantProjects: () => prepareCompareVariantProjects
 });
-import { cpSync as cpSync6, existsSync as existsSync105, mkdirSync as mkdirSync51, mkdtempSync as mkdtempSync17, renameSync as renameSync16, rmSync as rmSync32, statSync as statSync36 } from "fs";
+import { cpSync as cpSync6, existsSync as existsSync105, mkdirSync as mkdirSync51, mkdtempSync as mkdtempSync17, renameSync as renameSync15, rmSync as rmSync32, statSync as statSync36 } from "fs";
 import { tmpdir as tmpdir17 } from "os";
 import { basename as basename28, dirname as dirname55, extname as extname23, join as join110 } from "path";
 function defaultLabelForPath(input2) {
@@ -191726,7 +193132,7 @@ function stageHtmlVariant(variant) {
     });
     const sourceName = basename28(variant.inputPath);
     if (sourceName !== "index.html") {
-      renameSync16(join110(stagedDir, sourceName), join110(stagedDir, "index.html"));
+      renameSync15(join110(stagedDir, sourceName), join110(stagedDir, "index.html"));
     }
     return {
       ...variant,
@@ -192304,7 +193710,7 @@ __export(video_exports, {
   runVideoMode: () => runVideoMode,
   safeFilename: () => safeFilename
 });
-import { createWriteStream as createWriteStream4, existsSync as existsSync106, mkdirSync as mkdirSync54, readFileSync as readFileSync71, unlinkSync as unlinkSync9 } from "fs";
+import { createWriteStream as createWriteStream4, existsSync as existsSync106, mkdirSync as mkdirSync54, readFileSync as readFileSync71, unlinkSync as unlinkSync10 } from "fs";
 import { resolve as resolve71, join as join113, basename as basename29 } from "path";
 async function streamToFile(url, destPath) {
   const r2 = await safeFetch(url, {
@@ -192367,7 +193773,7 @@ async function streamToFile(url, destPath) {
     file.destroy();
     if (e3.code !== "EEXIST") {
       try {
-        unlinkSync9(destPath);
+        unlinkSync10(destPath);
       } catch {
       }
     }
@@ -193726,7 +195132,7 @@ var init_designStyleExtractor = __esm({
 });
 
 // src/capture/fontMetadataExtractor.ts
-import { readdirSync as readdirSync33, readFileSync as readFileSync73, writeFileSync as writeFileSync46, existsSync as existsSync107 } from "fs";
+import { readdirSync as readdirSync34, readFileSync as readFileSync73, writeFileSync as writeFileSync46, existsSync as existsSync107 } from "fs";
 import { join as join114 } from "path";
 import * as fontkit from "fontkit";
 function isFontCollection(value) {
@@ -193736,7 +195142,7 @@ function extractFontMetadata(fontsDir, outputPath) {
   const files = [];
   const unidentified = [];
   if (existsSync107(fontsDir)) {
-    const fontFiles = readdirSync33(fontsDir).filter((f3) => /\.(woff2?|ttf|otf)$/i.test(f3));
+    const fontFiles = readdirSync34(fontsDir).filter((f3) => /\.(woff2?|ttf|otf)$/i.test(f3));
     for (const filename of fontFiles) {
       const fullPath = join114(fontsDir, filename);
       const meta = readSingleFont(fullPath, filename);
@@ -194049,7 +195455,7 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync55, writeFileSync as writeFileSync47, readdirSync as readdirSync34, readFileSync as readFileSync74, statSync as statSync37 } from "fs";
+import { mkdirSync as mkdirSync55, writeFileSync as writeFileSync47, readdirSync as readdirSync35, readFileSync as readFileSync74, statSync as statSync37 } from "fs";
 import { join as join115, extname as extname25 } from "path";
 function liveRemainingMs(budget, fallbackMs) {
   return budget.remainingMs?.() ?? fallbackMs;
@@ -194118,7 +195524,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir, budget
   const manifest = [];
   const previewDir = join115(lottieDir, "previews");
   mkdirSync55(previewDir, { recursive: true });
-  for (const file of readdirSync34(lottieDir)) {
+  for (const file of readdirSync35(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     if (liveRemainingMs(budget, 1) <= 0) break;
     try {
@@ -194434,7 +195840,7 @@ var init_mediaCapture = __esm({
 });
 
 // src/capture/contentExtractor.ts
-import { existsSync as existsSync108, readdirSync as readdirSync35, statSync as statSync38, readFileSync as readFileSync75 } from "fs";
+import { existsSync as existsSync108, readdirSync as readdirSync36, statSync as statSync38, readFileSync as readFileSync75 } from "fs";
 import { basename as basename30, join as join116 } from "path";
 function resolveVisionPhaseCompletion(outcome, remainingMs) {
   if (outcome.budgetExhausted || remainingMs <= 0) {
@@ -194673,7 +196079,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
         return response.text?.trim() || "";
       };
     }
-    const imageFiles = readdirSync35(join116(outputDir, "assets")).filter(
+    const imageFiles = readdirSync36(join116(outputDir, "assets")).filter(
       (f3) => /\.(png|jpg|jpeg|webp|gif)$/i.test(f3)
     );
     const BATCH_SIZE = 20;
@@ -194735,12 +196141,12 @@ async function captionImagesWithGemini(outputDir, progress, warnings, options =
     );
     const svgFiles = [];
     const assetsDir = join116(outputDir, "assets");
-    for (const f3 of readdirSync35(assetsDir)) {
+    for (const f3 of readdirSync36(assetsDir)) {
       if (/\.svg$/i.test(f3)) svgFiles.push({ file: f3, relPath: f3 });
     }
     const svgsSubdir = join116(assetsDir, "svgs");
     if (existsSync108(svgsSubdir)) {
-      for (const f3 of readdirSync35(svgsSubdir)) {
+      for (const f3 of readdirSync36(svgsSubdir)) {
         if (/\.svg$/i.test(f3)) svgFiles.push({ file: f3, relPath: `svgs/${f3}` });
       }
     }
@@ -194840,7 +196246,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const fontLines = [];
   const assetsPath = join116(outputDir, "assets");
   try {
-    for (const file of readdirSync35(assetsPath)) {
+    for (const file of readdirSync36(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
       const filePath = join116(assetsPath, file);
       const stat3 = statSync38(filePath);
@@ -194872,7 +196278,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   }
   try {
     const svgsPath = join116(assetsPath, "svgs");
-    for (const file of readdirSync35(svgsPath)) {
+    for (const file of readdirSync36(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
         (s2) => s2.label && file.includes(
@@ -194891,7 +196297,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   }
   try {
     const fontsPath = join116(assetsPath, "fonts");
-    for (const file of readdirSync35(fontsPath)) {
+    for (const file of readdirSync36(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
   } catch {
@@ -194934,7 +196340,7 @@ var agentPromptGenerator_exports = {};
 __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
-import { writeFileSync as writeFileSync48, readdirSync as readdirSync36, existsSync as existsSync109 } from "fs";
+import { writeFileSync as writeFileSync48, readdirSync as readdirSync37, existsSync as existsSync109 } from "fs";
 import { join as join117 } from "path";
 function inferColorRole(hex) {
   const r2 = parseInt(hex.slice(1, 3), 16) / 255;
@@ -194970,7 +196376,7 @@ function buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShader
     const baseName = baseFile.replace(/\.jpg$/, "");
     const escapedBase = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const paginatedRe = new RegExp(`^${escapedBase}(?:-(\\d+))?\\.jpg$`);
-    const all = readdirSync36(fullDir).filter((f3) => paginatedRe.test(f3)).map((f3) => ({ name: f3, page: parseInt(f3.match(paginatedRe)?.[1] ?? "0", 10) })).sort((a, b2) => a.page - b2.page).map((entry) => entry.name);
+    const all = readdirSync37(fullDir).filter((f3) => paginatedRe.test(f3)).map((f3) => ({ name: f3, page: parseInt(f3.match(paginatedRe)?.[1] ?? "0", 10) })).sort((a, b2) => a.page - b2.page).map((entry) => entry.name);
     if (all.length === 0) return [];
     if (all.length === 1) {
       return [`| \`${dir}/${all[0]}\` | ${label2} |`];
@@ -196560,7 +197966,7 @@ __export(state_exports, {
   stateFilePath: () => stateFilePath,
   writeStackOutputs: () => writeStackOutputs
 });
-import { existsSync as existsSync113, mkdirSync as mkdirSync58, readdirSync as readdirSync37, readFileSync as readFileSync77, rmSync as rmSync33, writeFileSync as writeFileSync53 } from "fs";
+import { existsSync as existsSync113, mkdirSync as mkdirSync58, readdirSync as readdirSync38, readFileSync as readFileSync77, rmSync as rmSync33, writeFileSync as writeFileSync53 } from "fs";
 import { dirname as dirname56, join as join121 } from "path";
 function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   return join121(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
@@ -196587,7 +197993,7 @@ function deleteStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd())
 function listStackNames(cwd = process.cwd()) {
   const dir = join121(cwd, STATE_DIR_NAME);
   if (!existsSync113(dir)) return [];
-  return readdirSync37(dir).filter((f3) => f3.startsWith(STATE_FILE_PREFIX) && f3.endsWith(".json")).map((f3) => f3.slice(STATE_FILE_PREFIX.length, -".json".length));
+  return readdirSync38(dir).filter((f3) => f3.startsWith(STATE_FILE_PREFIX) && f3.endsWith(".json")).map((f3) => f3.slice(STATE_FILE_PREFIX.length, -".json".length));
 }
 function requireStack(stackName, cwd = process.cwd()) {
   const stack = readStackOutputs(stackName, cwd);
@@ -199001,7 +200407,7 @@ var init_poll = __esm({
 });
 
 // src/cloud/download.ts
-import { createWriteStream as createWriteStream5, mkdirSync as mkdirSync60, unlinkSync as unlinkSync10 } from "fs";
+import { createWriteStream as createWriteStream5, mkdirSync as mkdirSync60, unlinkSync as unlinkSync11 } from "fs";
 import { dirname as dirname58 } from "path";
 async function downloadToFile(url, destPath, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -199042,7 +200448,7 @@ async function downloadToFile(url, destPath, options = {}) {
     await closeFile(file);
     if (errored) {
       try {
-        unlinkSync10(destPath);
+        unlinkSync11(destPath);
       } catch {
       }
     }
@@ -200622,6 +202028,98 @@ __export(login_exports, {
   default: () => login_default
 });
 import { stdin as input } from "process";
+function isRemoteOrHeadless() {
+  const remoteEnvironment = [
+    "CODESPACES",
+    "GITHUB_CODESPACES",
+    "REMOTE_CONTAINERS",
+    "GITPOD_WORKSPACE_ID",
+    "container"
+  ].some(envFlagEnabled);
+  return Boolean(
+    process.env["SSH_CONNECTION"] || process.env["SSH_CLIENT"] || process.env["SSH_TTY"] || process.env["BROWSER"] === "none" || process.env["HF_NO_BROWSER"] === "1" || remoteEnvironment || process.stdout.isTTY !== true
+  );
+}
+function envFlagEnabled(name) {
+  const value = process.env[name]?.trim().toLowerCase();
+  return Boolean(value && value !== "0" && value !== "false" && value !== "no");
+}
+function assertAttendedDeviceFlow() {
+  if (envFlagEnabled("CI") || process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+    console.error(
+      c.error(
+        "`--device` requires an attended terminal and is disabled in CI. Use an API key or workload credential for automation."
+      )
+    );
+    failUsage();
+  }
+}
+async function runDeviceLogin() {
+  assertAttendedDeviceFlow();
+  assertOAuthConfiguredOrExit();
+  const { trackAuthLoginStarted: trackAuthLoginStarted2, trackAuthLoginCompleted: trackAuthLoginCompleted2, trackAuthLoginFailed: trackAuthLoginFailed2, identifyUser: identifyUser2 } = await Promise.resolve().then(() => (init_telemetry2(), telemetry_exports2));
+  trackAuthLoginStarted2("device");
+  let tokens;
+  try {
+    tokens = await startDeviceAuthorizationFlow({
+      onChallenge: ({ verificationUri, verificationUriComplete, userCode }) => {
+        console.log(`Open ${c.accent(verificationUriComplete ?? verificationUri)} in a browser.`);
+        if (!verificationUriComplete) console.log(`Enter code ${c.bold(userCode)}.`);
+        console.log(c.dim("Waiting for approval\u2026"));
+      }
+    });
+  } catch (err) {
+    const message = err.message || "Device authorization failed.";
+    trackAuthLoginFailed2("device", /expired/i.test(message) ? "flow_timeout" : "flow_error");
+    console.error(c.error(message));
+    failCommand();
+  }
+  const credential = {
+    type: "oauth",
+    access_token: tokens.access_token,
+    ...tokens.refresh_token ? { refresh_token: tokens.refresh_token } : {},
+    source: "file_json",
+    refreshable: false
+  };
+  let user;
+  try {
+    user = await new AuthClient().getCurrentUser(credential);
+  } catch (err) {
+    await revokeDeviceTokens(tokens);
+    trackAuthLoginFailed2("device", "rejected");
+    console.error(
+      c.error(
+        `HeyGen could not verify the approved device session; no credential was saved. ${err.message}`
+      )
+    );
+    failCommand();
+  }
+  try {
+    await persistVerifiedOAuthSession(tokens, toStoredUserInfo(user));
+  } catch (err) {
+    await revokeDeviceTokens(tokens);
+    trackAuthLoginFailed2("device", "flow_error");
+    console.error(
+      c.error(
+        `Could not save the verified device session; it was revoked. ${err.message}`
+      )
+    );
+    failCommand();
+  }
+  const id = identityKey(user);
+  if (id) identifyUser2(id);
+  trackAuthLoginCompleted2("device", id);
+  const identity = userDisplayName(toStoredUserInfo(user)) ?? "(unknown user)";
+  console.log(c.success(`\u2713 Signed in as ${identity}.`));
+}
+async function revokeDeviceTokens(tokens) {
+  await revokeTokens(tokens.access_token, { token_type_hint: "access_token" });
+  if (tokens.refresh_token) {
+    await revokeTokens(tokens.refresh_token, {
+      token_type_hint: "refresh_token"
+    });
+  }
+}
 async function runOAuthLogin() {
   assertOAuthConfiguredOrExit();
   const { trackAuthLoginStarted: trackAuthLoginStarted2, trackAuthLoginFailed: trackAuthLoginFailed2 } = await Promise.resolve().then(() => (init_telemetry2(), telemetry_exports2));
@@ -200756,7 +202254,11 @@ async function rollback(previous) {
 async function verifyAndReport(key2) {
   const client = new AuthClient();
   try {
-    const user = await client.getCurrentUser({ type: "api_key", key: key2, source: "file_json" });
+    const user = await client.getCurrentUser({
+      type: "api_key",
+      key: key2,
+      source: "file_json"
+    });
     await persistUserInfo(user);
     const identity = userDisplayName(toStoredUserInfo(user)) ?? "(unknown user)";
     console.log(c.success(`\u2713 API key saved. Authenticated as ${identity}.`));
@@ -200833,15 +202335,35 @@ var init_login = __esm({
         "api-key": {
           type: "string",
           description: "API key value, or pass `--api-key` with no value to read from stdin / prompt."
+        },
+        device: {
+          type: "boolean",
+          description: "Use an attended device code (for SSH/headless terminals; never for CI)."
         }
       },
       // fallow-ignore-next-line complexity
       async run({ args }) {
         const inlineKey = args["api-key"];
+        if (inlineKey !== void 0 && args.device) {
+          console.error(c.error("Choose either --device or --api-key, not both."));
+          failUsage();
+        }
         if (inlineKey !== void 0) {
           await runApiKeyLogin(inlineKey);
           return;
         }
+        if (args.device) {
+          await runDeviceLogin();
+          return;
+        }
+        if (isRemoteOrHeadless()) {
+          console.error(
+            c.error(
+              "Browser callback login is unavailable in this remote/headless terminal. Run `hyperframes auth login --device`."
+            )
+          );
+          failUsage();
+        }
         await runOAuthLogin();
       }
     });
@@ -201264,6 +202786,7 @@ var init_auth3 = __esm({
     init_colors();
     examples37 = [
       ["Sign in via browser (OAuth)", "hyperframes auth login"],
+      ["Sign in from SSH/headless terminal", "hyperframes auth login --device"],
       ["Save an API key (interactive)", "hyperframes auth login --api-key"],
       ["Save an API key from stdin", "echo $HEYGEN_API_KEY | hyperframes auth login --api-key"],
       ["Check who you're signed in as", "hyperframes auth status"],
@@ -201277,7 +202800,7 @@ Manage HeyGen credentials. Credentials live in
 ${c.accent("~/.heygen/credentials")} and are shared with heygen-cli.
 
 ${c.bold("SUBCOMMANDS:")}
-  ${c.accent("login")}    ${c.dim("Sign in via browser (default) or --api-key for a long-lived key.")}
+  ${c.accent("login")}    ${c.dim("Sign in via browser, --device for SSH, or --api-key for a long-lived key.")}
   ${c.accent("status")}   ${c.dim("Show the active credential's source, type, and identity.")}
   ${c.accent("refresh")}  ${c.dim("Force-refresh the OAuth access token.")}
   ${c.accent("logout")}   ${c.dim("Remove the stored credential (--keep-api-key for OAuth-only).")}
@@ -201288,6 +202811,7 @@ ${c.bold("ENV VARS:")}
   ${c.accent("HEYGEN_API_URL")}              Override the API base URL (default https://api.heygen.com).
   ${c.accent("HEYGEN_CONFIG_DIR")}           Override the credentials directory (default ~/.heygen).
   ${c.accent("HYPERFRAMES_OAUTH_CLIENT_ID")} Override the OAuth client_id (for dev/test).
+  ${c.accent("HYPERFRAMES_OAUTH_DEVICE_URL")} Override the RFC 8628 device endpoint (for dev/test).
 `;
     auth_default = defineCommand({
       meta: { name: "auth", description: "Sign in to HeyGen and manage credentials" },