hyperframes 0.8.183 → 0.8.184

package/dist/{chunk-WT4PYV2J.js → chunk-YALM6XN4.js}

@@ -37,7 +37,7 @@ import {
   stripEmbeddedRuntimeScripts,
   styleElementsFor,
   warnUnknownEnumValues
-} from "./chunk-GMNHAOMJ.js";
+} from "./chunk-R2SQBPMH.js";
 import {
   cssVariableName
 } from "./chunk-VC76R6W2.js";
@@ -690,21 +690,72 @@ function scopeCssToComposition(css, compositionId, scopeSelectorOverride, author
   if (!css || !trimmedCompositionId)
     return css;
   const scope = scopeSelectorOverride || `[data-composition-id="${escapeCssAttributeValue2(trimmedCompositionId)}"]`;
-  let root;
+  const root = parseCss(css);
+  return root ? scopeParsedCss(root, scope, trimmedCompositionId, authoredRootId, options) : "";
+}
+function parseCss(css) {
   try {
-    root = postcss.parse(css);
+    return postcss.parse(css);
   } catch {
-    return "";
+    return null;
   }
+}
+function forEachScopedRule(root, visit) {
   root.walkRules((rule) => {
     if (isInsideGlobalAtRule(rule))
       return;
     if (isNestedInsideAnotherRule(rule))
       return;
-    rule.selectors = rule.selectors.map((selector) => scopeSelector(selector, scope, trimmedCompositionId, authoredRootId, options?.compoundAuthoredRoot, options?.scopeRootSelectors));
+    visit(rule);
+  });
+}
+function scopeParsedCss(root, scope, compositionId, authoredRootId, options) {
+  forEachScopedRule(root, (rule) => {
+    rule.selectors = rule.selectors.map((selector) => scopeSelector(selector, scope, compositionId, authoredRootId, options?.compoundAuthoredRoot, options?.scopeRootSelectors));
   });
   return root.toResult({ map: false }).css;
 }
+var PLACEHOLDER_ID = "hf-scope-placeholder";
+var PLACEHOLDER_SCOPE = `[data-composition-id="${PLACEHOLDER_ID}"]`;
+var PLAIN_ID = /^[\w.:-]+$/;
+var PLAIN_SCOPE = /^\[data-composition-id="([\w.:-]+)"\]$/;
+function createCompositionCssScoper() {
+  const templates = /* @__PURE__ */ new Map();
+  return (css, compositionId, scopeSelectorOverride, authoredRootId, options) => {
+    const trimmedId = compositionId.trim();
+    const scope = scopeSelectorOverride ?? "";
+    const scopeId = PLAIN_SCOPE.exec(scope)?.[1];
+    if (!scopeId || scopeId === trimmedId || !PLAIN_ID.test(trimmedId) || trimmedId === PLACEHOLDER_ID)
+      return scopeCssToComposition(css, compositionId, scopeSelectorOverride, authoredRootId, options);
+    const key = JSON.stringify([
+      trimmedId,
+      authoredRootId ?? null,
+      Boolean(options?.compoundAuthoredRoot),
+      Boolean(options?.scopeRootSelectors),
+      css
+    ]);
+    let template = templates.get(key);
+    if (template === void 0) {
+      template = scopeTemplate(css, trimmedId, authoredRootId, options);
+      templates.set(key, template);
+    }
+    return template === null ? scopeCssToComposition(css, compositionId, scopeSelectorOverride, authoredRootId, options) : template.split(PLACEHOLDER_SCOPE).join(scope);
+  };
+}
+function scopeTemplate(css, compositionId, authoredRootId, options) {
+  if (css.includes(PLACEHOLDER_SCOPE))
+    return null;
+  if (!css)
+    return css;
+  const root = parseCss(css);
+  if (!root)
+    return "";
+  let rawSelector = false;
+  forEachScopedRule(root, (rule) => {
+    rawSelector ||= Boolean(rule.raws.selector);
+  });
+  return rawSelector ? null : scopeParsedCss(root, PLACEHOLDER_SCOPE, compositionId, authoredRootId, options);
+}
 function isFontFaceAtRule(node) {
   return node.type === "atrule" && node.name.toLowerCase() === "font-face";
 }
