hyperframes 0.8.181 → 0.8.183

package/dist/{chunk-OJDXABUF.js → chunk-TJB4GAV6.js}

@@ -9,10 +9,10 @@ import {
 } from "./chunk-K2FLNJVB.js";
 import {
   trackCommandFailure
-} from "./chunk-5E5EYPZO.js";
+} from "./chunk-DLC2FICN.js";
 import {
   failCommand
-} from "./chunk-PBN6GBJE.js";
+} from "./chunk-JVBRJMOP.js";
 
 // src/utils/project.ts
 import { existsSync, statSync } from "fs";

package/dist/{checkBrowser-VES2NF3K.js → chunk-TOHA5NAU.js}

@@ -8,36 +8,26 @@ import {
   auditClipDurations,
   shouldIgnoreHttpError,
   shouldIgnoreRequestFailure
-} from "./chunk-X7CCSMRR.js";
+} from "./chunk-VAK7A2N6.js";
 import {
   checkSnapshotDirectory,
   rectToBbox
-} from "./chunk-RHWJKSGH.js";
+} from "./chunk-KANNRHY7.js";
 import {
   ambiguousIssue,
   loadBrowserScript
-} from "./chunk-O5AE7HOP.js";
-import "./chunk-X7MTZ4T2.js";
-import "./chunk-OJDXABUF.js";
+} from "./chunk-CJYAJ3QM.js";
 import {
   serveStaticProjectHtml
-} from "./chunk-IZM562YJ.js";
-import "./chunk-UVEQLDKB.js";
-import "./chunk-X7MTZ4T2.js";
-import "./chunk-XUHOIDKG.js";
-import "./chunk-JBCU6NR5.js";
-import "./chunk-IWTRHPTP.js";
-import "./chunk-TTVHYD5R.js";
-import "./chunk-6JR2XUEE.js";
+} from "./chunk-Z4R35NJS.js";
 import {
   FfmpegUnavailableError,
   decideMediaProxyEligibility,
+  getProxyCachePath,
   proxyVariantFor,
   resolveProxies,
   scanProjectMediaCodecMap
-} from "./chunk-KIO3R4QN.js";
-import "./chunk-ICMXC3MI.js";
-import "./chunk-ALVXFXUG.js";
+} from "./chunk-GPE3WWTO.js";
 import {
   AUDIT_SEEK_OPTIONS,
   DEFAULT_ZOOM_PADDING_PX,
@@ -51,84 +41,21 @@ import {
   seekCompositionTimeline,
   seekInPage,
   waitForPreferredSeekTarget
-} from "./chunk-V2UNZ7QP.js";
-import "./chunk-FH7WODJH.js";
+} from "./chunk-XOVHO3TT.js";
 import {
   BrowserCleanupError,
   closeManagedBrowser
-} from "./chunk-IL3GTCQY.js";
-import "./chunk-XSRUVMXK.js";
-import "./chunk-BRHI7EIA.js";
-import "./chunk-S3RYRF3W.js";
-import "./chunk-K2FLNJVB.js";
-import "./chunk-4OT3FWVV.js";
-import "./chunk-442JNXRM.js";
-import "./chunk-RGHQID2E.js";
+} from "./chunk-GTE5WZAM.js";
 import {
   resolveAutoProxy
-} from "./chunk-XH262OWN.js";
-import "./chunk-XT7X6QCP.js";
-import "./chunk-4YYJOFKS.js";
-import "./chunk-HVW7ABXD.js";
-import "./chunk-WUQUR33W.js";
-import "./chunk-JHOCK3DG.js";
-import "./chunk-OFY6JTZC.js";
-import "./chunk-TO6JNTML.js";
-import "./chunk-AWDFDFI3.js";
-import "./chunk-P6LJ4Y32.js";
-import "./chunk-GMECXFAN.js";
-import "./chunk-5CS4T6C6.js";
-import "./chunk-5E5EYPZO.js";
-import "./chunk-K26FR4SM.js";
-import "./chunk-VWG7OQKU.js";
-import "./chunk-T6AGUTZJ.js";
-import "./chunk-S3S4TGEH.js";
-import "./chunk-54HJ63Q2.js";
-import "./chunk-PBN6GBJE.js";
-import "./chunk-ZTZA4UWZ.js";
-import "./chunk-KLIKCX6Q.js";
-import "./chunk-EVMY7IPL.js";
-import "./chunk-7FMUTGOH.js";
-import "./chunk-VAJIPSN6.js";
-import "./chunk-K4WIOZFP.js";
-import "./chunk-XUXGIA7H.js";
-import "./chunk-WERLJGIC.js";
-import "./chunk-ISN5GRYI.js";
-import "./chunk-XEWHUPFS.js";
-import "./chunk-EOVYQ3IG.js";
-import "./chunk-XT6MXC7A.js";
-import "./chunk-YPBIAONI.js";
-import "./chunk-4IEH6EAC.js";
-import "./chunk-W2LGJSEN.js";
-import "./chunk-LBQFLUIY.js";
-import "./chunk-BAZ5LCR3.js";
-import "./chunk-VC76R6W2.js";
-import "./chunk-UJKQWGFF.js";
-import "./chunk-YMS5FOMC.js";
-import "./chunk-OFQWTKPW.js";
-import "./chunk-DPVXBVLL.js";
-import "./chunk-634HSJ3J.js";
-import "./chunk-FXMKHHPO.js";
-import "./chunk-RQVDTPGD.js";
-import "./chunk-537IYAEE.js";
-import "./chunk-GK2FIKIQ.js";
-import "./chunk-6BNTGNGD.js";
-import "./chunk-VAS6HQX3.js";
-import "./chunk-OYLO6TYK.js";
-import "./chunk-32GKETR7.js";
-import "./chunk-BSQ7XANM.js";
-import "./chunk-SDYDNHEE.js";
-import "./chunk-TYXH3EKP.js";
-import "./chunk-IXLUTE6N.js";
+} from "./chunk-K2Z5DZBS.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
-import "./chunk-KGPLIH7B.js";
-import "./chunk-3GXQPCJC.js";
-import "./chunk-M2WBOQ2Q.js";
 
 // src/utils/checkBrowser.ts
