hyperframes 0.8.140 → 0.8.142

package/dist/{chunk-EDYBFSPE.js → chunk-6RAD4BCC.js}

@@ -6,13 +6,14 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   refreshIfNeeded
-} from "./chunk-BRITLL56.js";
+} from "./chunk-B4P5VDFQ.js";
 import {
   buildAuthHeaders,
+  envCredentialVar,
   isAuthError,
   isTokenExpired,
   tryResolveCredential
-} from "./chunk-246MOR5U.js";
+} from "./chunk-DKSDVDXG.js";
 import {
   CSS_URL_RE,
   isNonRelativeUrl,
@@ -204,12 +205,9 @@ async function metadataRequestError(response, fallback) {
 }
 var LOGIN_EXPIRED = "Your login expired. Run hyperframes auth login, then publish again.";
 var LOGIN_CHANGED = "Your login changed during publish. Run publish again.";
-var API_KEY_ENV_VAR = { env: "HEYGEN_API_KEY", env_alias: "HYPERFRAMES_API_KEY" };
 function rejectedCredentialMessage(credential) {
-  if (credential.type === "api_key" && (credential.source === "env" || credential.source === "env_alias")) {
-    return `${API_KEY_ENV_VAR[credential.source]} was rejected. Fix or unset it, then publish again.`;
-  }
-  return LOGIN_EXPIRED;
+  const envVar = envCredentialVar(credential.source);
+  return envVar ? `${envVar} was rejected. Fix or unset it, then publish again.` : LOGIN_EXPIRED;
 }
 async function resolvePublishCredential(checked) {
   try {
@@ -637,7 +635,6 @@ export {
   ensureProjectId,
   readTeamProject,
   writeTeamProject,
-  API_KEY_ENV_VAR,
   resolvePublishCredential,
   rewriteHtmlAttributes,
   buildPublishFileMap,

package/dist/{chunk-MTVDXB6S.js → chunk-6UM3R7PP.js}

@@ -6,9 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   firstFrameColourArgs,
+  formatPreviewProxyBox,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-YFT3BL7N.js";
 import {
   mkdirWithinProject,
   realProjectRoot,
@@ -334,7 +335,7 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
   return map;
 }
 
-// ../studio-server/dist/chunk-6RFZWPPN.js
+// ../studio-server/dist/chunk-QP7LKFU2.js
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
 import { existsSync as existsSync2, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, utimesSync } from "fs";
@@ -530,14 +531,15 @@ function canonicalizeProxySource(projectDir, absoluteSourcePath) {
     cacheIdentity: (sourceIsInsideCanonicalProject ? canonicalRelativePath : canonicalSourcePath).normalize("NFC")
   };
 }
-function buildProxyCacheKey(source, variant) {
+function buildProxyCacheKey(source, variant, box) {
   const stat = statSync2(source.sourcePath);
+  const size = box ? `\0${formatPreviewProxyBox(box)}` : "";
   return createHash("sha256").update(
-    `${source.relativePath}\0${source.cacheIdentity}\0${stat.mtimeMs}\0${stat.size}\0${PROXY_PARAMS_VERSION}\0${variant}`
+    `${source.relativePath}\0${source.cacheIdentity}\0${stat.mtimeMs}\0${stat.size}\0${PROXY_PARAMS_VERSION}\0${variant}${size}`
   ).digest("hex");
 }
-function getCanonicalProxyCachePath(source, variant) {
-  const key = buildProxyCacheKey(source, variant);
+function getCanonicalProxyCachePath(source, variant, box) {
+  const key = buildProxyCacheKey(source, variant, box);
   return join2(
     source.projectDir,
     CACHE_DIR_NAME,
@@ -620,7 +622,13 @@ function rememberFailure(cachePath, error) {
     failedTranscodes.delete(oldest);
   }
 }
-async function runFfmpeg(sourcePath, outputPath, variant) {
+function proxyScaleFilter(box) {
+  if (!box) return "scale=trunc(iw/2)*2:trunc(ih/2)*2";
+  const factor = `min(1\\,max(${box.width}/iw\\,${box.height}/ih))`;
+  const side = (d) => `min(trunc(${d}/2)*2\\,ceil(${d}*${factor}/2)*2)`;
+  return `scale=${side("iw")}:${side("ih")}`;
+}
+async function runFfmpeg(sourcePath, outputPath, variant, box) {
   const metadata = await probeMediaMetadata(sourcePath);
   const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
   if (!ffmpegPath) {
@@ -631,7 +639,7 @@ async function runFfmpeg(sourcePath, outputPath, variant) {
   const toneMap = (hdrTransfer === "pq" || hdrTransfer === "hlg") && !keepsAlpha;
   if (toneMap) await ensureHdrFilters(ffmpegPath);
   const firstFrame = toneMap ? await probeFirstFrameColour(sourcePath) : {};
-  const evenScale = "scale=trunc(iw/2)*2:trunc(ih/2)*2";
+  const evenScale = proxyScaleFilter(box);
   const pixelFormat = keepsAlpha ? "yuva420p" : "yuv420p";
   const videoFilter = toneMap ? [
     hdrToSdrToneMapFilter(metadata.color, firstFrame),
@@ -721,7 +729,7 @@ async function runFfmpeg(sourcePath, outputPath, variant) {
     });
   });
 }
-async function transcodeToCache(projectDir, absoluteSourcePath, cachePath, variant) {
+async function transcodeToCache(projectDir, absoluteSourcePath, cachePath, variant, box) {
   await acquireSlot();
   try {
     if (existsSync2(cachePath)) return cachePath;
@@ -729,7 +737,7 @@ async function transcodeToCache(projectDir, absoluteSourcePath, cachePath, varia
     mkdirWithinProject(projectDir, cacheDir);
     const tempPath = join2(cacheDir, `.tmp-${randomUUID()}-${basename(cachePath)}`);
     try {
-      await runFfmpeg(absoluteSourcePath, tempPath, variant);
+      await runFfmpeg(absoluteSourcePath, tempPath, variant, box);
       renameSync(tempPath, cachePath);
       maintainProxyCache(cacheDir);
       return cachePath;
@@ -747,9 +755,9 @@ function proxyActivityMark(projectDir) {
   for (const cachePath of inFlight.keys()) if (cachePath.startsWith(cacheDir)) return null;
   return String(settledProxyCount);
 }
-async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264") {
+async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", box) {
   const source = canonicalizeProxySource(projectDir, absoluteSourcePath);
-  const cachePath = getCanonicalProxyCachePath(source, variant);
+  const cachePath = getCanonicalProxyCachePath(source, variant, box);
   if (existsSync2(cachePath)) {
     markCacheEntryUsed(cachePath);
     maintainProxyCache(dirname(cachePath));
@@ -762,7 +770,7 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264") {
   }
   const existing = inFlight.get(cachePath);
   if (existing) return existing;
-  const promise = transcodeToCache(source.projectDir, source.sourcePath, cachePath, variant).catch((err) => {
+  const promise = transcodeToCache(source.projectDir, source.sourcePath, cachePath, variant, box).catch((err) => {
     if (!(err instanceof ProxyCapacityError)) rememberFailure(cachePath, err);
     throw err;
   }).finally(() => {

package/dist/{chunk-IRBESGJ7.js → chunk-6UYZB4TY.js}

@@ -16,7 +16,7 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-YFT3BL7N.js";
 import {
   extractCompositionMetadata
 } from "./chunk-OZUQF4NB.js";

package/dist/{chunk-VVJFZU6B.js → chunk-75JJVANE.js}

@@ -8,14 +8,14 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-5IKJONRY.js";
+} from "./chunk-QXPCARFE.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-YFT3BL7N.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-F3SPK6SO.js → chunk-7FCDA4RH.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6IHWCZ3W.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-LQG6GPVK.js";
+} from "./chunk-FWRNQOLT.js";
 import {
   DEFAULT_MODEL,
   ensureModel,

package/dist/{chunk-R4QIE6UY.js → chunk-7M4KAPAA.js}

@@ -3288,6 +3288,38 @@ function withPageText(url, fontText) {
   return `${withoutFragment}${joiner}text=${encodeURIComponent(fontText)}${parsed.hash}`;
 }
 
+// ../core/dist/fonts/fontDiagnostics.js
+var FontDiagCollector = class {
+  families = [];
+  current;
+  beginFamily(required) {
+    this.current = { required, resolved: false, attempts: [] };
+    this.families.push(this.current);
+  }
+  endFamily(resolved) {
+    if (this.current)
+      this.current.resolved = resolved;
+    this.current = void 0;
+  }
+  startAttempt(path, urlSource, textParam) {
+    const attempt = {
+      path,
+      urlSource,
+      textParam,
+      cssCache: "fresh",
+      cssStatus: null,
+      blocksTotal: 0,
+      regexMatches: 0,
+      assets: { total: 0, diskCacheHit: 0, fetchedOk: 0, nonOk: {} }
+    };
+    this.current?.attempts.push(attempt);
+    return attempt;
+  }
+  snapshot() {
+    return { families: this.families };
+  }
+};
+
 // ../core/dist/fonts/deterministicFonts.js
 var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
   "sans-serif",
@@ -3782,7 +3814,7 @@ async function bundledFamilyFaceRules(canonical, normalizedFamily, emitFamily, o
     coveredWeights.add(coverageKey(face.weight, style));
   }
   const canonicalFamily = resolveAliasDisplayName(normalizedFamily);
-  const googleFaces = canonicalFamily ? await fetchFamilyFaces(canonicalFamily, optional, options, fontText) : [];
+  const googleFaces = canonicalFamily ? await fetchFamilyFaces(canonicalFamily, "bundled_supplement", optional, options, fontText) : [];
   const supplementary = googleFaces.filter((face) => !coveredWeights.has(coverageKey(face.weight, face.style)) || !isBundledSubsetRange(face.unicodeRange));
   const runs = groupFacesBySource(supplementary).flatMap((group) => partitionWeightRuns(group, coveredWeights));
   const firstAppearance = (run) => Math.min(...run.map((face) => supplementary.indexOf(face)));
@@ -3798,7 +3830,7 @@ async function bundledFamilyFaceRules(canonical, normalizedFamily, emitFamily, o
   return rules;
 }
 async function googleFamilyFaceRules(lookupFamily, emitFamily, optional, options, fontText) {
-  const googleFaces = await fetchFamilyFaces(lookupFamily, optional, options, fontText);
+  const googleFaces = await fetchFamilyFaces(lookupFamily, "direct_google", optional, options, fontText);
   if (googleFaces.length === 0)
     return null;
   return googleFaces.map((face) => buildFontFaceRule(emitFamily, face.dataUri, face.weight, face.style, face.unicodeRange));
@@ -3974,8 +4006,10 @@ async function buildFontFaceCss(requestedFamilies, options, declaredFamilies, fo
   const unresolved = [];
   const requiredFirst = [...requestedFamilies].sort(([, a], [, b]) => Number(a.optional) - Number(b.optional));
   for (const [normalizedFamily, { family: originalCaseFamily, optional }] of requiredFirst) {
+    options.diag.beginFamily(!optional);
     const familyRules = await resolveFamilyFaceRules(normalizedFamily, originalCaseFamily, originalCaseFamily, optional, options, fontText) ?? // Last, so a family that already resolves keeps exactly the faces it had.
     await resolveDeclaredFamilyAlias(originalCaseFamily, declaredFamilies(), optional, options, fontText);
+    options.diag.endFamily(Boolean(familyRules));
     if (familyRules) {
       rules.push(...familyRules);
       continue;
@@ -4179,22 +4213,30 @@ async function fetchFontResource(url, init, readBody, familyName, what, options)
   }
   throw fontFetchError(familyName, url, what, lastCause, true);
 }
-async function ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options) {
+async function ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options, tally) {
+  tally.total += 1;
   try {
-    return `data:font/woff2;base64,${readFileSync2(cachePath).toString("base64")}`;
+    const cached = `data:font/woff2;base64,${readFileSync2(cachePath).toString("base64")}`;
+    tally.diskCacheHit += 1;
+    return cached;
   } catch {
   }
   const woff2What = `Google Fonts woff2 (${weight}/${style})`;
   try {
     const fontResult = await fetchFontResource(woff2Url, void 0, (response) => response.arrayBuffer(), familyName, woff2What, options);
-    if (!fontResult.ok)
+    if (!fontResult.ok) {
+      const status = String(fontResult.response.status);
+      tally.nonOk[status] = (tally.nonOk[status] ?? 0) + 1;
       return null;
+    }
     writeFileSync2(cachePath, Buffer.from(fontResult.body), { flag: "wx", mode: 420 });
+    tally.fetchedOk += 1;
   } catch (err) {
     throwIfCallerAborted(options.abortSignal);
     if (err instanceof FontFetchError)
       throw err;
     if (err.code === "EEXIST") {
+      tally.diskCacheHit += 1;
     } else if (options.failClosedFontFetch) {
       throw fontFetchError(familyName, woff2Url, woff2What, { error: err });
     } else {
@@ -4218,17 +4260,18 @@ function raceAgainstAbort(promise, signal) {
     promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
   });
 }
-function fetchGoogleFontCss(url, familyName, options) {
+function fetchGoogleFontCss(url, familyName, options, attempt) {
   const mode = options.failClosedFontFetch ? `closed${options.retryPolicy.maxAttempts}` : "open";
   const key = `${mode}:${url}`;
   let shared = googleFontCssCache.get(key);
+  attempt.cssCache = shared ? "hit" : "fresh";
   if (!shared) {
     shared = fetchFontResource(url, { headers: { "User-Agent": WOFF2_USER_AGENT } }, (response) => response.text(), familyName, "Google Fonts CSS", { ...options, abortSignal: void 0 }).then((result) => {
       if (result.ok)
-        return { ok: true, body: result.body };
+        return { ok: true, body: result.body, status: result.response.status };
       if (isRetryableFontFetchStatus(result.response.status))
         googleFontCssCache.delete(key);
-      return { ok: false };
+      return { ok: false, status: result.response.status };
     });
     googleFontCssCache.set(key, shared);
     shared.catch(() => googleFontCssCache.delete(key));
@@ -4242,28 +4285,39 @@ function declaredFaceFamily(block) {
   const found = /font-family:\s*['"]([^'"]+)['"]/i.exec(block);
   return found?.[1];
 }
-async function fetchGoogleFont(familyName, options, fontText) {
+async function fetchGoogleFont(familyName, path, options, fontText) {
   const googleFamilyName = familyName.replace(/\+/g, " ");
   const encodedFamily = encodeURIComponent(googleFamilyName);
   const textParam = fontText ? `&text=${encodeURIComponent(fontText)}` : "";
   const normalizedFamily = normalizeFamilyName(googleFamilyName);
   const authoredStylesheet = FONT_ALIASES[normalizedFamily] ? void 0 : options.authoredStylesheets.get(normalizedFamily);
-  const urls = authoredStylesheet ? authoredStylesheet.map((url) => withPageText(url, fontText)) : [
-    `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,700${textParam}`
-  ];
+  const defaultUrl = `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,700${textParam}`;
+  const fetchStylesheet = (url, urlSource) => fetchGoogleFontStylesheet(googleFamilyName, url, options, options.diag.startAttempt(path, urlSource, /[?&]text=/.test(url) ? "present" : "absent"));
+  if (!authoredStylesheet) {
+    return (await fetchStylesheet(defaultUrl, "default")).faces;
+  }
   const faces = [];
-  for (const url of urls) {
-    faces.push(...await fetchGoogleFontStylesheet(googleFamilyName, url, options));
+  const outcomes = [];
+  for (const url of authoredStylesheet) {
+    const result = await fetchStylesheet(withPageText(url, fontText), "authored");
+    faces.push(...result.faces);
+    if (result.faces.length === 0)
+      outcomes.push(result.status ? `http_${result.status}` : "no_faces");
   }
-  return faces;
+  if (faces.length > 0)
+    return faces;
+  const fallback = (await fetchStylesheet(defaultUrl, "default")).faces;
+  options.log.warn(`[Compiler] google_font_link_fallback family="${familyName}" link_outcomes=${outcomes.join(",")} fallback_faces=${fallback.length}`);
+  return fallback;
 }
-async function readGoogleFontStylesheet(familyName, url, options) {
+async function readGoogleFontStylesheet(familyName, url, options, attempt) {
   try {
-    const cssResult = await fetchGoogleFontCss(url, familyName, options);
+    const cssResult = await fetchGoogleFontCss(url, familyName, options, attempt);
+    attempt.cssStatus = cssResult.status;
     if (!cssResult.ok) {
-      return null;
+      return { css: null, status: cssResult.status };
     }
-    return cssResult.body;
+    return { css: cssResult.body };
   } catch (err) {
     throwIfCallerAborted(options.abortSignal);
     if (err instanceof FontFetchError)
@@ -4271,7 +4325,7 @@ async function readGoogleFontStylesheet(familyName, url, options) {
     if (options.failClosedFontFetch) {
       throw fontFetchError(familyName, url, "Google Fonts CSS", { error: err });
     }
-    return null;
+    return { css: null };
   }
 }
 function parseGoogleFontSource(match, familyName) {
@@ -4288,34 +4342,37 @@ function parseGoogleFontSource(match, familyName) {
     unicodeRange: match[4]?.trim() || void 0
   };
 }
-async function fetchGoogleFontStylesheet(familyName, url, options) {
+async function fetchGoogleFontStylesheet(familyName, url, options, attempt) {
   const slug = fontSlug(familyName);
-  const cssText = await readGoogleFontStylesheet(familyName, url, options);
-  if (!cssText)
-    return [];
+  const read = await readGoogleFontStylesheet(familyName, url, options, attempt);
+  if (read.css === null)
+    return { faces: [], status: read.status };
+  const cssText = read.css;
+  attempt.blocksTotal = (cssText.match(/@font-face\s*\{/gi) ?? []).length;
   const faceRegex = /@font-face\s*\{[^}]*font-style:\s*(normal|italic|oblique(?:\s+-?\d+(?:\.\d+)?deg){0,2})\s*;[^}]*font-weight:\s*(\d+(?:\s+\d+)?)[^}]*src:\s*url\(([^)]+)\)\s*format\(['"]woff2['"]\)(?:[^}]*?unicode-range:\s*([^;}]+))?[^}]*\}/gi;
   const faces = [];
   for (const match of cssText.matchAll(faceRegex)) {
+    attempt.regexMatches += 1;
     const source = parseGoogleFontSource(match, familyName);
     if (!source)
       continue;
     const { weight, style, unicodeRange, url: woff2Url } = source;
     const cachePath = cachedWoff2Path(slug, weight, style, subsetToken(woff2Url));
-    const dataUri = await ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options);
+    const dataUri = await ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options, attempt.assets);
     if (dataUri)
       faces.push({ weight, style, dataUri, unicodeRange });
   }
   if (faces.length > 0) {
     options.log.info(`[Compiler] Fetched ${faces.length} font face(s) for "${familyName}" from Google Fonts (cached to ${fontCacheDir(slug)})`);
   }
-  return faces;
+  return { faces };
 }
-async function fetchFamilyFaces(familyName, optional, options, fontText) {
+async function fetchFamilyFaces(familyName, path, optional, options, fontText) {
   if (!optional)
-    return fetchGoogleFont(familyName, options, fontText);
+    return fetchGoogleFont(familyName, path, options, fontText);
   const maxAttempts = Math.min(options.retryPolicy.maxAttempts, 2);
   try {
-    return await fetchGoogleFont(familyName, { ...options, retryPolicy: { ...options.retryPolicy, maxAttempts } }, fontText);
+    return await fetchGoogleFont(familyName, path, { ...options, retryPolicy: { ...options.retryPolicy, maxAttempts } }, fontText);
   } catch (err) {
     if (!(err instanceof FontFetchUnavailableError))
       throw err;
@@ -4456,6 +4513,7 @@ function placeAfterEveryStylesheet(document2, head, styleEl) {
     head.appendChild(styleEl);
 }
 async function injectDeterministicFontFaces(html, options = {}) {
+  const diag = new FontDiagCollector();
   const failClosedFontFetch = options.failClosedFontFetch === true;
   const fetchImpl = options.fetchImpl ?? fetch;
   const allowSystemFontCapture = options.allowSystemFontCapture !== false;
@@ -4468,7 +4526,8 @@ async function injectDeterministicFontFaces(html, options = {}) {
     abortSignal: options.abortSignal,
     retryPolicy,
     retryDeadlineMs: Date.now() + retryPolicy.maxElapsedMs,
-    authoredStylesheets: authoredGoogleFontStylesheets(html)
+    authoredStylesheets: authoredGoogleFontStylesheets(html),
+    diag
   };
   const existingFaces = extractExistingFontFaces(html);
   const requestedFamilies = extractRequestedFontFamilies(html);
@@ -4485,7 +4544,9 @@ async function injectDeterministicFontFaces(html, options = {}) {
   const { css, unresolved } = await buildFontFaceCss(pendingFamilies, fetchOptions, () => declaredFamilies ??= collectDeclaredFontFamilies(html), extractGoogleFontsText(html));
   const required = unresolved.filter((family) => !pendingFamilies.get(family.toLowerCase())?.optional);
   if (required.length > 0 && options.failClosedFontFetch) {
-    throw new FontFetchError(required.join(", "), "", `[Compiler] Unresolved fonts in fail-closed mode: ${required.join(", ")}. Distributed renders require all fonts to be resolvable.`, void 0, FONT_FETCH_FAILED, unresolved);
+    const unresolvedError = new FontFetchError(required.join(", "), "", `[Compiler] Unresolved fonts in fail-closed mode: ${required.join(", ")}. Distributed renders require all fonts to be resolvable.`, void 0, FONT_FETCH_FAILED, unresolved);
+    unresolvedError.diagnostics = diag.snapshot();
+    throw unresolvedError;
   }
   if (!css) {
     if (unresolved.length > 0) {

package/dist/{chunk-HKCNZITN.js → chunk-AM5L5YIA.js}

@@ -8,7 +8,7 @@ import {
   forceRefreshCredentials,
   resolveCloudAuthHeaders,
   resolveCloudBaseUrl
-} from "./chunk-BRITLL56.js";
+} from "./chunk-B4P5VDFQ.js";
 import {
   errorBox
 } from "./chunk-IHFUKJOR.js";

package/dist/{chunk-BRITLL56.js → chunk-B4P5VDFQ.js}

@@ -9,7 +9,7 @@ import {
   buildAuthHeaders,
   refreshTokens,
   resolveCredential
-} from "./chunk-246MOR5U.js";
+} from "./chunk-DKSDVDXG.js";
 
 // src/cloud/auth.ts
 async function resolveCloudAuthHeaders() {

package/dist/{chunk-2GMKWYEH.js → chunk-B6SMSALD.js}

@@ -6,24 +6,24 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   serveStaticProjectHtml
-} from "./chunk-PFJFHNU3.js";
+} from "./chunk-LQASVU3I.js";
 import {
   resolveProject
-} from "./chunk-PB3P4MKP.js";
+} from "./chunk-LJAU4TPS.js";
 import {
   AUDIT_SEEK_OPTIONS,
   installPageFunctionGuard,
   seekCompositionTimeline,
   waitForCompositionFonts,
   waitForRuntimeReady
-} from "./chunk-KFQNMY36.js";
+} from "./chunk-WSGY5CDQ.js";
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-BQKEGPPL.js";
+} from "./chunk-OSUKETIH.js";
 import {
   resolveDiagnosticNavigationTimeoutMs
-} from "./chunk-TYT2TLJR.js";
+} from "./chunk-TY6XOHEM.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -34,7 +34,7 @@ import {
 import {
   printDeprecationNotice,
   withMeta
-} from "./chunk-DDQ4LOML.js";
+} from "./chunk-JLKMWY2T.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -47,6 +47,36 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 
+// src/utils/checkFindings.ts
+var SEVERITY = { info: 0, warning: 1, error: 2 };
+function findingElementKey(finding) {
+  return JSON.stringify([finding.sourceFile, finding.selector]);
+}
+function groupSampledFindings(findings, compareEvidence = () => 0) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const key = JSON.stringify([findingElementKey(finding), finding.code]);
+    const times = finding.times ?? [finding.time];
+    const group = groups.get(key);
+    if (!group) {
+      groups.set(key, { finding, times: new Set(times) });
+      continue;
+    }
+    for (const time of times) group.times.add(time);
+    const severity = SEVERITY[finding.severity] - SEVERITY[group.finding.severity];
+    if (severity > 0 || severity === 0 && compareEvidence(finding, group.finding) > 0) {
+      group.finding = finding;
+    }
+  }
+  return [...groups.values()].map(({ finding, times }) => ({
+    ...finding,
+    times: [...times].sort((a, b) => a - b)
+  }));
+}
+function formatFindingTimes(finding) {
+  return `t=${(finding.times ?? [finding.time]).join(", ")}s`;
+}
+
 // src/utils/layoutAudit.ts
 function buildLayoutSampleTimes({ duration, samples, at }) {
   if (at?.length) {
@@ -73,7 +103,12 @@ function summarizeLayoutIssues(issues) {
   };
 }
 function formatLayoutIssue(issue) {
-  const timeLabel = issue.occurrences && issue.occurrences > 1 ? `t=${formatNumber(issue.firstSeen ?? issue.time)}-${formatNumber(issue.lastSeen ?? issue.time)}s (${issue.occurrences} samples)` : `t=${formatNumber(issue.time)}s`;
+  let timeLabel = `t=${formatNumber(issue.time)}s`;
+  if (issue.times) {
+    timeLabel = formatFindingTimes(issue);
+  } else if (issue.occurrences && issue.occurrences > 1) {
+    timeLabel = `t=${formatNumber(issue.firstSeen ?? issue.time)}-${formatNumber(issue.lastSeen ?? issue.time)}s (${issue.occurrences} samples)`;
+  }
   const parts = [
     timeLabel,
     issue.code,
@@ -91,6 +126,7 @@ function dedupeLayoutIssues(issues) {
   const result = [];
   for (const issue of issues) {
     const key = [
+      Reflect.get(issue, "sourceFile") ?? "",
       issue.code,
       issue.severity,
       issue.time.toFixed(3),
@@ -152,11 +188,11 @@ function collapseStaticLayoutIssues(issues, totalSampleCount) {
     ({ issue, firstSeen, lastSeen, occurrences, times }) => applyPersistenceTier(
       {
         ...issue,
-        time: firstSeen,
         firstSeen,
         lastSeen,
         occurrences,
-        heldMs: longestContiguousRunMs(times)
+        heldMs: longestContiguousRunMs(times),
+        times: [...new Set(times)].sort((a, b) => a - b)
       },
       multiSampleRun
     )
@@ -234,6 +270,7 @@ function severityRank(severity) {
 }
 function staticIssueKey(issue) {
   return [
+    Reflect.get(issue, "sourceFile") ?? "",
     issue.code,
     issue.severity,
     issue.selector,
@@ -670,7 +707,7 @@ async function collectTweenBoundaries(page) {
   });
 }
 async function bundleProjectHtml(projectDir) {
-  const { bundleToSingleHtml } = await import("./compiler-RTU3KTLF.js");
+  const { bundleToSingleHtml } = await import("./compiler-VTH2D3ID.js");
   return bundleToSingleHtml(projectDir);
 }
 async function alignViewportToComposition(page, url) {
@@ -692,8 +729,8 @@ async function alignViewportToComposition(page, url) {
 async function runLayoutAudit(projectDir, opts) {
   const { ensureBrowser } = await import("./manager-CT3D67CG.js");
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-7SSERHNP.js");
-  const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalBrowserGpuMode } = await import("./gpuPolicy-A45VSUKR.js");
+  const { buildChromeArgs } = await import("./src-3I3RH3V5.js");
+  const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalBrowserGpuMode } = await import("./gpuPolicy-LCBWVGEH.js");
   const html = await bundleProjectHtml(projectDir);
   const server = await serveStaticProjectHtml(
     projectDir,
@@ -1056,10 +1093,14 @@ function createInspectCommand(commandName) {
 var layout_default = createInspectCommand("layout");
 
 export {
+  findingElementKey,
+  groupSampledFindings,
+  formatFindingTimes,
   buildLayoutSampleTimes,
   formatLayoutIssue,
   dedupeLayoutIssues,
   collapseStaticLayoutIssues,
+  longestContiguousRunMs,
   limitLayoutIssues,
   buildTransitionSampleTimes,
   mergeSampleTimes,

package/dist/{chunk-DQNOPYAG.js → chunk-BPZVDBHY.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   VERSION
-} from "./chunk-MUINFURL.js";
+} from "./chunk-DZEVA7DI.js";
 
 // src/registry/compatibility.ts
 import { compareVersions } from "compare-versions";