hyperframes 0.8.140 → 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-JSGANFFH.js → chunk-7XTZVLE6.js}

@@ -8,7 +8,7 @@ import {
   flush,
   shouldTrack,
   trackEvent
-} from "./chunk-C2JUHIG5.js";
+} from "./chunk-RCFCZT5O.js";
 import {
   getPowerState
 } from "./chunk-GQJZORQP.js";

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

@@ -14,7 +14,7 @@ import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   removeElementWithGsapCascade
 } from "./chunk-OZUQF4NB.js";

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

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

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

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

package/dist/{chunk-WKTHUC2R.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-7VJJGC3D.js");
+        const { trackCommandFailure } = await import("./events-YFFXKAQQ.js");
         trackCommandFailure(
           command,
           err,

package/dist/{chunk-TPECLKPA.js → chunk-E6SDW5FV.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -55,7 +55,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-B3I3XJ47.js";
+} from "./chunk-SYKKFAUW.js";
 import {
   clampAudioGain,
   isAudibleVideoElement

package/dist/{chunk-TYT2TLJR.js → chunk-EKA4ZZBI.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-PBN6GBJE.js";
 import {
   parseFps
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-6E6CM7WS.js";
 
 // src/browser/windowsCrash.ts
 var STATUS_STACK_BUFFER_OVERRUN_DEC = "3221225595";

package/dist/{chunk-IFY57LUW.js → chunk-GS6FE3IW.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   updateNoticesSuppressed
-} from "./chunk-DDQ4LOML.js";
+} from "./chunk-IYFKBFTW.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";

package/dist/{chunk-ASW6NWON.js → chunk-IKVBTDLO.js}

@@ -8,7 +8,7 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemManifest,
   fetchRegistryManifest
-} from "./chunk-5IKJONRY.js";
+} from "./chunk-Q65ZQFF2.js";
 
 // src/registry/resolver.ts
 function defaultWarn(message) {

package/dist/{chunk-SLEPCESN.js → chunk-INI3TM6I.js}

@@ -8,10 +8,10 @@ import {
   DEFAULT_VP9_CPU_USED,
   isHttpUrl,
   runFfmpeg
-} from "./chunk-TPECLKPA.js";
+} from "./chunk-E6SDW5FV.js";
 import {
   parseAnimatedGifMetadata
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   parseHTML
 } from "./chunk-GK4AIFIH.js";

package/dist/{chunk-2GMKWYEH.js → chunk-IO7ZIDRP.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-34TXESM7.js";
 import {
   resolveProject
-} from "./chunk-PB3P4MKP.js";
+} from "./chunk-TC2FBZJZ.js";
 import {
   AUDIT_SEEK_OPTIONS,
   installPageFunctionGuard,
   seekCompositionTimeline,
   waitForCompositionFonts,
   waitForRuntimeReady
-} from "./chunk-KFQNMY36.js";
+} from "./chunk-XDSOIJC3.js";
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-BQKEGPPL.js";
+} from "./chunk-O3SKIXQK.js";
 import {
   resolveDiagnosticNavigationTimeoutMs
-} from "./chunk-TYT2TLJR.js";
+} from "./chunk-EKA4ZZBI.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -34,7 +34,7 @@ import {
 import {
   printDeprecationNotice,
   withMeta
-} from "./chunk-DDQ4LOML.js";
+} from "./chunk-IYFKBFTW.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -670,7 +670,7 @@ async function collectTweenBoundaries(page) {
   });
 }
 async function bundleProjectHtml(projectDir) {
-  const { bundleToSingleHtml } = await import("./compiler-RTU3KTLF.js");
+  const { bundleToSingleHtml } = await import("./compiler-ACHWOU5N.js");
   return bundleToSingleHtml(projectDir);
 }
 async function alignViewportToComposition(page, url) {
@@ -692,8 +692,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-I7UC3JTL.js");
+  const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalBrowserGpuMode } = await import("./gpuPolicy-LYOVBAJP.js");
   const html = await bundleProjectHtml(projectDir);
   const server = await serveStaticProjectHtml(
     projectDir,

package/dist/{chunk-F3SPK6SO.js → chunk-IV7EI5E2.js}

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

package/dist/{chunk-DDQ4LOML.js → chunk-IYFKBFTW.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-ISN5GRYI.js";
 import {
   VERSION
-} from "./chunk-MUINFURL.js";
+} from "./chunk-W6HTOVHU.js";
 
 // src/utils/updateCheck.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-PE2I3AFA.js → chunk-J5IPIQU2.js}

@@ -13,7 +13,7 @@ function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCE
   return "auto";
 }
 async function resolveCaptureBrowserGpuMode(requestedMode, chromePath) {
-  const { resolveBrowserGpuMode } = await import("./src-7SSERHNP.js");
+  const { resolveBrowserGpuMode } = await import("./src-I7UC3JTL.js");
   return resolveBrowserGpuMode(requestedMode, { chromePath });
 }
 