-import { mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import os from "os";
 import { join, resolve } from "path";
 
 // src/utils/gsapTweenTails.ts
@@ -268,12 +195,22 @@ async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride
       variant: proxyVariantFor(facts)
     };
   });
-  const results = await resolveProxies(projectDir, sources);
+  const total = hostileEntries.length;
+  const toMake = sources.filter((source) => !proxyCached(projectDir, source)).length;
+  if (toMake > 0) {
+    console.error(
+      `[hyperframes] Making browser-playable copies of ${toMake} video${toMake === 1 ? "" : "s"} Chrome cannot decode. Only the first check of these files waits for this; later checks reuse the copies.`
+    );
+  }
+  let settled = 0;
+  const results = await resolveProxies(projectDir, sources, () => {
+    settled += 1;
+    if (toMake > 0) console.error(`[hyperframes] browser-playable copies: ${settled}/${total}`);
+  });
   const failures = sources.flatMap((source, index) => {
     const result = results[index];
     return result.status === "rejected" ? [{ ...source, reason: result.reason }] : [];
   });
-  const total = hostileEntries.length;
   console.error(
     `[hyperframes] media proxy pre-resolve: ${total - failures.length}/${total} ready, ${failures.length} failed (${Date.now() - startedAt}ms)`
   );
@@ -292,11 +229,18 @@ async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride
   }
   return { findings, failedPaths: new Set(failures.map(({ pathname }) => pathname)) };
 }
