hyperframes 0.8.139 → 0.8.141

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-25DHUDOK.js → chunk-7XTZVLE6.js}

@@ -8,16 +8,16 @@ import {
   flush,
   shouldTrack,
   trackEvent
-} from "./chunk-7SI7GCX6.js";
+} from "./chunk-RCFCZT5O.js";
 import {
   getPowerState
-} from "./chunk-PLNWWGE7.js";
+} from "./chunk-GQJZORQP.js";
 import {
   CliRuntimeError
 } from "./chunk-PBN6GBJE.js";
 import {
   redactTelemetryString
-} from "./chunk-EJ7OWYF2.js";
+} from "./chunk-T76PLPD6.js";
 import {
   readConfig
 } from "./chunk-XUXGIA7H.js";
@@ -486,6 +486,14 @@ function trackHistoryAction(props) {
 function trackSkillsInstallSkipped(props) {
   trackEvent("cli skill install skipped", { reason: props.reason });
 }
+function trackFeedbackComment(props) {
+  trackEvent("cli_feedback_comment", {
+    comment: props.comment,
+    ...props.doctorSummary ? { doctor_summary: props.doctorSummary } : {},
+    ...props.feedbackId ? { feedback_id: props.feedbackId } : {},
+    ...props.recentRenderIds?.length ? { recent_render_ids: props.recentRenderIds.join(",") } : {}
+  });
+}
 function trackRenderFeedback(props) {
   trackEvent("cli_render_feedback", {
     rating: props.rating,
@@ -592,6 +600,7 @@ export {
   trackCompareSheet,
   trackHistoryAction,
   trackSkillsInstallSkipped,
+  trackFeedbackComment,
   trackRenderFeedback,
   trackCatalogSearchMiss,
   trackCommandResult,

package/dist/chunk-A4KQZXZI.js

@@ -0,0 +1,116 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  parseHTML
+} from "./chunk-GK4AIFIH.js";
+
+// ../parsers/dist/hfIds.js
+var EXCLUDED_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "template",
+  "meta",
+  "link",
+  "noscript",
+  "base"
+]);
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function toHfId(hash) {
+  const s = (hash >>> 0).toString(36);
+  const four = s.length >= 4 ? s.slice(-4) : s.padStart(4, "0");
+  return `hf-${four}`;
+}
+function ownText(el) {
+  let text = "";
+  el.childNodes.forEach((n) => {
+    if (n.nodeType === 3) text += n.nodeValue ?? "";
+  });
+  return text.trim();
+}
+function getContractAttribute(el, name) {
+  return Array.from(el.attributes).find((attr) => attr.name.toLowerCase() === name)?.value ?? null;
+}
+function contentKey(el) {
+  const attrs = Array.from(el.attributes).filter((a) => !a.name.toLowerCase().startsWith("data-hf-")).map((a) => `${a.name.toLowerCase()}\0${a.value}`).sort().join("
");
+  return `${el.tagName.toLowerCase()}|${attrs}|${ownText(el)}`;
+}
+function mintHfId(el, assigned) {
+  const key = contentKey(el);
+  let id = toHfId(fnv1a(key));
+  let dup = 0;
+  while (assigned.has(id)) {
+    dup += 1;
+    if (dup > 1e4) {
+      id = `hf-${(fnv1a(key) >>> 0).toString(36)}-${dup}`;
+      break;
+    }
+    id = toHfId(fnv1a(`${key}#${dup}`));
+  }
+  assigned.add(id);
+  return id;
+}
+function getChildElements(parent) {
+  const directChildren = Array.from(parent.children);
+  if (directChildren.length || parent.tagName.toLowerCase() !== "template") return directChildren;
+  const content = parent.content;
+  if (content?.children.length) return Array.from(content.children);
+  return directChildren;
+}
+function isCompositionTemplate(el) {
+  if (el.tagName.toLowerCase() !== "template") return false;
+  if (getContractAttribute(el, "data-composition-id") !== null) return true;
+  for (const child of getChildElements(el)) {
+    if (getContractAttribute(child, "data-composition-id") !== null) return true;
+  }
+  return false;
+}
+function walkCompositionDescendants(root, visit) {
+  const rootElement = root.nodeType === 9 ? root.documentElement : root;
+  if (!rootElement) return;
+  const walk = (parent) => {
+    for (const child of getChildElements(parent)) {
+      const isTemplate = child.tagName.toLowerCase() === "template";
+      if (isTemplate && !isCompositionTemplate(child)) continue;
+      visit(child);
+      walk(child);
+    }
+  };
+  walk(rootElement);
+}
+function assignHfIds(body) {
+  const assigned = /* @__PURE__ */ new Set();
+  walkCompositionDescendants(body, (el) => {
+    const existing = getContractAttribute(el, "data-hf-id");
+    if (existing) assigned.add(existing);
+  });
+  walkCompositionDescendants(body, (el) => {
+    if (EXCLUDED_TAGS.has(el.tagName.toLowerCase())) return;
+    if (getContractAttribute(el, "data-hf-id")) return;
+    el.setAttribute("data-hf-id", mintHfId(el, assigned));
+  });
+}
+function ensureHfIds(html) {
+  const wrapped = !/<!doctype|<html[\s>]/i.test(html);
+  const { document } = wrapped ? parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`) : parseHTML(html);
+  if (!document.body) return html;
+  assignHfIds(document.body);
+  return wrapped ? document.body.innerHTML || "" : document.toString();
+}
+
+export {
+  EXCLUDED_TAGS,
+  mintHfId,
+  walkCompositionDescendants,
+  ensureHfIds
+};

package/dist/{chunk-DUQJF7FK.js → chunk-A7YQNIQT.js}

@@ -4,23 +4,23 @@ import { dirname as __hf_dirname } from "node:path";
 var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
+import {
+  EXCLUDED_TAGS,
+  ensureHfIds,
+  mintHfId,
+  walkCompositionDescendants
+} from "./chunk-A4KQZXZI.js";
 import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-EJ7OWYF2.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   removeElementWithGsapCascade
 } from "./chunk-OZUQF4NB.js";
-import {
-  EXCLUDED_TAGS,
-  ensureHfIds,
-  mintHfId,
-  walkCompositionDescendants
-} from "./chunk-GWV2Y36Q.js";
 import {
   require_dist
-} from "./chunk-STA43FMY.js";
+} from "./chunk-24OWOBQH.js";
 import {
   readClipTiming,
   readMediaOffsetSeconds,

package/dist/{chunk-XOZ3J3LB.js → chunk-AVWEIOEN.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-HVW7ABXD.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-GIDHR5OL.js";
+} from "./chunk-Q65ZQFF2.js";
 
 // src/utils/projectConfig.ts
 import { readFileSync, writeFileSync } from "fs";

package/dist/{chunk-UQXOHEQ7.js → chunk-BM5PX3DJ.js}

@@ -10,19 +10,19 @@ import {
 import {
   ensureDOMParser
 } from "./chunk-PFCFR3KZ.js";
-import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
 import {
   failCommand
 } from "./chunk-PBN6GBJE.js";
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-EJ7OWYF2.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   extractCompositionMetadata
 } from "./chunk-OZUQF4NB.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
 
 // src/utils/variables.ts
 import { readFileSync } from "fs";

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

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

package/dist/{chunk-JX7Y57YY.js → chunk-E4BSCXMU.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-6T7M2VCO.js");
+        const { trackCommandFailure } = await import("./events-YFFXKAQQ.js");
         trackCommandFailure(
           command,
           err,