@@ -1590,6 +1641,7 @@ function ensureExternalLinkTag(doc, link) {
   if (!hasSameLink(doc, el))
     doc.head.appendChild(el);
 }
+var isDocument = (node) => node.nodeType === 9;
 function defaultBuildScopeSelector(compId) {
   const escaped = compId.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
   return `[data-composition-id="${escaped}"]`;
@@ -1607,6 +1659,22 @@ function inlineSubCompositions(document, hosts, options) {
   const externalLinks = [];
   const variablesByComp = {};
   const svgIdScopes = [];
+  const parsed = /* @__PURE__ */ new Map();
+  const parseOnce = (html) => {
+    let doc = parsed.get(html);
+    if (!doc) {
+      doc = parseHtml(html);
+      parsed.set(html, doc);
+    }
+    return doc;
+  };
+  const parseCopy = (html) => {
+    const copy = parseOnce(html).cloneNode(true);
+    return isDocument(copy) ? copy : parseHtml(html);
+  };
+  const usability = /* @__PURE__ */ new Map();
+  const sheetsWithAssetUrls = /* @__PURE__ */ new Map();
+  const scopeCssToComposition2 = createCompositionCssScoper();
   const sceneHosts = /* @__PURE__ */ new Map();
   const queue = hosts.map((element) => ({
     element,
@@ -1619,7 +1687,12 @@ function inlineSubCompositions(document, hosts, options) {
     if (!src)
       continue;
     const compHtml = resolveHtml(src);
-    const validity = checkSubCompositionUsability(compHtml, parseHtml);
+    let validity = compHtml == null ? void 0 : usability.get(compHtml);
+    if (!validity) {
+      validity = checkSubCompositionUsability(compHtml, parseOnce);
+      if (compHtml != null)
+        usability.set(compHtml, validity);
+    }
     if (!validity.ok) {
       onMissingComposition?.(src, validity.detail);
       continue;
@@ -1628,7 +1701,7 @@ function inlineSubCompositions(document, hosts, options) {
       onMissingComposition?.(src);
       continue;
     }
-    const compDoc = parseHtml(compHtml);
+    const compDoc = parseCopy(compHtml);
     let compId;
     let runtimeCompId;
     if (hostIdentityMap) {
@@ -1644,7 +1717,7 @@ function inlineSubCompositions(document, hosts, options) {
       onMissingComposition?.(src);
       continue;
     }
-    const contentDoc = parseHtml(contentHtml);
+    const contentDoc = parseCopy(contentHtml);
     if (!contentDoc.documentElement) {
       onMissingComposition?.(src);
       continue;
@@ -1688,8 +1761,13 @@ function inlineSubCompositions(document, hosts, options) {
     }
     const resolveSubAssetPath = (raw) => rewriteAssetPath(src, (raw || "").trim(), assetExists);
     const scopeSubStyle = (raw) => {
-      const css = rewriteCssAssetUrls(raw, src, assetExists);
-      return scopeCompId ? scopeCssToComposition(css, scopeCompId, runtimeScope || void 0, authoredRootId, {
+      const sheetKey = JSON.stringify([src, raw]);
+      let css = sheetsWithAssetUrls.get(sheetKey);
+      if (css === void 0) {
+        css = rewriteCssAssetUrls(raw, src, assetExists);
+        sheetsWithAssetUrls.set(sheetKey, css);
+      }
+      return scopeCompId ? scopeCssToComposition2(css, scopeCompId, runtimeScope || void 0, authoredRootId, {
         compoundAuthoredRoot: compoundAuthoredRoot === true,
         scopeRootSelectors: true
       }) : css;
@@ -2346,31 +2424,45 @@ function warnAssetTooLargeToInline(assetPath, byteLength) {
   const mb = (byteLength / (1024 * 1024)).toFixed(1);
   console.warn(`[HyperFrames] Not inlining "${assetPath}" (${mb} MB exceeds the ${MAX_INLINE_ASSET_BYTES / (1024 * 1024)} MB inline limit). The bundle may not be self-contained.`);
 }
-function maybeInlineRelativeAssetUrl(urlValue, projectDir, inlineAssets) {
-  if (!inlineAssets)
-    return null;
-  if (!urlValue || !isRelativeUrl(urlValue))
-    return null;
-  const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
-  if (!basePath)
-    return null;
-  const filePath = resolveWithinProject(projectDir, decodeWellFormedEscapes(basePath));
-  if (!filePath)
-    return null;
-  const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0] ?? "";
-  const mimeType = INLINE_MIME[ext];
-  if (!mimeType)
-    return null;
-  const byteLength = safeStatSize(filePath);
-  if (byteLength !== null && byteLength > MAX_INLINE_ASSET_BYTES) {
-    warnAssetTooLargeToInline(basePath, byteLength);
-    return null;
-  }
-  const content = safeReadFileBuffer(filePath);
-  if (content == null)
-    return null;
-  const dataUrl = `data:${mimeType};base64,${content.toString("base64")}`;
-  return appendSuffixToUrl(dataUrl, suffix);
+function createAssetInliner(resolveProjectPath, inlineAssets) {
+  const assets = /* @__PURE__ */ new Map();
+  const readAsset = (filePath, mimeType) => {
+    const byteLength = safeStatSize(filePath);
+    if (byteLength !== null && byteLength > MAX_INLINE_ASSET_BYTES)
+      return { tooLarge: byteLength };
+    const content = safeReadFileBuffer(filePath);
+    return {
+      dataUrl: content === null ? null : `data:${mimeType};base64,${content.toString("base64")}`
+    };
+  };
+  return (urlValue) => {
+    if (!inlineAssets)
+      return null;
+    if (!urlValue || !isRelativeUrl(urlValue))
+      return null;
+    const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
+    if (!basePath)
+      return null;
+    const filePath = resolveProjectPath(decodeWellFormedEscapes(basePath));
+    if (!filePath)
+      return null;
+    const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0] ?? "";
+    const mimeType = INLINE_MIME[ext];
+    if (!mimeType)
+      return null;
+    let asset = assets.get(filePath);
+    if (asset === void 0) {
+      asset = readAsset(filePath, mimeType);
+      assets.set(filePath, asset);
+    } else if ("dataUrl" in asset) {
+      noteRead(filePath);
+    }
+    if ("tooLarge" in asset) {
+      warnAssetTooLargeToInline(basePath, asset.tooLarge);
+      return null;
+    }
+    return asset.dataUrl === null ? null : appendSuffixToUrl(asset.dataUrl, suffix);
+  };
 }
 function isExternalSvgFragmentUse(el, attr, urlValue) {
   if (el.tagName.toLowerCase() !== "use")
@@ -2391,7 +2483,7 @@ function warnColorGradingLutNotInlined(lutSrc) {
     return;
   console.warn(`[HyperFrames] Could not inline color grading LUT "${trimmed}". The rendered bundle may not be self-contained.`);
 }
-function rewriteColorGradingLutWithInlinedAssets(value, projectDir) {
+function rewriteColorGradingLutWithInlinedAssets(value, inlineAsset) {
   if (!value.trim().startsWith("{"))
     return value;
   let parsed;
@@ -2404,7 +2496,7 @@ function rewriteColorGradingLutWithInlinedAssets(value, projectDir) {
     return value;
   const lut = Reflect.get(parsed, "lut");
   if (typeof lut === "string") {
-    const inlined2 = maybeInlineRelativeAssetUrl(lut, projectDir, true);
+    const inlined2 = inlineAsset(lut);
     if (!inlined2) {
       warnColorGradingLutNotInlined(lut);
       return value;
@@ -2417,7 +2509,7 @@ function rewriteColorGradingLutWithInlinedAssets(value, projectDir) {
   const lutSrc = Reflect.get(lut, "src");
   if (typeof lutSrc !== "string")
     return value;
-  const inlined = maybeInlineRelativeAssetUrl(lutSrc, projectDir, true);
+  const inlined = inlineAsset(lutSrc);
   if (!inlined) {
     warnColorGradingLutNotInlined(lutSrc);
     return value;
@@ -2425,7 +2517,7 @@ function rewriteColorGradingLutWithInlinedAssets(value, projectDir) {
   Reflect.set(lut, "src", inlined);
   return JSON.stringify(parsed);
 }
-function rewriteSrcsetWithInlinedAssets(srcsetValue, projectDir, inlineAssets) {
+function rewriteSrcsetWithInlinedAssets(srcsetValue, inlineAsset) {
   if (!srcsetValue)
     return srcsetValue;
   return srcsetValue.split(",").map((rawCandidate) => {
@@ -2435,17 +2527,17 @@ function rewriteSrcsetWithInlinedAssets(srcsetValue, projectDir, inlineAssets) {
     const parts = candidate.split(/\s+/);
     if (parts.length === 0)
       return candidate;
-    const maybeInlined = maybeInlineRelativeAssetUrl(parts[0] ?? "", projectDir, inlineAssets);
+    const maybeInlined = inlineAsset(parts[0] ?? "");
     if (maybeInlined)
       parts[0] = maybeInlined;
     return parts.join(" ");
   }).join(", ");
 }
-function rewriteCssUrlsWithInlinedAssets(cssText, projectDir, inlineAssets) {
+function rewriteCssUrlsWithInlinedAssets(cssText, inlineAsset) {
   if (!cssText)
     return cssText;
   return cssText.replace(/\burl\(\s*(["']?)([^)"']+)\1\s*\)/g, (_full, quote, rawUrl) => {
-    const maybeInlined = maybeInlineRelativeAssetUrl((rawUrl || "").trim(), projectDir, inlineAssets);
+    const maybeInlined = inlineAsset((rawUrl || "").trim());
     if (!maybeInlined)
       return _full;
     return `url(${quote || ""}${maybeInlined}${quote || ""})`;
@@ -2788,7 +2880,17 @@ function hoistCompositionScripts(container, opts) {
 }
 function bundleToSingleHtml(projectDir, options) {
   const bundle = () => bundleProject(projectDir, options);
-  return options?.onRead ? bundleReads.run(options.onRead, bundle) : bundle();
+  const onRead = options?.onRead;
+  if (!onRead)
+    return bundle();
+  const noted = /* @__PURE__ */ new Set();
+  const noteOnce = (filePath) => {
+    if (noted.has(filePath))
+      return;
+    noted.add(filePath);
+    onRead(filePath);
+  };
+  return bundleReads.run(noteOnce, bundle);
 }
 function readMountedSceneShell(projectDir, entryFile, entryHtml) {
   if (!isTemplateEntry(entryHtml))
@@ -2806,9 +2908,28 @@ async function bundleProject(projectDir, options) {
   const entryHtml = readFileSync(indexPath, "utf-8");
   const mountedShell = readMountedSceneShell(projectDir, entryFile, entryHtml);
   const sourceDir = mountedShell ? projectDir : dirname(indexPath);
+  const safePaths = /* @__PURE__ */ new Map();
+  const isSafeProjectPath = (resolved) => {
+    let safe = safePaths.get(resolved);
+    if (safe === void 0) {
+      safe = isSafePath(projectDir, resolved);
+      safePaths.set(resolved, safe);
+    }
+    return safe;
+  };
+  const entryPaths = /* @__PURE__ */ new Map();
   const resolveEntryPath = (relativePath) => {
-    const resolved = resolve2(sourceDir, relativePath);
-    return isSafePath(projectDir, resolved) ? resolved : null;
+    let entry = entryPaths.get(relativePath);
+    if (entry === void 0) {
+      const resolved = resolve2(sourceDir, relativePath);
+      entry = isSafeProjectPath(resolved) ? resolved : null;
+      entryPaths.set(relativePath, entry);
+    }
+    return entry;
+  };
+  const resolveProjectPath = (relativePath) => {
+    const resolved = resolve2(projectDir, relativePath);
+    return isSafeProjectPath(resolved) ? resolved : null;
   };
   const resolveEntryUrl = (url) => resolveEntryPath(decodedUrlPath(url));
   const readSource = options?.stampHfIds ? ensureHfIds : (html) => html;
@@ -2859,13 +2980,23 @@ async function bundleProject(projectDir, options) {
   const trackedCompositionHosts = getBundledTrackedCompositionHosts(document);
   const hostIdentityByElement = assignBundledRuntimeCompositionIds(trackedCompositionHosts);
   const subCompositionHosts = trackedCompositionHosts.filter((host) => host.hasAttribute("data-composition-src"));
+  const sceneSources = /* @__PURE__ */ new Map();
   const subCompResult = inlineSubCompositions(document, subCompositionHosts, {
     resolveHtml: (srcPath) => {
       if (!isRelativeUrl(srcPath))
         return null;
       const compPath = resolveEntryPath(srcPath);
-      const html = compPath ? safeReadFile(compPath) : null;
-      return html === null ? null : readSource(html);
+      if (!compPath)
+        return null;
+      let source = sceneSources.get(compPath);
+      if (source === void 0) {
+        const html = safeReadFile(compPath);
+        source = html === null ? null : readSource(html);
+        sceneSources.set(compPath, source);
+      } else {
+        noteRead(compPath);
+      }
+      return source;
     },
     parseHtml: parseHTMLContent,
     hostIdentityMap: hostIdentityByElement,
@@ -3078,6 +3209,7 @@ async function bundleProject(projectDir, options) {
   deferScriptsUntilFonts(document, (el) => el.hasAttribute(RUNTIME_BOOTSTRAP_ATTR));
   injectTextRenderingRule(document);
   const inlineAssets = options?.inlineAssets !== false;
+  const inlineAsset = createAssetInliner(resolveProjectPath, inlineAssets);
   for (const el of [...document.querySelectorAll("[src], [href], [poster], [xlink\\:href]")]) {
     for (const attr of ["src", "href", "poster", "xlink:href"]) {
       const value = el.getAttribute(attr);
@@ -3085,7 +3217,7 @@ async function bundleProject(projectDir, options) {
         continue;
       if (isExternalSvgFragmentUse(el, attr, value))
         continue;
-      const inlined = maybeInlineRelativeAssetUrl(value, projectDir, inlineAssets);
+      const inlined = inlineAsset(value);
       if (inlined)
         el.setAttribute(attr, inlined);
     }
@@ -3093,7 +3225,7 @@ async function bundleProject(projectDir, options) {
   for (const el of [...document.querySelectorAll("[srcset]")]) {
     const srcset = el.getAttribute("srcset");
     if (srcset)
-      el.setAttribute("srcset", rewriteSrcsetWithInlinedAssets(srcset, projectDir, inlineAssets));
+      el.setAttribute("srcset", rewriteSrcsetWithInlinedAssets(srcset, inlineAsset));
   }
   const liveStyles = [...document.querySelectorAll("style")].filter(isAlwaysAppliedStyle);
   const liveCss = liveStyles.map((el) => el.textContent || "");
@@ -3108,16 +3240,16 @@ async function bundleProject(projectDir, options) {
     document.head.prepend(holder);
   }
   for (const styleEl of document.querySelectorAll("style")) {
-    styleEl.textContent = rewriteCssUrlsWithInlinedAssets(styleEl.textContent || "", projectDir, inlineAssets);
+    styleEl.textContent = rewriteCssUrlsWithInlinedAssets(styleEl.textContent || "", inlineAsset);
   }
   for (const el of [...document.querySelectorAll("[style]")]) {
-    el.setAttribute("style", rewriteCssUrlsWithInlinedAssets(el.getAttribute("style") || "", projectDir, inlineAssets));
+    el.setAttribute("style", rewriteCssUrlsWithInlinedAssets(el.getAttribute("style") || "", inlineAsset));
   }
   if (inlineAssets && options?.inlineColorGradingLuts !== false) {
     for (const el of [...document.querySelectorAll(`[${HF_COLOR_GRADING_ATTR}]`)]) {
       const value = el.getAttribute(HF_COLOR_GRADING_ATTR);
       if (value) {
-        el.setAttribute(HF_COLOR_GRADING_ATTR, rewriteColorGradingLutWithInlinedAssets(value, projectDir));
+        el.setAttribute(HF_COLOR_GRADING_ATTR, rewriteColorGradingLutWithInlinedAssets(value, inlineAsset));
       }
     }
   }
@@ -3157,7 +3289,22 @@ function emitRootCompositionVariableStyles(document, variablesByComp = {}, overr
 }
 function authoredDefinesPredicate(document) {
   const authoredCss = [...document.querySelectorAll("style:not([data-hf-composition-variables])")].map((s) => s.textContent || "").join("\n");
-  return (id) => new RegExp(`${cssVariableName(id)}\\s*:`).test(authoredCss);
+  const defined = namesBeforeAColon(authoredCss);
+  return (id) => defined.has(cssVariableName(id));
+}
+function namesBeforeAColon(css) {
+  const names = /* @__PURE__ */ new Set();
+  const word = /[\w-]+/g;
+  const colonNext = /\s*:/y;
+  for (let match = word.exec(css); match; match = word.exec(css)) {
+    colonNext.lastIndex = word.lastIndex;
+    if (!colonNext.test(css))
+      continue;
+    const text = match[0];
+    for (let at = text.indexOf("--"); at !== -1; at = text.indexOf("--", at + 1))
+      names.add(text.slice(at));
+  }
+  return names;
 }
 function makeVariableLayer(authoredDefines, overrides) {
   return (declared, hostValues) => {

package/dist/{chunk-R6OV4J4K.js → chunk-YOZPQCSR.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-DLC2FICN.js";
+} from "./chunk-JIUTXKWA.js";
 import {
   shouldTrack
-} from "./chunk-DEORFAWP.js";
+} from "./chunk-UKOTVJFV.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
@@ -84,7 +84,7 @@ async function getDoctorSummary() {
   try {
     const [{ getSystemMeta }, { findFFmpeg }] = await Promise.all([
       import("./system-7F3UEHQT.js"),
-      import("./ffmpeg-2AECXG7V.js")
+      import("./ffmpeg-BYHON577.js")
     ]);
     const sys = getSystemMeta();
     const parts = [

package/dist/{chunk-COTLNID2.js → chunk-YWHCXIMD.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-5ETJX6WM.js";
 import {
   runEnvironmentChecks
-} from "./chunk-MIZDJVPZ.js";
+} from "./chunk-E32ZQ2WO.js";
 import {
   OPTIONAL_PACKAGES,
   installedOptionalPackageVersion
@@ -29,7 +29,7 @@ import {
 } from "./chunk-ZTZA4UWZ.js";
 import {
   resolveExtractCacheDir
-} from "./chunk-73LTCCZI.js";
+} from "./chunk-RGXVEYHI.js";
 import {
   getAvailableMemoryMb,
   getFreeDiskMb,
@@ -39,14 +39,14 @@ import {
 import {
   getUpdateMeta,
   withMeta
-} from "./chunk-ANR6WOC3.js";
+} from "./chunk-ABZYYUUH.js";
 import {
   CONFIG_PATH,
   withFileLock
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-RZXUQR42.js";
+} from "./chunk-4N4P3ZWL.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -232,7 +232,7 @@ function checkEnvironment() {
   return { ok: true, detail: parts.join(" \xB7 ") };
 }
 async function checkWhisper() {
-  const { findWhisper, getInstallInstructions } = await import("./manager-D2UV6RDQ.js");
+  const { findWhisper, getInstallInstructions } = await import("./manager-TWVDSJXO.js");
   const result = findWhisper();
   if (result) {
     return { ok: true, detail: result.executablePath };

package/dist/{chunk-5OGDBU4G.js → chunk-YWNJTZGN.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   getMimeType
-} from "./chunk-NZ3BE2QE.js";
+} from "./chunk-3QVMJ7GX.js";
 import {
   injectTagsAtHeadStart
-} from "./chunk-GMNHAOMJ.js";
+} from "./chunk-R2SQBPMH.js";
 
 // src/utils/compositionServer.ts
 import { createHash } from "crypto";

package/dist/{chunk-AKFADCMS.js → chunk-ZOCHDXDG.js}

@@ -11,7 +11,7 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemManifest,
   fetchRegistryManifest
-} from "./chunk-BP4VNTZL.js";
+} from "./chunk-7MB2ZAQF.js";
 
 // src/registry/resolver.ts
 function defaultWarn(message) {

package/dist/{chunk-EVAQPW6O.js → chunk-ZRHO6YMM.js}

@@ -11,13 +11,13 @@ import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-VFBAKPRC.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   EXCLUDED_TAGS,
   ensureHfIds,
   mintHfId,
   walkCompositionDescendants
-} from "./chunk-WT4PYV2J.js";
+} from "./chunk-YALM6XN4.js";
 import {
   decodedUrlPath,
   removeElementWithGsapCascade

package/dist/{clean-WNEIVBF3.js → clean-HGASSMWI.js}

@@ -6,18 +6,18 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   redactHome
-} from "./chunk-COTLNID2.js";
+} from "./chunk-YWHCXIMD.js";
 import "./chunk-Z27A7NUB.js";
 import "./chunk-5ETJX6WM.js";
-import "./chunk-MIZDJVPZ.js";
+import "./chunk-E32ZQ2WO.js";
 import "./chunk-QH3T4WI2.js";
 import "./chunk-6BEFEWFB.js";
-import "./chunk-OH56PXFH.js";
+import "./chunk-7HJALUIO.js";
 import {
   loadProducer
-} from "./chunk-VH5KESLX.js";
-import "./chunk-NZ3BE2QE.js";
-import "./chunk-EVAQPW6O.js";
+} from "./chunk-BCHSTE7U.js";
+import "./chunk-3QVMJ7GX.js";
+import "./chunk-ZRHO6YMM.js";
 import "./chunk-6JR2XUEE.js";
 import "./chunk-TTVHYD5R.js";
 import {
@@ -28,7 +28,7 @@ import {
 import {
   CACHE_DIR_NAME,
   cleanupProxyCache
-} from "./chunk-GPE3WWTO.js";
+} from "./chunk-SN7KI5JA.js";
 import "./chunk-ALVXFXUG.js";
 import {
   formatBytes
@@ -52,11 +52,12 @@ import {
   directorySizeBytes,
   gcExtractionCache,
   resolveExtractCacheDir
-} from "./chunk-73LTCCZI.js";
-import "./chunk-VFBAKPRC.js";
+} from "./chunk-RGXVEYHI.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-J3QM7AHP.js";
 import "./chunk-RQVDTPGD.js";
-import "./chunk-WT4PYV2J.js";
-import "./chunk-GMNHAOMJ.js";
+import "./chunk-YALM6XN4.js";
+import "./chunk-R2SQBPMH.js";
 import "./chunk-VC76R6W2.js";
 import "./chunk-UJKQWGFF.js";
 import "./chunk-YMS5FOMC.js";
@@ -82,12 +83,12 @@ import "./chunk-TYXH3EKP.js";
 import "./chunk-W2LGJSEN.js";
 import {
   withMeta
-} from "./chunk-ANR6WOC3.js";
+} from "./chunk-ABZYYUUH.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-RZXUQR42.js";
+import "./chunk-4N4P3ZWL.js";
 import "./chunk-KNU5COPB.js";
 import "./chunk-KGPLIH7B.js";
 import "./chunk-M2WBOQ2Q.js";