package/dist/{chunk-L2H2L22P.js → chunk-K2GOFLTX.js}

@@ -20,7 +20,7 @@ import {
   typeDirPath,
   updateRecord,
   withFigmaErrors
-} from "./chunk-WKTHUC2R.js";
+} from "./chunk-E4BSCXMU.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -221,7 +221,7 @@ var asset_default = defineCommand({
           rendered > 0 ? `(${results.length} nodes, ${rendered} rendered in 1 figma request)` : `(${results.length} nodes, all reused from cache \u2014 no figma request)`
         );
       }
-      const { trackFigmaImport } = await import("./telemetry-7AO77PMH.js");
+      const { trackFigmaImport } = await import("./telemetry-65LFHIWH.js");
       trackFigmaImport({
         phase: "asset",
         reused: results.every((r) => r.reused),

package/dist/{chunk-X3X3VETN.js → chunk-KFH6UD26.js}

@@ -32,18 +32,18 @@ import {
 } from "./chunk-S3S4TGEH.js";
 import {
   resolveExtractCacheDir
-} from "./chunk-TPECLKPA.js";
+} from "./chunk-E6SDW5FV.js";
 import {
   getUpdateMeta,
   withMeta
-} from "./chunk-DDQ4LOML.js";
+} from "./chunk-IYFKBFTW.js";
 import {
   CONFIG_PATH,
   withFileLock
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-MUINFURL.js";
+} from "./chunk-W6HTOVHU.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";

package/dist/{chunk-VVJFZU6B.js → chunk-L3JSAB4L.js}

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

package/dist/{chunk-BJ5JWOES.js → chunk-N77KD7ZZ.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-RXTXL3VL.js");
+  return await import("./src-74PFDTDX.js");
 }
 
 export {

package/dist/{chunk-KJLY2SDJ.js → chunk-NORZWWLK.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   getMimeType
-} from "./chunk-MHK5DE2P.js";
+} from "./chunk-6Q6FR4KH.js";
 import {
   injectTagsAtHeadStart
-} from "./chunk-B3I3XJ47.js";
+} from "./chunk-SYKKFAUW.js";
 
 // src/utils/compositionServer.ts
 import { createHash } from "crypto";

package/dist/{chunk-BQKEGPPL.js → chunk-O3SKIXQK.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveCaptureBrowserGpuMode
-} from "./chunk-PE2I3AFA.js";
+} from "./chunk-J5IPIQU2.js";
 import {
   requestCliExit
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-ABJNXQUA.js → chunk-OLDDJS3S.js}

@@ -7,29 +7,29 @@ var __dirname = __hf_dirname(__filename);
 import {
   RegistryCompatibilityError,
   gateRegistryItemsCompatibility
-} from "./chunk-DQNOPYAG.js";
+} from "./chunk-XWVGSEUT.js";
 import {
   DEFAULT_PROJECT_CONFIG,
   createProjectConfig,
   loadProjectConfig,
   projectConfigPath,
   recordProjectRegistryItems
-} from "./chunk-KMKWRIMC.js";
+} from "./chunk-AVWEIOEN.js";
 import {
   resolveItemWithDependencies,
   resolveItemsByTag
-} from "./chunk-ASW6NWON.js";
+} from "./chunk-IKVBTDLO.js";
 import {
   InvalidVariableValuesError,
   prepareItem,
   publishItem
-} from "./chunk-VVJFZU6B.js";
+} from "./chunk-L3JSAB4L.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-5IKJONRY.js";
+} from "./chunk-Q65ZQFF2.js";
 import {
   trackRegistryItemAdded
-} from "./chunk-JSGANFFH.js";
+} from "./chunk-7XTZVLE6.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -38,7 +38,7 @@ import {
 } from "./chunk-PBN6GBJE.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-QP3BRKGF.js";
+} from "./chunk-6E6CM7WS.js";
 import {
   isProjectRootMissing,
   realpath