+function proxyCached(projectDir, source) {
+  try {
+    return existsSync(getProxyCachePath(projectDir, source.sourcePath, source.variant));
+  } catch {
+    return false;
+  }
+}
 function proxyFailedDraft(message) {
   return { code: "media_proxy_failed", severity: "warning", message, time: 0 };
 }
 async function runBrowserCheck(project, options, motion, runGrid, deadline, prelaunched) {
-  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-2WCR57IN.js");
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-OAYLYC4W.js");
   const html = await bundleWithLocalizedFonts(project.dir);
   const { findings: drafts, failedPaths } = await preResolveHostileMediaProxies(
     project.dir,
@@ -310,18 +254,15 @@ async function runBrowserCheck(project, options, motion, runGrid, deadline, prel
     [],
     options.autoProxy
   );
-  let stamp = { time: 0 };
-  const clock = {
-    now: () => stamp,
-    at: (time) => {
-      stamp = { time };
-    },
-    during: (range) => {
-      stamp = { time: range[0], timeRange: range };
-    }
-  };
+  const clock = createRuntimeClock();
   let failure = { kind: "none" };
   let chromeBrowser;
+  const helperSession = samplingBrowserCount(options) > 1 ? startHelperSession(html, server.url, options, deadline) : void 0;
+  const helperOpen = helperSession?.opened;
+  const helpers = helperOpen?.then(
+    (helper) => [helper.driver],
+    () => []
+  );
   try {
     const launchSettleStart = Date.now();
     const session = await openSettledCompositionPage(html, server.url, {
@@ -343,7 +284,7 @@ async function runBrowserCheck(project, options, motion, runGrid, deadline, prel
     await waitForPreferredSeekTarget(page);
     const rootAnchor = await resolveRootAnchor(page);
     const launchSettleMs = Date.now() - launchSettleStart;
-    const { analyzeClipMediaFit } = await import("./src-RDSWHMJS.js");
+    const { analyzeClipMediaFit } = await import("./src-EL6HGIS4.js");
     for (const entry of await auditClipDurations(page, analyzeClipMediaFit, options.timeout)) {
       drafts.push({ code: "clip_media_fit", severity: entry.level, message: entry.text, time: 0 });
     }
@@ -351,14 +292,18 @@ async function runBrowserCheck(project, options, motion, runGrid, deadline, prel
       const message = tweenTailMessage(tail);
       drafts.push({ code: "gsap_tween_tail", severity: "warning", message, time: tail.later.end });
     }
-    const driver = createPageDriver(page, clock);
-    const result = await runGrid(driver, options, motion);
-    const broken = await abortedImagesStillBroken(page, drafts);
+    const sampleLog = sampleWindow(drafts);
+    const driver = createPageDriver(page, clock, sampleLog);
+    const result = await runGrid(driver, options, motion, helpers);
+    helperSession?.stop();
+    const helper = await helperOpen?.catch(() => void 0);
+    const merged = helper ? mergeHelperDrafts(sampleLog, helper.sampleLog) : drafts;
+    const broken = await abortedImagesStillBroken(page, merged);
     return {
       ...result,
       timings: { ...result.timings, launchSettleMs },
       runtimeFindings: dropFailedProxyEchoes(
-        keepBrokenImageAborts(drafts, broken),
+        keepBrokenImageAborts(merged, broken),
         failedPaths
       ).map((draft) => runtimeFinding(draft, rootAnchor))
     };
@@ -366,12 +311,87 @@ async function runBrowserCheck(project, options, motion, runGrid, deadline, prel
     failure = { kind: "failed", error };
     throw error;
   } finally {
-    await closeCheckResources(chromeBrowser, server, failure);
+    helperSession?.stop();
+    await helperOpen?.catch(() => void 0);
+    await closeCheckResources([chromeBrowser, helperSession?.browser()], server, failure);
   }
 }
+function createRuntimeClock() {
+  let stamp = { time: 0 };
+  return {
+    now: () => stamp,
+    at: (time) => {
+      stamp = { time };
+    },
+    during: (range) => {
+      stamp = { time: range[0], timeRange: range };
+    }
+  };
+}
+var SAMPLING_BROWSER_BYTES = 250 * 1024 * 1024;
+function samplingBrowserCount(options, cores = os.availableParallelism(), free = Math.min(os.freemem(), process.availableMemory())) {
+  if (options.at?.length === 1) return 1;
+  return Math.max(1, Math.min(2, cores - 1, Math.floor(free / SAMPLING_BROWSER_BYTES)));
+}
+function sampleWindow(drafts) {
+  return { drafts, start: Number.POSITIVE_INFINITY, end: Number.POSITIVE_INFINITY };
+}
+function startHelperSession(html, url, options, deadline) {
+  const abort = new AbortController();
+  let browser;
+  const opened = openHelperSession(html, url, options, deadline, {
+    signal: deadline ? AbortSignal.any([deadline.signal, abort.signal]) : abort.signal,
+    onBrowser: (launched) => {
+      browser = launched;
+      deadline?.ownBrowser(launched);
+    }
+  });
+  return {
+    opened,
+    browser: () => browser,
+    stop: () => {
+      abort.abort();
+      if (browser) void closeManagedBrowser(browser).catch(() => void 0);
+    }
+  };
+}
+async function openHelperSession(html, url, options, deadline, owner) {
+  const sampleLog = sampleWindow([]);
+  const clock = createRuntimeClock();
+  const session = await openSettledCompositionPage(html, url, {
+    navigationTimeoutMs: options.timeout,
+    renderReadyTimeoutMs: options.timeout,
+    renderReadyWarningSuffix: "checking the current page state",
+    browserGpuMode: options.browserGpuMode ?? resolveCliChromeGpuMode(),
+    signal: owner.signal,
+    onBrowser: owner.onBrowser,
+    beforeNavigate: async (page) => {
+      wireRuntimeListeners(page, sampleLog.drafts, clock);
+      await deadline?.preparePage(page);
+    }
+  });
+  await waitForPreferredSeekTarget(session.page);
+  return {
+    driver: createPageDriver(session.page, clock, sampleLog),
+    sampleLog
+  };
+}
+var draftKey = (draft) => `${draft.code} ${draft.time} ${draft.message}`;
+function mergeHelperDrafts(primary, helper) {
+  const window2 = ({ drafts, start: start2, end }) => drafts.slice(Math.min(start2, drafts.length), Math.min(end, drafts.length));
+  const own = window2(primary);
+  const seen = new Set(own.map(draftKey));
+  const extra = window2(helper).filter((draft) => !seen.has(draftKey(draft)));
+  const start = Math.min(primary.start, primary.drafts.length);
+  return [
+    ...primary.drafts.slice(0, start),
+    ...[...own, ...extra].sort((a, b) => a.time - b.time),
+    ...primary.drafts.slice(start + own.length)
+  ];
+}
 async function captureFindingCrops(project, options, requests, deadline) {
   if (requests.length === 0) return [];
-  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-2WCR57IN.js");
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-OAYLYC4W.js");
   const html = await bundleWithLocalizedFonts(project.dir);
   const server = await serveStaticProjectHtml(
     project.dir,
@@ -415,12 +435,12 @@ async function captureFindingCrops(project, options, requests, deadline) {
     failure = { kind: "failed", error };
     throw error;
   } finally {
-    await closeCheckResources(chromeBrowser, server, failure);
+    await closeCheckResources([chromeBrowser], server, failure);
   }
 }
-async function closeCheckResources(browser, server, failure) {
+async function closeCheckResources(browsers, server, failure) {
   const cleanup = await Promise.allSettled([
-    browser ? closeManagedBrowser(browser) : Promise.resolve(),
+    ...browsers.map((browser) => browser ? closeManagedBrowser(browser) : Promise.resolve()),
     server.close()
   ]);
   const errors = cleanup.filter((entry) => entry.status === "rejected").map((entry) => entry.reason);
@@ -598,9 +618,14 @@ function wireNetworkListeners(page, drafts, clock) {
     });
   });
 }
-function createPageDriver(page, clock) {
+function createPageDriver(page, clock = createRuntimeClock(), sampleLog) {
   return {
     initialize: (contrast) => injectAuditScripts(page, contrast),
+    markSamples: (phase) => {
+      if (!sampleLog) return;
+      if (phase === "drop") sampleLog.start = sampleLog.end = Number.POSITIVE_INFINITY;
+      else sampleLog[phase] = sampleLog.drafts.length;
+    },
     matchComponents: (components, findings) => page.evaluate(matchComponentFindings, { components, findings }),
     getDuration: () => getCompositionDuration(page),
     hasNoTimelineDeclaration: () => hasNoTimelineDeclaration(page),
@@ -628,6 +653,12 @@ function createPageDriver(page, clock) {
       return issues;
     },
     collectLayoutGeometry: () => collectLayoutGeometry(page),
+    captureFrame: (scope) => captureFrame(page, scope),
+    framesDiffer: (first, second) => page.evaluate(
+      (a, b) => Reflect.apply(Reflect.get(window, "__hyperframesFramesDiffer"), window, [a, b]),
+      first,
+      second
+    ).then((differ) => differ === true),
     collectSeekClock: () => collectSeekClock(page),
     collectRotationSample: (time) => collectRotationSample(page, time),
     collectOffPivotRotationSample: (time) => collectOffPivotRotationSample(page, time),
@@ -806,6 +837,44 @@ async function collectOverlapGrid(page, times) {
     )
   );
 }
+async function captureFrame(page, scope) {
+  if (!scope) return page.screenshot({ encoding: "base64", type: "png" });
+  try {
+    const box = await page.evaluate(isolateScopePaint, scope);
+    if (!box || box.width < 1 || box.height < 1) return "";
+    return await page.screenshot({
+      encoding: "base64",
+      type: "png",
+      clip: box,
+      omitBackground: true
+    });
+  } finally {
+    await page.evaluate(restoreScopePaint);
+  }
+}
+function isolateScopePaint(scope) {
+  let target = null;
+  try {
+    target = document.querySelector(scope);
+  } catch {
+    return null;
+  }
+  if (!target) return null;
+  const visibility = getComputedStyle(target).visibility;
+  target.setAttribute("data-hf-capture-scope", "");
+  const style = document.createElement("style");
+  style.id = "__hf_capture_scope_style";
+  style.textContent = `:not([data-hf-capture-scope], [data-hf-capture-scope] *) { visibility: hidden !important; }
+    :root:not([data-hf-capture-scope]), body:not([data-hf-capture-scope]) { background: none !important; }
+    [data-hf-capture-scope] { visibility: ${visibility} !important; }`;
+  document.head.append(style);
+  const rect = target.getBoundingClientRect();
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+function restoreScopePaint() {
+  document.getElementById("__hf_capture_scope_style")?.remove();
+  document.querySelector("[data-hf-capture-scope]")?.removeAttribute("data-hf-capture-scope");
+}
 async function collectLayoutGeometry(page) {
   return page.evaluate(() => {
     const geometry = Reflect.get(window, "__hyperframesLayoutGeometry");
@@ -1476,13 +1545,17 @@ function matchComponentFindings({
     return matchesSelector(finding.selector) !== false || typeof container === "string" && matchesSelector(container) !== false;
   });
 }
+
 export {
+  preResolveHostileMediaProxies,
+  runBrowserCheck,
+  samplingBrowserCount,
+  mergeHelperDrafts,
   captureFindingCrops,
-  captureOverviewShot,
-  collectSeekClock,
-  dropFailedProxyEchoes,
   keepBrokenImageAborts,
-  matchComponentFindings,
-  preResolveHostileMediaProxies,
-  runBrowserCheck
+  dropFailedProxyEchoes,
+  createPageDriver,
+  collectSeekClock,
+  captureOverviewShot,
+  matchComponentFindings
 };

package/dist/{chunk-RXQHSGAQ.js → chunk-TXGZZKDF.js}

@@ -12,10 +12,10 @@ import {
 } from "./chunk-DCAI5DBR.js";
 import {
   createProjectConfig
-} from "./chunk-XH262OWN.js";
+} from "./chunk-K2Z5DZBS.js";
 import {
   isHyperframesProject
-} from "./chunk-LBQFLUIY.js";
+} from "./chunk-VFBAKPRC.js";
 
 // src/utils/desktopApp.ts
 import { spawn, spawnSync } from "child_process";

package/dist/{chunk-3XDOGSRD.js → chunk-U5YVWG5W.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   stoppedByCancelSignal
-} from "./chunk-Y5GY6Y7A.js";
+} from "./chunk-QX4GGPMY.js";
 import {
   DEFAULT_MODEL,
   ensureModel,
@@ -14,12 +14,12 @@ import {
   hasFFmpeg,
   pinnedWhisperModel,
   sha256File
-} from "./chunk-YMS6CJCD.js";
+} from "./chunk-SAQYJLI6.js";
 import {
   findFFmpeg,
   findFFprobe,
   getFFmpegInstallHint
-} from "./chunk-3PULCIY5.js";
+} from "./chunk-OH56PXFH.js";
 import {
   findWavChunk
 } from "./chunk-UOFAE5RF.js";

package/dist/{chunk-ICMXC3MI.js → chunk-U6RXZNZE.js}

@@ -8,20 +8,20 @@ import {
   pinProjectRecord,
   realFilePath
 } from "./chunk-ALVXFXUG.js";
-import {
-  isProjectIgnoredDir
-} from "./chunk-EVMY7IPL.js";
 import {
   atomicTempPath,
   isAtomicTempPath,
   replaceFileAtomically
 } from "./chunk-EOVYQ3IG.js";
+import {
+  isProjectIgnoredDir
+} from "./chunk-EVMY7IPL.js";
 import {
   isSafePath,
   mkdirWithinProject
 } from "./chunk-OFQWTKPW.js";
 
-// ../studio-server/dist/chunk-6PE5OD32.js
+// ../studio-server/dist/chunk-XM2TJIF5.js
 import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, writeFile } from "fs/promises";
 import {
@@ -174,6 +174,10 @@ var HistoryBusyError = class extends Error {
   pid;
   url;
 };
+var WINDOWS_BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+function busyOnWindows(error) {
+  return process.platform === "win32" && WINDOWS_BUSY.has(error.code ?? "");
+}
 function alive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -238,27 +242,36 @@ function servedBy(file, urlFile, pid) {
     return void 0;
   }
 }
+function attemptClaim(file, urlFile, deadline) {
+  if (claim(file)) return "claimed";
+  const pid = ownerOf(file);
+  if (pid === null) return "retry";
+  if (!alive(pid) && evictDeadOwner(file)) return "retry";
+  if (Date.now() >= deadline) throw new HistoryBusyError(pid, servedBy(file, urlFile, pid));
+  return "wait";
+}
 async function takeHistoryOwnership(home, waitMs, url) {
   const file = join(home, "owner.pid");
   const urlFile = join(home, "owner-url.json");
   const deadline = Date.now() + waitMs;
   mkdirSync(home, { recursive: true });
   for (; ; ) {
-    if (claim(file)) {
-      advertise(urlFile, url);
-      let held = true;
-      return () => {
-        if (held && servedBy(file, urlFile, process.pid)) rmSync(urlFile, { force: true });
-        if (held) releaseOwn(file);
-        held = false;
-      };
+    let next = "wait";
+    try {
+      next = attemptClaim(file, urlFile, deadline);
+    } catch (error) {
+      if (!busyOnWindows(error) || Date.now() >= deadline) throw error;
     }
-    const pid = ownerOf(file);
-    if (pid === null) continue;
-    if (!alive(pid) && evictDeadOwner(file)) continue;
-    if (Date.now() >= deadline) throw new HistoryBusyError(pid, servedBy(file, urlFile, pid));
-    await new Promise((settle) => setTimeout(settle, 50));
-  }
+    if (next === "claimed") break;
+    if (next === "wait") await new Promise((settle) => setTimeout(settle, 50));
+  }
+  advertise(urlFile, url);
+  let held = true;
+  return () => {
+    if (held && servedBy(file, urlFile, process.pid)) rmSync(urlFile, { force: true });
+    if (held) releaseOwn(file);
+    held = false;
+  };
 }
 var manifest = ".hyperframes/render-outputs.json";
 function readRenderOutputs(projectDir) {

package/dist/{chunk-PF7OWVTL.js → chunk-UNOSCGBG.js}

@@ -6,11 +6,11 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   withOwner
-} from "./chunk-JMFJI26U.js";
+} from "./chunk-O7N3A7PE.js";
 import {
   HistoryBusyError,
   beginArtifactCapture
-} from "./chunk-ICMXC3MI.js";
+} from "./chunk-U6RXZNZE.js";
 
 // src/utils/artifactCapture.ts
 var SKIP_BUSY_HISTORY = { ownerWaitMs: 0 };

package/dist/{chunk-X7CCSMRR.js → chunk-VAK7A2N6.js}

@@ -6,40 +6,40 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveProject
-} from "./chunk-OJDXABUF.js";
+} from "./chunk-TJB4GAV6.js";
 import {
   installPageFunctionGuard,
   resolveCliChromeGpuMode,
   seekCompositionTimeline,
   waitForRuntimeReady
-} from "./chunk-V2UNZ7QP.js";
+} from "./chunk-XOVHO3TT.js";
 import {
   resolveCompositionViewportFromHtml
 } from "./chunk-FH7WODJH.js";
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-IL3GTCQY.js";
+} from "./chunk-GTE5WZAM.js";
 import {
   pageNavigationTimeoutMs
-} from "./chunk-XSRUVMXK.js";
+} from "./chunk-B2SZZFWW.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
 import {
   failCommand,
   setCommandExitCode
-} from "./chunk-PBN6GBJE.js";
+} from "./chunk-JVBRJMOP.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
-import {
-  printDeprecationNotice,
-  withMeta
-} from "./chunk-VAJIPSN6.js";
 import {
   decodeWellFormedEscapes
 } from "./chunk-BSQ7XANM.js";
+import {
+  printDeprecationNotice,
+  withMeta
+} from "./chunk-ANR6WOC3.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -227,7 +227,7 @@ function extractCompositionErrorsFromLint(lintResult) {
 async function localizeRemoteAssets(html) {
   let dir;
   try {
-    const { loadProducer } = await import("./producer-C76CRJ5O.js");
+    const { loadProducer } = await import("./producer-6YM3UH3B.js");
     const { localizeRemoteMediaSources, localizeRemoteImageSources, localizeRemoteFontFaces } = await loadProducer();
     dir = mkdtempSync(join(tmpdir(), "hf-validate-assets-"));
     const assetDir = dir;
@@ -248,10 +248,10 @@ async function localizeRemoteAssets(html) {
 }
 async function validateInBrowser(project, opts) {
   const projectDir = project.dir;
-  const { bundleToSingleHtml } = await import("./compiler-U3W6CJW7.js");
-  const { ensureBrowser } = await import("./manager-V2QCCPOJ.js");
-  const { serveStaticProjectHtml } = await import("./staticProjectServer-GYPUQGI7.js");
-  const { lintProject } = await import("./lintProject-ARKJXDQF.js");
+  const { bundleToSingleHtml } = await import("./compiler-27KQD7KW.js");
+  const { ensureBrowser } = await import("./manager-UHWEKPXC.js");
+  const { serveStaticProjectHtml } = await import("./staticProjectServer-EO7X7RAY.js");
+  const { lintProject } = await import("./lintProject-C2ONSH2U.js");
   const lintResult = await lintProject(projectDir);
   const compositionErrors = extractCompositionErrorsFromLint(lintResult);
   const html = await bundleToSingleHtml(projectDir);
@@ -272,9 +272,9 @@ async function validateInBrowser(project, opts) {
   try {
     const browser = await ensureBrowser();
     const puppeteer = await import("puppeteer-core");
-    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-RDSWHMJS.js");
+    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-EL6HGIS4.js");
     const requestedGpuMode = resolveCliChromeGpuMode();
-    const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalWebGpu } = await import("./gpuPolicy-4NNXESM7.js");
+    const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalWebGpu } = await import("./gpuPolicy-UDJT2MQK.js");
     const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath);
     const requiresWebGpu = compositionRequiresWebGpu(html);
     const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);