@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-RNV3DM4S.js

@@ -0,0 +1,3573 @@
+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 {
+  HF_AUDIO_FX_ATTR,
+  HF_COLOR_GRADING_ATTR,
+  INLINED_FILE_ATTR,
+  RUNTIME_BOOTSTRAP_ATTR,
+  UNCONDITIONAL_CSS_KEY,
+  assignMediaRenderIds,
+  clampDurations,
+  compileTimingAttrs,
+  compositionStyle,
+  countPageRoot,
+  cssStyleMergeKey,
+  deferScriptsUntilFonts,
+  enumerateNestedCompositionHosts,
+  escapeInlineScriptSource,
+  executableScripts,
+  extractResolvedMedia,
+  extractedCompositionAssets,
+  getHyperframeRuntimeScript,
+  hasSameLink,
+  headStyleRuns,
+  injectDurations,
+  injectTagsAtHeadStart,
+  inlineScriptRuns,
+  insertRuntimeTag,
+  isJavaScriptType,
+  isTemplateEntry,
+  parseHTMLContent,
+  parseHostVariableValues,
+  planCompositionAssembly,
+  readDeclaredDefaults,
+  shouldClampResolvedMediaDuration,
+  stripEmbeddedRuntimeScripts,
+  styleElementsFor,
+  warnUnknownEnumValues
+} from "./chunk-UJZREAV6.js";
+import {
+  cssVariableName
+} from "./chunk-VC76R6W2.js";
+import {
+  isSafePath,
+  resolveWithinProject
+} from "./chunk-OFQWTKPW.js";
+import {
+  lintHyperframeHtml
+} from "./chunk-4P7NX5BM.js";
+import {
+  checkSubCompositionUsability,
+  resolveSubCompositionContent
+} from "./chunk-MMQ52NIZ.js";
+import {
+  CSS_URL_RE,
+  decodeCssEscapes,
+  decodeWellFormedEscapes,
+  decodedUrlPath,
+  encodeUrlPath,
+  isNonRelativeUrl,
+  rewriteAssetPath,
+  rewriteAssetPaths,
+  rewriteCssAssetUrls,
+  rewriteInlineStyleAssetUrls,
+  splitUrlSuffix
+} from "./chunk-BSQ7XANM.js";
+import {
+  parseHTML
+} from "./chunk-SDYDNHEE.js";
+
+// ../core/dist/compiler/htmlCompiler.js
+import { resolve } from "path";
+function resolveMediaSrc(src, projectDir) {
+  return src.startsWith("http://") || src.startsWith("https://") ? src : resolve(projectDir, decodedUrlPath(src));
+}
+async function compileHtml(rawHtml, projectDir, probeMediaDuration) {
+  const { html: staticCompiled, unresolved } = compileTimingAttrs(rawHtml);
+  let html = staticCompiled;
+  if (!probeMediaDuration)
+    return html;
+  const mediaUnresolved = unresolved.filter((el) => el.tagName === "video" || el.tagName === "audio");
+  if (mediaUnresolved.length > 0) {
+    const resolutions = [];
+    for (const el of mediaUnresolved) {
+      if (!el.src)
+        continue;
+      const src = resolveMediaSrc(el.src, projectDir);
+      const fileDuration = await probeMediaDuration(src);
+      if (fileDuration <= 0)
+        continue;
+      const effectiveDuration = fileDuration - el.mediaStart;
+      const sourceDuration = effectiveDuration > 0 ? effectiveDuration : fileDuration;
+      resolutions.push({ id: el.id, duration: sourceDuration });
+    }
+    if (resolutions.length > 0) {
+      html = injectDurations(html, resolutions);
+    }
+  }
+  return clampProbedMedia(html, projectDir, probeMediaDuration);
+}
+async function clampProbedMedia(html, projectDir, probeMediaDuration) {
+  const preResolved = extractResolvedMedia(html);
+  const clampList = [];
+  for (const el of preResolved) {
+    if (!el.src)
+      continue;
+    if (el.loop)
+      continue;
+    const src = resolveMediaSrc(el.src, projectDir);
+    const fileDuration = await probeMediaDuration(src);
+    if (fileDuration <= 0)
+      continue;
+    const maxDuration = fileDuration - el.mediaStart;
+    if (maxDuration > 0 && shouldClampResolvedMediaDuration(el.tagName, el.duration, maxDuration)) {
+      clampList.push({ id: el.id, duration: maxDuration });
+    }
+  }
+  if (clampList.length > 0) {
+    html = clampDurations(html, clampList);
+  }
+  return html;
+}
+
+// ../core/dist/compiler/htmlBundler.js
+import { createHash } from "crypto";
+
+// ../core/dist/sceneParts.js
+var SCENE_PART_ATTR = "data-hf-scene";
+var SCENE_PARTS_META = "hf-scene-parts";
+var SCENE_FONTS_ATTR = "data-hf-scene-fonts";
+var SCENE_NO_SWAP_ATTR = "data-hf-scene-no-swap";
+
+// ../core/dist/compiler/externalScripts.js
+function readExternalScriptAttributes(el) {
+  const attributes = {};
+  if (el.hasAttribute("integrity"))
+    attributes.integrity = el.getAttribute("integrity") || "";
+  if (el.hasAttribute("crossorigin"))
+    attributes.crossorigin = el.getAttribute("crossorigin") || "";
+  if ((el.getAttribute("type") || "").trim().toLowerCase() === "module")
+    attributes.type = "module";
+  return attributes;
+}
+function ensureExternalScriptTag(doc, src, attributes = {}) {
+  const existing = [...doc.querySelectorAll("script[src]")].filter((el) => el.getAttribute("src")?.trim() === src);
+  const requirements = new Set([attributes.integrity, ...existing.map((el) => el.getAttribute("integrity"))].map((value) => value?.trim().replace(/(^|[\t\n\f\r ])(sha256|sha384|sha512)-/gi, (_match, space, algorithm) => `${space}${algorithm.toLowerCase()}-`)).filter((value) => Boolean(value)));
+  if (requirements.size > 1) {
+    throw new Error(`Conflicting script integrity requirements for ${src}`);
+  }
+  const integrity = [...requirements][0];
+  const elements = existing.length ? existing : [doc.createElement("script")];
+  for (const el of elements) {
+    if (integrity)
+      el.setAttribute("integrity", integrity);
+    if (attributes.crossorigin !== void 0)
+      el.setAttribute("crossorigin", attributes.crossorigin);
+    if (attributes.type)
+      el.setAttribute("type", attributes.type);
+  }
+  if (!existing.length) {
+    const el = elements[0];
+    el.setAttribute("src", src);
+    doc.body.appendChild(el);
+  }
+}
+
+// ../core/dist/compiler/importMaps.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isScopeMap(value) {
+  return isRecord(value) && Object.values(value).every(isRecord);
+}
+var rebaseEntries = (entries, rebase) => entries && Object.fromEntries(Object.entries(entries).map(([specifier, url]) => [
+  specifier,
+  typeof url === "string" ? rebase(url) : null
+]));
+function parseImportMap(json, rebase) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed))
+    return null;
+  const { imports, scopes } = parsed;
+  if (imports !== void 0 && !isRecord(imports))
+    return null;
+  if (scopes !== void 0 && !isScopeMap(scopes))
+    return null;
+  return {
+    imports: rebaseEntries(imports, rebase),
+    scopes: scopes && Object.fromEntries(Object.entries(scopes).map(([prefix, entries]) => [
+      rebase(prefix),
+      rebaseEntries(entries, rebase) ?? {}
+    ]))
+  };
+}
+function mergeEntries(into, from, where) {
+  for (const [specifier, url] of Object.entries(from ?? {})) {
+    if (!Object.hasOwn(into, specifier)) {
+      Object.defineProperty(into, specifier, {
+        value: url,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else if (into[specifier] !== url) {
+      console.warn(`[Framey] import map conflict for "${specifier}"${where}: keeping ${into[specifier]}, ignoring ${url}.`);
+    }
+  }
+}
+function mergeImportMapsIntoDocument(doc, maps) {
+  if (maps.length === 0)
+    return;
+  let el = doc.querySelector('script[type="importmap"]');
+  let page = {};
+  try {
+    page = el ? JSON.parse(el.textContent || "{}") : {};
+  } catch {
+    console.warn("[Framey] the page's import map is not valid JSON; replacing it.");
+  }
+  const imports = { ...page.imports };
+  const scopes = { ...page.scopes };
+  for (const map of maps) {
+    mergeEntries(imports, map.imports, "");
+    for (const [prefix, entries] of Object.entries(map.scopes ?? {})) {
+      const scope = (Object.hasOwn(scopes, prefix) ? scopes[prefix] : void 0) ?? {};
+      Object.defineProperty(scopes, prefix, { value: scope, enumerable: true });
+      mergeEntries(scope, entries, ` in scope ${prefix}`);
+    }
+  }
+  if (!el) {
+    el = doc.createElement("script");
+    el.setAttribute("type", "importmap");
+    doc.head.prepend(el);
+  }
+  el.textContent = JSON.stringify({
+    ...page,
+    imports,
+    ...Object.keys(scopes).length ? { scopes } : {}
+  }).replace(/</g, "\\u003c");
+}
+function emitMountedModuleScripts(doc, importMaps, moduleScripts) {
+  mergeImportMapsIntoDocument(doc, importMaps);
+  for (const content of moduleScripts) {
+    const el = doc.createElement("script");
+    el.setAttribute("type", "module");
+    el.textContent = content;
+    doc.body.appendChild(el);
+  }
+}
+
+// ../core/dist/runtime/flattenedRoot.js
+var FLATTENED_INNER_ROOT_STRIP_ATTRS = [
+  "data-composition-id",
+  "data-composition-file",
+  "data-start",
+  "data-duration",
+  "data-end",
+  "data-track-index",
+  "data-track",
+  "data-composition-src",
+  "data-hf-authored-duration",
+  "data-hf-authored-end"
+];
+function markFlattenedInnerRoot(prepared) {
+  const authoredRootId = prepared.getAttribute("id")?.trim();
+  for (const attrName of FLATTENED_INNER_ROOT_STRIP_ATTRS) {
+    prepared.removeAttribute(attrName);
+  }
+  if (authoredRootId) {
+    prepared.removeAttribute("id");
+    prepared.setAttribute("data-hf-authored-id", authoredRootId);
+  }
+  prepared.setAttribute("data-hf-inner-root", "true");
+}
+
+// ../core/dist/runtime/applyVariableBindings.js
+function sanitizeCssValue(value) {
+  return value.replace(/[;{}<>\r\n]/g, "");
+}
+
+// ../core/dist/compiler/htmlBundler.js
+import { AsyncLocalStorage } from "async_hooks";
+import { readFileSync, existsSync, statSync } from "fs";
+import { parse as parseJs } from "acorn";
+import { resolve as resolve2, relative, dirname, isAbsolute, sep } from "path";
+
+// ../core/dist/compiler/standaloneEntry.js
+function normalizeCompositionSrcPath(srcPath) {
+  return srcPath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function readSceneRoot(entryHtml) {
+  if (!entryHtml)
+    return null;
+  const { document } = parseHTML(entryHtml);
+  const template = document.querySelector("template");
+  const scope = template ? parseHTML(template.innerHTML).document : document;
+  return scope.querySelector("[data-composition-id]");
+}
+function setSceneFxChain(el, sceneFxChain) {
+  if (sceneFxChain) {
+    el.setAttribute(HF_AUDIO_FX_ATTR, sceneFxChain);
+  } else {
+    el.removeAttribute(HF_AUDIO_FX_ATTR);
+  }
+}
+function createStandaloneEntryRenderClone(root, host, sceneDuration, sceneFxChain) {
+  const hostClone = host.cloneNode(true);
+  hostClone.setAttribute("data-start", "0");
+  if (root === host) {
+    setSceneFxChain(hostClone, sceneFxChain);
+    return hostClone;
+  }
+  const rootClone = root.cloneNode(false);
+  if (sceneDuration != null) {
+    rootClone.setAttribute("data-duration", sceneDuration);
+  } else {
+    rootClone.removeAttribute("data-duration");
+  }
+  setSceneFxChain(rootClone, sceneFxChain);
+  rootClone.appendChild(hostClone);
+  return rootClone;
+}
+function replaceBodyWithRenderClone(body, renderClone) {
+  const libraries = Array.from(body.children).filter((child) => child.tagName === "SCRIPT" && child.hasAttribute("src"));
+  while (body.firstChild) {
+    body.removeChild(body.firstChild);
+  }
+  for (const library of libraries)
+    body.appendChild(library);
+  body.appendChild(renderClone);
+}
+function extractStandaloneEntryFromIndex(indexHtml, entryFile, entryHtml) {
+  const normalizedEntryFile = normalizeCompositionSrcPath(entryFile);
+  const { document } = parseHTML(indexHtml);
+  const body = document.querySelector("body");
+  if (!body)
+    return null;
+  const hosts = Array.from(document.querySelectorAll("[data-composition-src]"));
+  const host = hosts.find((candidate) => normalizeCompositionSrcPath(candidate.getAttribute("data-composition-src") || "") === normalizedEntryFile);
+  if (!host)
+    return null;
+  const root = Array.from(body.children).find((candidate) => candidate.hasAttribute("data-composition-id")) ?? null;
+  if (!root)
+    return null;
+  const sceneRoot = readSceneRoot(entryHtml);
+  const sceneDuration = sceneRoot?.getAttribute("data-duration") ?? host.getAttribute("data-duration");
+  const sceneFxChain = sceneRoot?.getAttribute(HF_AUDIO_FX_ATTR) || null;
+  const renderClone = createStandaloneEntryRenderClone(root, host, sceneDuration, sceneFxChain);
+  replaceBodyWithRenderClone(body, renderClone);
+  return document.toString();
+}
+
+// ../core/dist/generated/svg-selector-aliases-inline.js
+var SVG_SELECTOR_ALIASES_IIFE = '"use strict";(()=>{function I(e){return e?/[\\w-]/.test(e)||e.charCodeAt(0)>=128:!1}function _(e){return e===" "||e==="	"||e===`\n`||e==="\\r"||e==="\\f"}var j=/^[0-9a-fA-F]{1,6}/;function G(e){let n=e>=55296&&e<=57343;return e===0||e>1114111||n?65533:e}function $(e,n){return e[n]==="\\r"&&e[n+1]===`\n`?n+2:_(e[n])?n+1:n}function R(e,n){let t=e[n+1];if(t===void 0||/[\\n\\r\\f]/.test(t))return null;let i=j.exec(e.slice(n+1,n+7));if(!i)return{value:t,end:n+2};let o=G(Number.parseInt(i[0],16));return{value:String.fromCodePoint(o),end:$(e,n+1+i[0].length)}}function H(e,n){let t=o=>I(o)&&!/[0-9-]/.test(o),i=o=>e[o]==="\\\\"&&R(e,o)!==null;return e[n]==="-"?e[n+1]==="-"||t(e[n+1])||i(n+1):t(e[n])||i(n)}function y(e,n){let t=n;for(;e.startsWith("/*",t);){let i=e.indexOf("*/",t+2);t=i<0?e.length:i+2}return t}function A(e,n){let t=y(e,n);for(;_(e[t]);)t=y(e,t+1);return t}function h(e,n){if(!H(e,n))return null;let t=n,i="";for(;t<e.length;){let o=e[t];if(o==="\\\\"){let a=R(e,t);if(!a)break;i+=a.value,t=a.end;continue}if(!I(o))break;i+=o,t+=1}return t===n?null:{value:i,end:t}}var C=45;function T(e){return e>=48&&e<=57}function z(e){return e>=128||e===C||e===95||T(e)||e>=65&&e<=90||e>=97&&e<=122}function J(e,n){let t=e.charCodeAt(n);return t>=1&&t<=31||t===127?!0:T(t)?n===0||n===1&&e.charCodeAt(0)===C:!1}function k(e){let n="";for(let t=0;t<e.length;t+=1){let i=e.charCodeAt(t),o=e[t];i===0?n+="\\uFFFD":J(e,t)?n+=`\\\\${i.toString(16)} `:t===0&&e.length===1&&i===C?n+=`\\\\${o}`:z(i)?n+=o:n+=`\\\\${o}`}return n}var W=/\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|\\\\(?:[0-9a-fA-F]{1,6}(?:\\r\\n|[ \\t\\r\\n\\f])?|[\\s\\S])|"(?:[^"\\\\]|\\\\[\\s\\S])*"|\'(?:[^\'\\\\]|\\\\[\\s\\S])*\'|\\[(?:\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|\\\\[\\s\\S]|"(?:[^"\\\\]|\\\\[\\s\\S])*"|\'(?:[^\'\\\\]|\\\\[\\s\\S])*\'|[^\\]"\'\\\\/]|\\/(?!\\*))*\\]/g;function Q(e){let n=new Array(e.length).fill(!0);for(let t of e.matchAll(W)){let i=t.index;n.fill(!1,i,i+t[0].length)}return n}function q(e,n,t){if(n.length===0||!e.includes("#"))return e;let i=new Set(n),o=Q(e),a="",u=0;for(;u<e.length;){let d=o[u]&&e[u]==="#"?h(e,u+1):null;d&&i.has(d.value)?(a+=t(d.value),u=d.end):(a+=e[u],u+=1)}return a}function X(e){let n="";for(let t=0;t<e.length;t+=1){if(e[t]==="\\\\"){let i=e[t+1];if(i!==void 0&&/[\\n\\r\\f]/.test(i)){t=$(e,t+1)-1;continue}let o=R(e,t);if(o){n+=o.value,t=o.end-1;continue}}n+=e[t]}return n}function N(e){return Array.from(e,n=>{let t=n.charCodeAt(0);return t===0?"\\uFFFD":t<32||t===127?`\\\\${t.toString(16)} `:n===\'"\'||n==="\\\\"?`\\\\${n}`:n}).join("")}function Y(e,n){return e?{kind:"any"}:n===void 0?{kind:"none"}:{kind:"named",prefix:n}}function Z(e,n){return e[n]==="|"&&e[n+1]!=="="}function B(e,n){let t=e[n]==="*",i=t?{value:"*",end:n+1}:h(e,n),o=y(e,i?.end??n);if(!Z(e,o))return t?null:i?{token:i,namespace:{kind:"none"}}:null;let a=h(e,y(e,o+1));return a?{token:a,namespace:Y(t,i?.value)}:null}function K(e){if(e[0]!=="[")return null;let n=A(e,1),t=B(e,n);if(!t)return null;let{token:i,namespace:o}=t;return{name:i.value,rawName:e.slice(n,i.end),namespace:o,end:i.end}}function ee(e,n){let t=/^(?:"((?:\\\\[\\s\\S]|[^"\\\\])*)"|\'((?:\\\\[\\s\\S]|[^\'\\\\])*)\')/.exec(e.slice(n));return t?{value:X(t[1]??t[2]),end:n+t[0].length}:h(e,n)}function ne(e,n){let t=A(e,n),i=h(e,t);if(i){if(!/^[is]$/i.test(i.value))return null;t=A(e,i.end)}return e[t]!=="]"||t!==e.length-1?null:{flag:i?.value}}function F(e){let n=K(e);if(!n)return null;let t=A(e,n.end),o=["=","~=","|=","^=","$=","*="].find(d=>e.startsWith(d,t));if(!o)return null;let a=ee(e,A(e,t+o.length));if(!a)return null;let u=ne(e,a.end);return u?{name:n.name,rawName:n.rawName,namespace:n.namespace,operator:o,value:a.value,flag:u.flag}:null}function E(e,n){return e.replace(W,t=>t.startsWith("[")?n(t):t)}var re="data-hf-svg-reference-aliases";function O(e,n,t,i){let o={"=":(s,r)=>s===r,"~=":(s,r)=>s.split(/[ \\t\\r\\n\\f]+/).includes(r),"|=":(s,r)=>s===r||s.startsWith(r+"-"),"^=":(s,r)=>s.startsWith(r),"$=":(s,r)=>s.endsWith(r),"*=":(s,r)=>s.includes(r)},a=(s,r,l)=>!r&&l!=="="&&l!=="|="?!1:o[l](s,r),u=s=>s.replace(/[A-Z]/g,r=>r.toLowerCase()),d=s=>{let r=F(s);if(!r)return s;let{name:l,rawName:g,namespace:m,operator:b,value:D,flag:w}=r;if(m.kind==="named"!=(i!==void 0))return s;let x=w?.toLowerCase()==="i"?u:S=>S,L=u(l),P=t.filter(S=>{let V=m.kind==="none"?S.name:S.localName,U=m.kind==="named"?i.get(m.prefix):null;return(m.kind==="any"||S.namespaceURI===U)&&u(V)===L}),v=new Set([s]);for(let S of P)a(x(S.before),x(D),b)&&v.add(`[${g}="${N(S.after)}"${w?` ${w}`:""}]`);return v.size===1?s:`:is(${[...v].join(", ")})`};if(i)return E(e,d);let p=new Map(n.map(({id:s,replacement:r})=>[s,r])),f=new Map;for(let s of t){if(s.name!=="id"||s.before===s.after||p.has(s.before))continue;let r=f.get(s.before);r||(r=new Set([`#${k(s.before)}`]),f.set(s.before,r)),r.add(`#${k(s.after)}`)}for(let[s,r]of f)p.set(s,`:is(${[...r].join(", ")})`);let c=q(e,[...p.keys()],s=>p.get(s));return E(c,d)}function se(e,n,t=!0){let i=[],a=(t?[...e.querySelectorAll(`[${n}]`)]:[]).map(d=>d.getAttribute(n)),u=e.getAttribute?.(n);u&&a.unshift(u);for(let d of a){let p;try{p=JSON.parse(d)}catch{continue}if(!Array.isArray(p))continue;let f=p;for(let c of f){if(!ie(c))continue;let{name:s,localName:r,namespaceURI:l,before:g,after:m}=c;i.push({name:s,localName:r,namespaceURI:l,before:g,after:m})}}return i}function ie(e){if(!e||typeof e!="object")return!1;let{name:n,localName:t,namespaceURI:i,before:o,after:a}=e;return typeof n=="string"&&typeof t=="string"&&(i===null||typeof i=="string")&&typeof o=="string"&&typeof a=="string"}function oe(e){let n=[],t=[],i=!1,o,a=new WeakMap,u=(f,c)=>{for(let s of f){if("selectorText"in s){let r=s,l=a.get(r),g=r.selectorText,m=l?.applied===g?l.authored:g,b=O(m,[],t,c);b!==g&&(r.selectorText=b),b===m?a.delete(r):a.set(r,{authored:m,applied:r.selectorText})}"cssRules"in s&&u(s.cssRules,c)}},d=()=>{if(t.length)for(let f of e.document.styleSheets){let c;try{c=f.cssRules}catch{continue}let s=new Map;for(let r of c){if(!("namespaceURI"in r))continue;let{prefix:l,namespaceURI:g}=r;l&&s.set(l,g||null)}s.size&&u(c,s)}},p={rewrite:(f,c=[])=>{if(typeof f!="string"||!f.includes("#")&&!f.includes("["))return f;let s=O(f,c.length?[...c,...n]:n,t);if(s!==f){if(!o){let r=e.document.createElement("div");o=r.matches.bind(r)}o(f)}return s},refresh(){t=se(e.document,re).filter(r=>r.before!==r.after);let f=new Set(t.filter(r=>r.name==="id").map(r=>r.before)),c=new Set;n=[];for(let r of e.document.querySelectorAll("[data-hf-authored-id][id]")){let l=r.getAttribute("data-hf-authored-id");if(!l||l===r.id||c.has(l)||f.has(l))continue;c.add(l);let g=N(l);n.push({id:l,replacement:`:is(#${k(l)}, [data-hf-authored-id="${g}"])`})}if(d(),i||!n.length&&!t.length)return;let s=e.Element.prototype;s.querySelector=new Proxy(s.querySelector,{apply(r,l,g){return Reflect.apply(r,l,[p.rewrite(g[0])])}}),s.querySelectorAll=new Proxy(s.querySelectorAll,{apply(r,l,g){return Reflect.apply(r,l,[p.rewrite(g[0])])}}),i=!0}};e.__hfSvgSelectorAliases=p,p.refresh()}function M(){let e=window;e.__hfSvgSelectorAliases||oe(e)}M();})();\n';
+function getSvgSelectorAliasesScript() {
+  return SVG_SELECTOR_ALIASES_IIFE;
+}
+
+// ../core/dist/compiler/compositionScoping.js
+import postcss from "postcss";
+
+// ../core/dist/compiler/selectorIdTokens.js
+function isNameChar(char) {
+  if (!char)
+    return false;
+  return /[\w-]/.test(char) || char.charCodeAt(0) >= 128;
+}
+function isCssWhitespace(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+}
+var HEX_ESCAPE_RE = /^[0-9a-fA-F]{1,6}/;
+function sanitizeCodePoint(codePoint) {
+  const isSurrogate = codePoint >= 55296 && codePoint <= 57343;
+  return codePoint === 0 || codePoint > 1114111 || isSurrogate ? 65533 : codePoint;
+}
+function skipEscapeWhitespace(text, index) {
+  if (text[index] === "\r" && text[index + 1] === "\n")
+    return index + 2;
+  return isCssWhitespace(text[index]) ? index + 1 : index;
+}
+function consumeCssEscape(text, index) {
+  const next = text[index + 1];
+  if (next === void 0 || /[\n\r\f]/.test(next))
+    return null;
+  const hex = HEX_ESCAPE_RE.exec(text.slice(index + 1, index + 7));
+  if (!hex)
+    return { value: next, end: index + 2 };
+  const codePoint = sanitizeCodePoint(Number.parseInt(hex[0], 16));
+  return {
+    value: String.fromCodePoint(codePoint),
+    end: skipEscapeWhitespace(text, index + 1 + hex[0].length)
+  };
+}
+function startsCssIdentifier(text, start) {
+  const isStart = (char) => isNameChar(char) && !/[0-9-]/.test(char);
+  const escape = (index) => text[index] === "\\" && consumeCssEscape(text, index) !== null;
+  if (text[start] === "-")
+    return text[start + 1] === "-" || isStart(text[start + 1]) || escape(start + 1);
+  return isStart(text[start]) || escape(start);
+}
+function skipCssComments(text, start) {
+  let index = start;
+  while (text.startsWith("/*", index)) {
+    const end = text.indexOf("*/", index + 2);
+    index = end < 0 ? text.length : end + 2;
+  }
+  return index;
+}
+function skipCssTrivia(text, start) {
+  let index = skipCssComments(text, start);
+  while (isCssWhitespace(text[index]))
+    index = skipCssComments(text, index + 1);
+  return index;
+}
+function decodeCssIdentifierAt(text, start) {
+  if (!startsCssIdentifier(text, start))
+    return null;
+  let index = start;
+  let value = "";
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      const escape = consumeCssEscape(text, index);
+      if (!escape)
+        break;
+      value += escape.value;
+      index = escape.end;
+      continue;
+    }
+    if (!isNameChar(char))
+      break;
+    value += char;
+    index += 1;
+  }
+  return index === start ? null : { value, end: index };
+}
+var CODE_UNIT_HYPHEN = 45;
+function isDigitCodeUnit(codeUnit) {
+  return codeUnit >= 48 && codeUnit <= 57;
+}
+function isPlainNameCodeUnit(codeUnit) {
+  return codeUnit >= 128 || codeUnit === CODE_UNIT_HYPHEN || codeUnit === 95 || isDigitCodeUnit(codeUnit) || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122;
+}
+function needsHexEscape(value, index) {
+  const codeUnit = value.charCodeAt(index);
+  if (codeUnit >= 1 && codeUnit <= 31 || codeUnit === 127)
+    return true;
+  if (!isDigitCodeUnit(codeUnit))
+    return false;
+  return index === 0 || index === 1 && value.charCodeAt(0) === CODE_UNIT_HYPHEN;
+}
+function escapeCssIdentifier(value) {
+  let result = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    const char = value[index];
+    if (codeUnit === 0)
+      result += "\uFFFD";
+    else if (needsHexEscape(value, index))
+      result += `\\${codeUnit.toString(16)} `;
+    else if (index === 0 && value.length === 1 && codeUnit === CODE_UNIT_HYPHEN)
+      result += `\\${char}`;
+    else if (isPlainNameCodeUnit(codeUnit))
+      result += char;
+    else
+      result += `\\${char}`;
+  }
+  return result;
+}
+var GUARDED_SELECTOR_SEGMENT_RE = /\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:[0-9a-fA-F]{1,6}(?:\r\n|[ \t\r\n\f])?|[\s\S])|"(?:[^"\\]|\\[\s\S])*"|'(?:[^'\\]|\\[\s\S])*'|\[(?:\/\*(?:[^*]|\*(?!\/))*\*\/|\\[\s\S]|"(?:[^"\\]|\\[\s\S])*"|'(?:[^'\\]|\\[\s\S])*'|[^\]"'\\/]|\/(?!\*))*\]/g;
+function markUnguardedOffsets(selector) {
+  const mask = new Array(selector.length).fill(true);
+  for (const match of selector.matchAll(GUARDED_SELECTOR_SEGMENT_RE)) {
+    const start = match.index;
+    mask.fill(false, start, start + match[0].length);
+  }
+  return mask;
+}
+function replaceSelectorIdTokens(selector, candidateIds, resolveReplacement) {
+  if (candidateIds.length === 0 || !selector.includes("#"))
+    return selector;
+  const candidates = new Set(candidateIds);
+  const unguarded = markUnguardedOffsets(selector);
+  let result = "";
+  let index = 0;
+  while (index < selector.length) {
+    const token = unguarded[index] && selector[index] === "#" ? decodeCssIdentifierAt(selector, index + 1) : null;
+    if (token && candidates.has(token.value)) {
+      result += resolveReplacement(token.value);
+      index = token.end;
+    } else {
+      result += selector[index];
+      index += 1;
+    }
+  }
+  return result;
+}
+function decodeCssString(value) {
+  let result = "";
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === "\\") {
+      const next = value[index + 1];
+      if (next !== void 0 && /[\n\r\f]/.test(next)) {
+        index = skipEscapeWhitespace(value, index + 1) - 1;
+        continue;
+      }
+      const escaped = consumeCssEscape(value, index);
+      if (escaped) {
+        result += escaped.value;
+        index = escaped.end - 1;
+        continue;
+      }
+    }
+    result += value[index];
+  }
+  return result;
+}
+function escapeCssAttributeValue(value) {
+  return Array.from(value, (char) => {
+    const code = char.charCodeAt(0);
+    if (code === 0)
+      return "\uFFFD";
+    if (code < 32 || code === 127)
+      return `\\${code.toString(16)} `;
+    return char === '"' || char === "\\" ? `\\${char}` : char;
+  }).join("");
+}
+function attributeNamespace(wildcard, prefix) {
+  if (wildcard)
+    return { kind: "any" };
+  return prefix === void 0 ? { kind: "none" } : { kind: "named", prefix };
+}
+function isNamespaceSeparator(text, offset) {
+  return text[offset] === "|" && text[offset + 1] !== "=";
+}
+function readQualifiedAttributeName(text, start) {
+  const wildcard = text[start] === "*";
+  const first = wildcard ? { value: "*", end: start + 1 } : decodeCssIdentifierAt(text, start);
+  const separator = skipCssComments(text, first?.end ?? start);
+  if (!isNamespaceSeparator(text, separator)) {
+    if (wildcard)
+      return null;
+    return first ? { token: first, namespace: { kind: "none" } } : null;
+  }
+  const token = decodeCssIdentifierAt(text, skipCssComments(text, separator + 1));
+  if (!token)
+    return null;
+  return { token, namespace: attributeNamespace(wildcard, first?.value) };
+}
+function readAttributeName(predicate) {
+  if (predicate[0] !== "[")
+    return null;
+  const start = skipCssTrivia(predicate, 1);
+  const qualified = readQualifiedAttributeName(predicate, start);
+  if (!qualified)
+    return null;
+  const { token, namespace } = qualified;
+  return {
+    name: token.value,
+    rawName: predicate.slice(start, token.end),
+    namespace,
+    end: token.end
+  };
+}
+function readAttributeValue(predicate, start) {
+  const quoted = /^(?:"((?:\\[\s\S]|[^"\\])*)"|'((?:\\[\s\S]|[^'\\])*)')/.exec(predicate.slice(start));
+  if (quoted)
+    return { value: decodeCssString(quoted[1] ?? quoted[2]), end: start + quoted[0].length };
+  return decodeCssIdentifierAt(predicate, start);
+}
+function readAttributeEnding(predicate, start) {
+  let offset = skipCssTrivia(predicate, start);
+  const token = decodeCssIdentifierAt(predicate, offset);
+  if (token) {
+    if (!/^[is]$/i.test(token.value))
+      return null;
+    offset = skipCssTrivia(predicate, token.end);
+  }
+  if (predicate[offset] !== "]" || offset !== predicate.length - 1)
+    return null;
+  return { flag: token?.value };
+}
+function parseAttributeSelector(predicate) {
+  const name = readAttributeName(predicate);
+  if (!name)
+    return null;
+  const offset = skipCssTrivia(predicate, name.end);
+  const operators = ["=", "~=", "|=", "^=", "$=", "*="];
+  const operator = operators.find((candidate) => predicate.startsWith(candidate, offset));
+  if (!operator)
+    return null;
+  const value = readAttributeValue(predicate, skipCssTrivia(predicate, offset + operator.length));
+  if (!value)
+    return null;
+  const ending = readAttributeEnding(predicate, value.end);
+  if (!ending)
+    return null;
+  return {
+    name: name.name,
+    rawName: name.rawName,
+    namespace: name.namespace,
+    operator,
+    value: value.value,
+    flag: ending.flag
+  };
+}
+function replaceSelectorAttributeTokens(selector, rewrite) {
+  return selector.replace(GUARDED_SELECTOR_SEGMENT_RE, (segment) => segment.startsWith("[") ? rewrite(segment) : segment);
+}
+
+// ../core/dist/compiler/compositionScoping.js
+var AUTHORED_ROOT_ID_ATTR = "data-hf-authored-id";
+var INNER_ROOT_ATTR = "data-hf-inner-root";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeCssAttributeValue2(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function getAuthoredRootIdSelectorForms(authoredRootId) {
+  const trimmed = authoredRootId.trim();
+  if (!trimmed)
+    return [];
+  return Array.from(/* @__PURE__ */ new Set([trimmed, escapeCssIdentifier(trimmed)])).filter(Boolean);
+}
+function replaceAuthoredRootIdSelectors(selector, authoredRootId, replacement) {
+  const forms = getAuthoredRootIdSelectorForms(authoredRootId);
+  return replaceSelectorIdTokens(selector, forms, () => replacement);
+}
+function normalizeAuthoredRootIdSelector(selector, authoredRootId) {
+  const trimmed = authoredRootId?.trim();
+  if (!trimmed)
+    return selector;
+  return replaceAuthoredRootIdSelectors(selector, trimmed, `[${AUTHORED_ROOT_ID_ATTR}="${escapeCssAttributeValue2(trimmed)}"]`);
+}
+function compositionBoxSelector(scope) {
+  return `${scope}:not(:has([${INNER_ROOT_ATTR}])), ${scope} > [${INNER_ROOT_ATTR}]`;
+}
+function scopeSelector(selector, scope, compositionId, authoredRootId, compoundAuthoredRoot, scopeRootSelectors) {
+  const selectorWithoutAuthoredRootId = normalizeAuthoredRootIdSelector(selector, authoredRootId);
+  const selectorWithoutRootTiming = normalizeCompositionRootSelector(selectorWithoutAuthoredRootId, scope, compositionId);
+  const trimmed = selectorWithoutRootTiming.trim();
+  if (!trimmed)
+    return selector;
+  if (trimmed === "*")
+    return selector;
+  if (/^(html|body|:root)$/i.test(trimmed)) {
+    return scopeRootSelectors ? compositionBoxSelector(scope) : selector;
+  }
+  const compositionIdPattern = new RegExp(`\\[\\s*data-composition-id\\s*[\\^\\*\\$]?=\\s*(["'])${escapeRegExp(compositionId)}\\1\\s*\\]`, "g");
+  if (compositionIdPattern.test(trimmed)) {
+    const isRootBoxSelector = trimmed.replace(compositionIdPattern, "").trim() === "";
+    if (isRootBoxSelector) {
+      return compositionBoxSelector(scope);
+    }
+    return selectorWithoutRootTiming.replace(compositionIdPattern, scope);
+  }
+  const leading = selectorWithoutRootTiming.match(/^\s*/)?.[0] ?? "";
+  const trailing = selectorWithoutRootTiming.match(/\s*$/)?.[0] ?? "";
+  if (compoundAuthoredRoot) {
+    const authoredRootAttr = authoredRootId ? `[${AUTHORED_ROOT_ID_ATTR}="${escapeCssAttributeValue2(authoredRootId)}"]` : null;
+    if (authoredRootAttr && trimmed.startsWith(authoredRootAttr)) {
+      const rest = trimmed.slice(authoredRootAttr.length);
+      return `${leading}${scope}${authoredRootAttr}${rest}${trailing}`;
+    }
+  }
+  return `${leading}${scope} ${trimmed}${trailing}`;
+}
+function normalizeCompositionRootSelector(selector, scope, compositionId) {
+  const quotedCompId = escapeRegExp(compositionId);
+  const compAttr = String.raw`\[\s*data-composition-id\s*=\s*(?:"${quotedCompId}"|'${quotedCompId}')\s*\]`;
+  const timingAttr = String.raw`\s*\[\s*data-(?:start|duration)\s*=\s*(?:"[^"]*"|'[^']*')\s*\]`;
+  return selector.replace(new RegExp(`${compAttr}(?:${timingAttr})+`, "g"), scope).replace(new RegExp(`(?:${timingAttr})+${compAttr}`, "g"), scope);
+}
+var GLOBAL_AT_RULES = /* @__PURE__ */ new Set(["keyframes", "-webkit-keyframes", "font-face"]);
+function isAtRuleNode(node) {
+  return node?.type === "atrule";
+}
+function isInsideGlobalAtRule(rule) {
+  let current = rule.parent;
+  while (current) {
+    if (isAtRuleNode(current) && GLOBAL_AT_RULES.has(current.name.toLowerCase())) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isNestedInsideAnotherRule(rule) {
+  let current = rule.parent;
+  while (current) {
+    if (current.type === "rule")
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function scopeCssToComposition(css, compositionId, scopeSelectorOverride, authoredRootId, options) {
+  const trimmedCompositionId = compositionId.trim();
+  if (!css || !trimmedCompositionId)
+    return css;
+  const scope = scopeSelectorOverride || `[data-composition-id="${escapeCssAttributeValue2(trimmedCompositionId)}"]`;
+  const root = parseCss(css);
+  return root ? scopeParsedCss(root, scope, trimmedCompositionId, authoredRootId, options) : "";
+}
+function parseCss(css) {
+  try {
+    return postcss.parse(css);
+  } catch {
+    return null;
+  }
+}
+function forEachScopedRule(root, visit) {
+  root.walkRules((rule) => {
+    if (isInsideGlobalAtRule(rule))
+      return;
+    if (isNestedInsideAnotherRule(rule))
+      return;
+    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";
+}
+function fontFaceKey(atRule) {
+  const decls = [];
+  atRule.walkDecls((decl) => {
+    const value = decl.value.replace(/("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')|\s+/g, (_m, str) => str ?? " ");
+    decls.push(`${decl.prop.trim().toLowerCase()}:${value.trim()}${decl.important ? "!important" : ""}`);
+  });
+  return decls.join(";");
+}
+var dedupeFontFaceRules = (styleTexts) => dropFontFaces(styleTexts);
+function hoistFontFaceRules(styleTexts) {
+  const faces = [];
+  return { styles: dropFontFaces(styleTexts, faces), faces };
+}
+function dropFontFaces(styleTexts, hoisted) {
+  const seen = /* @__PURE__ */ new Set();
+  return [...styleTexts].reverse().map((css) => {
+    if (!css || !/@font-face/i.test(css))
+      return css;
+    let root;
+    try {
+      root = postcss.parse(css);
+    } catch {
+      return css;
+    }
+    let changed = false;
+    for (const node of [...root.nodes ?? []].reverse()) {
+      if (!isFontFaceAtRule(node))
+        continue;
+      const key = fontFaceKey(node);
+      if (!seen.has(key)) {
+        seen.add(key);
+        if (!hoisted)
+          continue;
+        hoisted.unshift(node.toString());
+      }
+      node.remove();
+      changed = true;
+    }
+    return changed ? root.toResult({ map: false }).css : css;
+  }).reverse();
+}
+function jsonScriptLiteral(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+var SCOPED_HYPERFRAMES_EXPRESSION = `!__hfBaseHyperframes
+    ? __hfBaseHyperframes
+    : Object.assign({}, __hfBaseHyperframes, {
+        assetUrl: function(path) {
+          var page = window.document.baseURI;
+          return new URL(path, __hfCompositionSrc ? new URL(__hfCompositionSrc, page) : page).href;
+        },
+        getVariables: function() {
+          var byComp = window.__hfVariablesByComp;
+          var scoped = byComp && __hfTimelineCompId ? byComp[__hfTimelineCompId] : null;
+          return scoped ? Object.assign({}, scoped) : {};
+        },
+      })`;
+function scopedModulePrelude(timelineCompositionId, compositionSrc) {
+  return `const __hyperframes = (function(__hfBaseHyperframes, __hfTimelineCompId, __hfCompositionSrc) {
+  return ${SCOPED_HYPERFRAMES_EXPRESSION};
+})(window.__hyperframes, ${jsonScriptLiteral(timelineCompositionId)}, ${jsonScriptLiteral(compositionSrc?.trim() || null)});
+${wrapScopedCompositionScript("", timelineCompositionId)}
+`;
+}
+function wrapScopedCompositionScript(source, compositionId, errorLabel = "[Framey] composition script error:", scopeSelectorOverride, timelineCompositionId = compositionId, authoredRootId, compositionSrc) {
+  const compositionIdLiteral = jsonScriptLiteral(compositionId);
+  const timelineCompositionIdLiteral = jsonScriptLiteral(timelineCompositionId);
+  const errorLabelLiteral = jsonScriptLiteral(errorLabel);
+  const escapedCompositionId = escapeRegExp(compositionId);
+  const authoredRootIdLiteral = jsonScriptLiteral(authoredRootId?.trim() || null);
+  const scopeSelectorLiteral = jsonScriptLiteral(scopeSelectorOverride ?? null);
+  const rootSelectorPatternLiteral = jsonScriptLiteral(String.raw`\[\s*data-composition-id\s*=\s*(?:"${escapedCompositionId}"|'${escapedCompositionId}')\s*\]`);
+  const timingSelectorPatternLiteral = jsonScriptLiteral(String.raw`\s*\[\s*data-(?:start|duration)\s*=\s*(?:"[^"]*"|'[^']*')\s*\]`);
+  const aliasInstallerOutsideAuthoredStrictness = `(function(){ ${getSvgSelectorAliasesScript()} })();`;
+  return `(function(){
+  ${aliasInstallerOutsideAuthoredStrictness}
+  var __hfCompId = ${compositionIdLiteral};
+  var __hfTimelineCompId = ${timelineCompositionIdLiteral};
+  var __hfErrorLabel = ${errorLabelLiteral};
+  var __hfAuthoredRootId = ${authoredRootIdLiteral};
+  var __hfCompositionSrc = ${jsonScriptLiteral(compositionSrc?.trim() || null)};
+  var __hfAuthoredRootAttr = ${jsonScriptLiteral(AUTHORED_ROOT_ID_ATTR)};
+  var __hfEscapeAttr = function(value) {
+    return (value + "").replace(/\\\\/g, "\\\\\\\\").replace(/"/g, "\\\\\\"");
+  };
+  var __hfRootSelector = ${scopeSelectorLiteral} || (__hfCompId
+    ? '[data-composition-id="' + __hfEscapeAttr(__hfCompId) + '"]'
+    : "");
+  var __hfRoot = null;
+  var __hfRootSelectorPattern = ${rootSelectorPatternLiteral};
+  var __hfTimingSelectorPattern = ${timingSelectorPatternLiteral};
+  var __hfAuthoredRootSelector = __hfAuthoredRootId
+    ? "[" + __hfAuthoredRootAttr + '="' + __hfEscapeAttr(__hfAuthoredRootId) + '"]'
+    : "";
+  var __hfAuthoredRootEntries = __hfAuthoredRootSelector
+    ? [{ id: __hfAuthoredRootId, replacement: __hfAuthoredRootSelector }]
+    : [];
+  var __hfNormalizeSelector = function(selector) {
+    if (!__hfCompId || typeof selector !== "string") return selector;
+    var normalized = selector
+      .replace(new RegExp(__hfRootSelectorPattern + '(?:' + __hfTimingSelectorPattern + ')+', 'g'), __hfRootSelector)
+      .replace(new RegExp('(?:' + __hfTimingSelectorPattern + ')+' + __hfRootSelectorPattern, 'g'), __hfRootSelector);
+    return window.__hfSvgSelectorAliases.rewrite(normalized, __hfAuthoredRootEntries);
+  };
+  var __hfFindRoot = function() {
+    if (!__hfRoot && __hfRootSelector) {
+      __hfRoot = window.document.querySelector(__hfRootSelector);
+    }
+    return __hfRoot;
+  };
+  var __hfContains = function(node) {
+    var root = __hfFindRoot();
+    return !root || node === root || root.contains(node);
+  };
+  var __hfQueryAll = function(selector) {
+    var root = __hfFindRoot();
+    if (!root || typeof selector !== "string") {
+      return window.document.querySelectorAll(selector);
+    }
+    return Array.prototype.filter.call(window.document.querySelectorAll(__hfNormalizeSelector(selector)), function(node) {
+      return __hfContains(node);
+    });
+  };
+  var __hfQueryOne = function(selector) {
+    var matches = __hfQueryAll(selector);
+    return matches[0] || null;
+  };
+  var __hfGetElementById = function(id) {
+    var found = window.document.getElementById(id);
+    if (found && __hfContains(found)) return found;
+    var root = __hfFindRoot();
+    if (!root) return found || null;
+    var idValue = id + "";
+    if (__hfAuthoredRootId && __hfAuthoredRootId === idValue && root.getAttribute && root.getAttribute(__hfAuthoredRootAttr) === idValue) {
+      return root;
+    }
+    if (root.id === idValue) return root;
+    if (typeof root.querySelector !== "function") return null;
+    try {
+      var authoredRootMatch = root.querySelector('[' + __hfAuthoredRootAttr + '="' + __hfEscapeAttr(idValue) + '"]');
+      if (authoredRootMatch) return authoredRootMatch;
+    } catch {}
+    if (typeof CSS !== "undefined" && CSS && typeof CSS.escape === "function") {
+      try {
+        return root.querySelector("#" + CSS.escape(idValue)) || null;
+      } catch {}
+    }
+    try {
+      return root.querySelector('[id="' + __hfEscapeAttr(idValue) + '"]') || null;
+    } catch {}
+    return null;
+  };
+  var __hfScopedDocument = typeof Proxy === "function"
+    ? new Proxy(window.document, {
+        get: function(target, prop, receiver) {
+          if (prop === "querySelector") return __hfQueryOne;
+          if (prop === "querySelectorAll") return __hfQueryAll;
+          if (prop === "getElementById") return __hfGetElementById;
+          var value = Reflect.get(target, prop, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        },
+      })
+    : window.document;
+  var __hfTimelineRegistryProxy = null;
+  var __hfGetTimelineRegistry = function() {
+    window.__timelines = window.__timelines || {};
+    if (!__hfCompId || __hfCompId === __hfTimelineCompId || typeof Proxy !== "function") {
+      return window.__timelines;
+    }
+    if (!__hfTimelineRegistryProxy) {
+      __hfTimelineRegistryProxy = new Proxy(window.__timelines, {
+        get: function(target, prop, receiver) {
+          if (prop !== __hfCompId) {
+            return Reflect.get(target, prop, target);
+          }
+          var runtimeValue = Reflect.get(target, __hfTimelineCompId, target);
+          return runtimeValue === undefined ? Reflect.get(target, prop, target) : runtimeValue;
+        },
+        set: function(target, prop, value, receiver) {
+          if (prop !== __hfCompId) {
+            return Reflect.set(target, prop, value, target);
+          }
+          // The authored node remains in the compiled DOM when its local id
+          // differs from the runtime mount id, so readiness legitimately sees
+          // both compositions. Publish the same timeline under both identities,
+          // unless another mount of the same file already owns the authored one.
+          var authoredValue = Reflect.get(target, __hfCompId, target);
+          var ownsAuthored =
+            authoredValue === undefined ||
+            authoredValue === Reflect.get(target, __hfTimelineCompId, target);
+          var runtimeSet = Reflect.set(target, __hfTimelineCompId, value, target);
+          if (!ownsAuthored) return runtimeSet;
+          return Reflect.set(target, __hfCompId, value, target) && runtimeSet;
+        },
+      });
+    }
+    return __hfTimelineRegistryProxy;
+  };
+  var __hfScopedWindow = typeof Proxy === "function"
+    ? new Proxy(window, {
+        get: function(target, prop, receiver) {
+          if (prop === "__timelines") return __hfGetTimelineRegistry();
+          // Inside a sub-composition, __hyperframes is passed as a bare script
+          // param bound to the SCOPED variant (per-comp getVariables). But
+          // authors routinely write the documented window.__hyperframes.
+          // getVariables() form, which would otherwise fall through to the host
+          // page's base __hyperframes and return the WRONG (or empty) variables
+          // for this instance. Route it to the scoped variant too so both
+          // spellings resolve to this composition's own variables.
+          // (__hfScopedHyperframes is a hoisted var assigned below, before any
+          // sub-comp script -- the only code that reads this -- runs.)
+          if (prop === "__hyperframes") return __hfScopedHyperframes;
+          // Native window methods must stay bound to the real window. Handed
+          // back unbound, "this" at call time is this Proxy and Chrome rejects
+          // it with "Illegal invocation", which broke window.addEventListener,
+          // setTimeout, matchMedia and getComputedStyle inside every
+          // sub-composition -- including the window.addEventListener("hf-seek",
+          // ...) form the Three.js and TypeGPU adapters document. The sibling
+          // document and gsap proxies here already bind.
+          //
+          // Only bind non-constructors. Function.prototype.bind drops static
+          // members, so binding a class exposed on window (window.Texts and
+          // friends) would silently strip its statics. Built-in methods have
+          // no .prototype; classes and constructor functions do.
+          var value = Reflect.get(target, prop, target);
+          return typeof value === "function" && value.prototype === undefined
+            ? value.bind(target)
+            : value;
+        },
+        set: function(target, prop, value, receiver) {
+          if (prop === "__timelines") {
+            // Common authoring boilerplate assigns the registry back to
+            // itself (window.__timelines = window.__timelines || {}). The
+            // getter above returns our proxy; do not replace the canonical
+            // registry with that proxy or later wrappers will stack proxies.
+            if (value === __hfTimelineRegistryProxy) return true;
+            target.__timelines = value || {};
+            __hfTimelineRegistryProxy = null;
+            return true;
+          }
+          return Reflect.set(target, prop, value, target);
+        },
+      })
+    : window;
+  var __hfResolveGsapTarget = function(target) {
+    if (typeof target !== "string" && !Array.isArray(target)) return target;
+    var resolved = typeof target === "string" ? __hfQueryAll(target) : target.reduce(function(resolved, item) {
+      if (typeof item === "string") {
+        return resolved.concat(Array.prototype.slice.call(__hfQueryAll(item)));
+      }
+      resolved.push(item);
+      return resolved;
+    }, []);
+    if (!resolved.length) {
+      // GSAP warns "GSAP target " + targets + " not found"; a bare empty match list prints an
+      // empty name. Keep the authored selector as the text while still targeting nothing here.
+      var originalTarget = String(target);
+      resolved = [];
+      resolved.toString = function() { return originalTarget; };
+    }
+    return resolved;
+  };
+  var __hfScopeTimeline = function(timeline) {
+    if (!timeline || timeline.__hfScopedCompositionRoot === __hfFindRoot()) return timeline;
+    ["to", "from", "fromTo", "set"].forEach(function(method) {
+      var original = timeline[method];
+      if (typeof original !== "function") return;
+      timeline[method] = function(target) {
+        var args = Array.prototype.slice.call(arguments);
+        args[0] = __hfResolveGsapTarget(target);
+        return original.apply(timeline, args);
+      };
+    });
+    try {
+      Object.defineProperty(timeline, "__hfScopedCompositionRoot", {
+        value: __hfFindRoot(),
+        configurable: true,
+      });
+    } catch {
+      // Best-effort: timelines coming from user code may have a frozen target
+      // or a non-extensible defineProperty path. Swallow \u2014 the scoped root
+      // is an enrichment, not a correctness invariant for playback.
+    }
+    return timeline;
+  };
+  var __hfBaseGsap = typeof gsap === "undefined" ? window.gsap : gsap;
+  var __hfScopedGsap = !__hfBaseGsap || typeof Proxy !== "function"
+    ? __hfBaseGsap
+    : new Proxy(__hfBaseGsap, {
+        get: function(target, prop, receiver) {
+          if (prop === "timeline") {
+            return function() {
+              return __hfScopeTimeline(target.timeline.apply(target, arguments));
+            };
+          }
+          if (prop === "to" || prop === "from" || prop === "fromTo" || prop === "set") {
+            return function(firstArg) {
+              var args = Array.prototype.slice.call(arguments);
+              args[0] = __hfResolveGsapTarget(firstArg);
+              return target[prop].apply(target, args);
+            };
+          }
+          if (prop === "utils" && target.utils && typeof Proxy === "function") {
+            return new Proxy(target.utils, {
+              get: function(utilsTarget, utilsProp, utilsReceiver) {
+                if (utilsProp === "toArray") {
+                  return function(firstArg) {
+                    var args = Array.prototype.slice.call(arguments);
+                    args[0] = __hfResolveGsapTarget(firstArg);
+                    return utilsTarget.toArray.apply(utilsTarget, args);
+                  };
+                }
+                if (utilsProp === "selector") {
+                  return function(base) {
+                    var baseEl = typeof base === "string" ? __hfQueryOne(base) : base;
+                    var root = baseEl || __hfFindRoot();
+                    return function(selector) {
+                      if (!root || typeof selector !== "string") return [];
+                      return Array.prototype.filter.call(
+                        window.document.querySelectorAll(__hfNormalizeSelector(selector)),
+                        function(node) {
+                          return node === root || (typeof root.contains === "function" && root.contains(node));
+                        },
+                      );
+                    };
+                  };
+                }
+                var value = Reflect.get(utilsTarget, utilsProp, utilsTarget);
+                return typeof value === "function" ? value.bind(utilsTarget) : value;
+              },
+            });
+          }
+          var value = Reflect.get(target, prop, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        },
+      });
+  var __hfBaseHyperframes = window.__hyperframes;
+  var __hfScopedHyperframes = ${SCOPED_HYPERFRAMES_EXPRESSION};
+  var __hfRun = function() {
+    var report = window.__hfScriptState;
+    if (typeof report === "function") report("start", __hfCompositionSrc || "index.html");
+    try {
+      (function(document, gsap, window, __hyperframes) {
+${source.replace(/<\/(script)/gi, "<\\/$1")}
+      }).call(window, __hfScopedDocument, __hfScopedGsap, __hfScopedWindow, __hfScopedHyperframes);
+    } catch (_err) {
+      console.error(__hfErrorLabel, __hfCompId, _err);
+    } finally {
+      if (typeof report === "function") report("finish", __hfCompositionSrc || "index.html");
+    }
+  };
+  // What the script started on the global gsap timeline, by any route, for a scene swap to revert.
+  // Only a page with a scene manifest can swap; elsewhere the first script stores null and none records.
+  var __hfRecordAnimations = function(run) {
+    if (window.__hfSceneAnimations === undefined) {
+      window.__hfSceneAnimations = window.document.querySelector(${jsonScriptLiteral(`meta[name="${SCENE_PARTS_META}"]`)})
+        ? {}
+        : null;
+    }
+    var byComp = window.__hfSceneAnimations;
+    var globalTimeline = __hfBaseGsap && __hfBaseGsap.globalTimeline;
+    if (!byComp || !globalTimeline || !__hfTimelineCompId) return run();
+    var before = globalTimeline.getChildren(false);
+    // A set completes as it is made and would leave the timeline before the diff below.
+    var autoRemove = globalTimeline.autoRemoveChildren;
+    globalTimeline.autoRemoveChildren = false;
+    run();
+    globalTimeline.autoRemoveChildren = autoRemove;
+    var recorded = (byComp[__hfTimelineCompId] = byComp[__hfTimelineCompId] || []);
+    globalTimeline.getChildren(false).forEach(function(animation) {
+      if (before.indexOf(animation) >= 0) return;
+      recorded.push(animation);
+      // Dropped as the timeline drops a finished tween (it keeps a paused one); moved back, a tween re-adds itself.
+      if (autoRemove && !animation.getChildren && animation.totalProgress() === 1) globalTimeline.remove(animation);
+    });
+  };
+  __hfFindRoot();
+  __hfRecordAnimations(__hfRun);
+})();`;
+}
+function wrapInlineScriptWithErrorBoundary(source, errorLabel) {
+  return `(function(){ try { Function(${jsonScriptLiteral(source)}).call(window); } catch (_err) { console.error(${jsonScriptLiteral(errorLabel)}, _err); } })();`;
+}
+function buildVariablesByCompScript(variablesByComp) {
+  if (!variablesByComp || Object.keys(variablesByComp).length === 0)
+    return null;
+  const json = jsonScriptLiteral(variablesByComp);
+  return `window.__hfVariablesByComp = Object.assign({}, window.__hfVariablesByComp || {}, ${json});`;
+}
+
+// ../core/dist/compiler/staticGuard.js
+async function validateHyperframeHtmlContract(html) {
+  const result = await lintHyperframeHtml(html);
+  const missingKeys = result.findings.filter((finding) => finding.severity === "error").map((finding) => finding.message);
+  if (missingKeys.length === 0) {
+    return { isValid: true, missingKeys: [], failureReason: null };
+  }
+  const joined = missingKeys.join(" ").toLowerCase();
+  let failureReason = "invalid_static_hyperframe_contract";
+  if (joined.includes("data-composition-id")) {
+    failureReason = "missing_composition_id";
+  } else if (joined.includes("data-width") || joined.includes("data-height")) {
+    failureReason = "missing_composition_dimensions";
+  } else if (joined.includes("window.__timelines")) {
+    failureReason = "missing_timeline_registry";
+  } else if (joined.includes("script syntax")) {
+    failureReason = "invalid_script_syntax";
+  }
+  return { isValid: false, missingKeys, failureReason };
+}
+
+// ../core/dist/compiler/svgSelectorAliases.js
+var SVG_REFERENCE_ALIASES_ATTR = "data-hf-svg-reference-aliases";
+function rewriteSvgSelectors(selector, ids, references, namespaces) {
+  const attributeOperators = {
+    "=": (before, value) => before === value,
+    "~=": (before, value) => before.split(/[ \t\r\n\f]+/).includes(value),
+    "|=": (before, value) => before === value || before.startsWith(value + "-"),
+    "^=": (before, value) => before.startsWith(value),
+    "$=": (before, value) => before.endsWith(value),
+    "*=": (before, value) => before.includes(value)
+  };
+  const matchesValue = (before, value, operator) => {
+    if (!value && operator !== "=" && operator !== "|=")
+      return false;
+    return attributeOperators[operator](before, value);
+  };
+  const lower = (text) => text.replace(/[A-Z]/g, (char) => char.toLowerCase());
+  const rewriteAttribute = (predicate) => {
+    const parsed = parseAttributeSelector(predicate);
+    if (!parsed)
+      return predicate;
+    const { name, rawName, namespace, operator, value, flag } = parsed;
+    if (namespace.kind === "named" !== (namespaces !== void 0))
+      return predicate;
+    const fold = flag?.toLowerCase() === "i" ? lower : (text) => text;
+    const attributeName = lower(name);
+    const candidates = references.filter((reference) => {
+      const actualName = namespace.kind === "none" ? reference.name : reference.localName;
+      const uri = namespace.kind === "named" ? namespaces.get(namespace.prefix) : null;
+      return (namespace.kind === "any" || reference.namespaceURI === uri) && lower(actualName) === attributeName;
+    });
+    const alternatives = /* @__PURE__ */ new Set([predicate]);
+    for (const reference of candidates) {
+      if (!matchesValue(fold(reference.before), fold(value), operator))
+        continue;
+      alternatives.add(`[${rawName}="${escapeCssAttributeValue(reference.after)}"${flag ? ` ${flag}` : ""}]`);
+    }
+    return alternatives.size === 1 ? predicate : `:is(${[...alternatives].join(", ")})`;
+  };
+  if (namespaces)
+    return replaceSelectorAttributeTokens(selector, rewriteAttribute);
+  const replacements = new Map(ids.map(({ id, replacement }) => [id, replacement]));
+  const targets = /* @__PURE__ */ new Map();
+  for (const reference of references) {
+    if (reference.name !== "id" || reference.before === reference.after || replacements.has(reference.before))
+      continue;
+    let alternatives = targets.get(reference.before);
+    if (!alternatives) {
+      alternatives = /* @__PURE__ */ new Set([`#${escapeCssIdentifier(reference.before)}`]);
+      targets.set(reference.before, alternatives);
+    }
+    alternatives.add(`#${escapeCssIdentifier(reference.after)}`);
+  }
+  for (const [id, alternatives] of targets)
+    replacements.set(id, `:is(${[...alternatives].join(", ")})`);
+  const rewrittenIds = replaceSelectorIdTokens(selector, [...replacements.keys()], (id) => replacements.get(id));
+  return replaceSelectorAttributeTokens(rewrittenIds, rewriteAttribute);
+}
+function readSvgReferenceAliases(root, attribute, includeDescendants = true) {
+  const aliases = [];
+  const nodes = includeDescendants ? [...root.querySelectorAll(`[${attribute}]`)] : [];
+  const texts = nodes.map((node) => node.getAttribute(attribute));
+  const own = root.getAttribute?.(attribute);
+  if (own)
+    texts.unshift(own);
+  for (const text of texts) {
+    let value;
+    try {
+      value = JSON.parse(text);
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(value))
+      continue;
+    const entries = value;
+    for (const entry of entries) {
+      if (!isSvgReferenceAlias(entry))
+        continue;
+      const { name, localName, namespaceURI, before, after } = entry;
+      aliases.push({ name, localName, namespaceURI, before, after });
+    }
+  }
+  return aliases;
+}
+function isSvgReferenceAlias(entry) {
+  if (!entry || typeof entry !== "object")
+    return false;
+  const { name, localName, namespaceURI, before, after } = entry;
+  return typeof name === "string" && typeof localName === "string" && (namespaceURI === null || typeof namespaceURI === "string") && typeof before === "string" && typeof after === "string";
+}
+
+// ../core/dist/compiler/svgIdNamespacing.js
+import postcss2 from "postcss";
+var ID_ATTR = "id";
+var SVG_AUTHORED_ID_ATTR = "data-hf-authored-id";
+var URL_HASH_REF_RE = /(url\(\s*)(["']?)#([^"')\s]+)\2(\s*\))/gi;
+function isHrefAttrName(name) {
+  return name === "href" || name.endsWith(":href");
+}
+function sanitizeNamespaceSegment(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function rewriteUrlHashRefs(value, idMap) {
+  if (!value || !value.toLowerCase().includes("url("))
+    return value;
+  return value.replace(URL_HASH_REF_RE, (full, pre, quote, id, post) => {
+    const mapped = idMap.get(id);
+    return mapped ? `${pre}${quote}#${mapped}${quote}${post}` : full;
+  });
+}
+function nativeReferenceValue(name, value, idMap) {
+  if (isHrefAttrName(name) && value.startsWith("#")) {
+    const mapped = idMap.get(value.slice(1));
+    return mapped ? `#${mapped}` : value;
+  }
+  URL_HASH_REF_RE.lastIndex = 0;
+  const hasUrl = URL_HASH_REF_RE.test(value);
+  URL_HASH_REF_RE.lastIndex = 0;
+  return hasUrl ? rewriteUrlHashRefs(value, idMap) : null;
+}
+function decideReferenceWrite(attr, previous, idMap) {
+  if (attr.name === SVG_REFERENCE_ALIASES_ATTR || attr.name === ID_ATTR)
+    return { kind: "skip" };
+  const before = previous && attr.value === previous.after ? previous.before : attr.value;
+  const after = nativeReferenceValue(attr.name, before, idMap);
+  if (after !== null)
+    return { kind: "managed", before, after };
+  return previous ? { kind: "retain", alias: previous } : { kind: "skip" };
+}
+function referenceAlias(attr, before, after, inSvg) {
+  const serializedXlink = attr.namespaceURI === void 0 && attr.name === "xlink:href" && inSvg;
+  return {
+    name: attr.name,
+    localName: serializedXlink ? "href" : attr.localName,
+    namespaceURI: serializedXlink ? "http://www.w3.org/1999/xlink" : attr.namespaceURI ?? null,
+    before,
+    after
+  };
+}
+function rewriteElementIdReferences(el, idMap) {
+  const prior = new Map(readSvgReferenceAliases(el, SVG_REFERENCE_ALIASES_ATTR, false).map((alias) => [
+    alias.name,
+    alias
+  ]));
+  const aliases = [...prior.values()].filter((alias) => alias.name === ID_ATTR);
+  const inSvg = !!el.closest("svg");
+  for (const attr of el.attributes ? Array.from(el.attributes) : []) {
+    const decision = decideReferenceWrite(attr, prior.get(attr.name), idMap);
+    if (decision.kind === "skip")
+      continue;
+    if (decision.kind === "retain") {
+      aliases.push(decision.alias);
+      continue;
+    }
+    if (decision.after !== attr.value) {
+      if (attr.namespaceURI)
+        el.setAttributeNS(attr.namespaceURI, attr.name, decision.after);
+      else
+        el.setAttribute(attr.name, decision.after);
+    }
+    aliases.push(referenceAlias(attr, decision.before, decision.after, inSvg));
+  }
+  if (aliases.length)
+    el.setAttribute(SVG_REFERENCE_ALIASES_ATTR, JSON.stringify(aliases));
+}
+function collectUrlHashRefsFromText(text, filter, out) {
+  let m;
+  URL_HASH_REF_RE.lastIndex = 0;
+  while (m = URL_HASH_REF_RE.exec(text)) {
+    const refId = m[3];
+    if (filter.has(refId))
+      out.add(refId);
+  }
+}
+function collectHrefFragmentRef(attr, filter, out) {
+  if (isHrefAttrName(attr.name) && attr.value.startsWith("#")) {
+    const id = attr.value.slice(1);
+    if (filter.has(id))
+      out.add(id);
+  }
+}
+function collectNativelyReferencedIds(elements, cssTexts, svgIds) {
+  const referenced = /* @__PURE__ */ new Set();
+  for (const el of elements) {
+    for (const attr of el.attributes ? Array.from(el.attributes) : []) {
+      if (!attr.value || attr.name === SVG_REFERENCE_ALIASES_ATTR)
+        continue;
+      collectHrefFragmentRef(attr, svgIds, referenced);
+      if (attr.value.toLowerCase().includes("url("))
+        collectUrlHashRefsFromText(attr.value, svgIds, referenced);
+    }
+  }
+  for (const text of cssTexts) {
+    if (text.toLowerCase().includes("url("))
+      collectUrlHashRefsFromText(text, svgIds, referenced);
+  }
+  return referenced;
+}
+function isExcluded(el, exclude) {
+  return exclude.some((excluded) => excluded === el || excluded.contains(el));
+}
+function collectScopeElements(scope) {
+  const exclude = scope.exclude ?? [];
+  const descendants = [...scope.root.querySelectorAll("*")];
+  const own = exclude.length ? descendants.filter((el) => !isExcluded(el, exclude)) : descendants;
+  return [scope.root, ...own];
+}
+function collectSvgIdElements(scope) {
+  const exclude = scope.exclude ?? [];
+  const matches = [...scope.root.querySelectorAll("svg [id], svg[id]")];
+  return exclude.length ? matches.filter((el) => !isExcluded(el, exclude)) : matches;
+}
+function resolveScope(scope) {
+  const elements = collectScopeElements(scope);
+  const renamable = /* @__PURE__ */ new Set();
+  if (!scope.namespace)
+    return { elements, renamable };
+  const svgIdElements = collectSvgIdElements(scope);
+  const svgIds = /* @__PURE__ */ new Set();
+  for (const el of svgIdElements) {
+    const id = el.getAttribute(ID_ATTR);
+    if (id)
+      svgIds.add(id);
+  }
+  if (svgIds.size === 0)
+    return { elements, renamable };
+  const nativelyReferenced = collectNativelyReferencedIds(elements, scope.cssTexts ?? [], svgIds);
+  for (const el of svgIdElements) {
+    const id = el.getAttribute(ID_ATTR);
+    if (id && nativelyReferenced.has(id))
+      renamable.add(el);
+  }
+  return { elements, renamable };
+}
+function currentAuthoredSvgId(el) {
+  if (!el.closest("svg"))
+    return null;
+  const idWrite = readSvgReferenceAliases(el, SVG_REFERENCE_ALIASES_ATTR, false).find((alias) => alias.name === ID_ATTR);
+  if (idWrite)
+    return el.getAttribute(ID_ATTR) === idWrite.after ? idWrite.before : null;
+  return el.getAttribute(SVG_AUTHORED_ID_ATTR);
+}
+function buildIdCensus(document) {
+  const elementsById = /* @__PURE__ */ new Map();
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const el of document.querySelectorAll("[id]")) {
+    const id = el.getAttribute(ID_ATTR);
+    if (!id)
+      continue;
+    usedIds.add(id);
+    const list = elementsById.get(id);
+    if (list)
+      list.push(el);
+    else
+      elementsById.set(id, [el]);
+    const authored = currentAuthoredSvgId(el);
+    if (authored && authored !== id) {
+      const aliases = elementsById.get(authored);
+      if (aliases)
+        aliases.push(el);
+      else
+        elementsById.set(authored, [el]);
+    }
+  }
+  return { elementsById, usedIds };
+}
+function mintNamespacedId(namespace, originalId, usedIds) {
+  const base = `${sanitizeNamespaceSegment(namespace)}--${originalId}`;
+  let candidate = base;
+  for (let n = 2; usedIds.has(candidate); n += 1)
+    candidate = `${base}-${n}`;
+  usedIds.add(candidate);
+  return candidate;
+}
+function collisionScopes(id, elements, scopeIndexByRenamable) {
+  const keeper = elements.find((el) => !scopeIndexByRenamable.has(el)) ?? elements[0];
+  const candidates = elements.filter((el) => el !== keeper && el.getAttribute(ID_ATTR) === id);
+  const indices = candidates.map((el) => scopeIndexByRenamable.get(el));
+  return new Set(indices.filter((index) => index !== void 0));
+}
+function planRenames(census, scopes, scopeIndexByRenamable) {
+  const idMaps = scopes.map(() => /* @__PURE__ */ new Map());
+  for (const [id, elements] of census.elementsById) {
+    if (elements.length < 2)
+      continue;
+    for (const index of collisionScopes(id, elements, scopeIndexByRenamable)) {
+      idMaps[index].set(id, mintNamespacedId(scopes[index].namespace, id, census.usedIds));
+    }
+  }
+  return idMaps;
+}
+function documentReferenceTargets(census, idMaps, scopeIndexByRenamable) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const [id, elements] of census.elementsById) {
+    const target = elements[0];
+    const actual = target.getAttribute(ID_ATTR);
+    if (actual !== id) {
+      targets.set(id, actual);
+      continue;
+    }
+    const index = scopeIndexByRenamable.get(target);
+    const renamed = index === void 0 ? void 0 : idMaps[index].get(id);
+    if (renamed)
+      targets.set(id, renamed);
+  }
+  return targets;
+}
+function localReferenceBindings(elements) {
+  const ids = new Set(elements.map((el) => el.getAttribute(ID_ATTR)));
+  const renamed = /* @__PURE__ */ new Map();
+  for (const el of elements) {
+    const authored = currentAuthoredSvgId(el);
+    const current = el.getAttribute(ID_ATTR);
+    if (!authored || !current)
+      continue;
+    ids.add(authored);
+    renamed.set(authored, current);
+  }
+  return { ids, renamed };
+}
+function applyRenames(resolved, idMap) {
+  for (const el of resolved.elements) {
+    const currentId = el.getAttribute(ID_ATTR);
+    if (currentId && resolved.renamable.has(el) && idMap.has(currentId)) {
+      if (!el.hasAttribute(SVG_AUTHORED_ID_ATTR))
+        el.setAttribute(SVG_AUTHORED_ID_ATTR, currentId);
+      const after = idMap.get(currentId);
+      const aliases = readSvgReferenceAliases(el, SVG_REFERENCE_ALIASES_ATTR, false);
+      aliases.push({
+        name: ID_ATTR,
+        localName: ID_ATTR,
+        namespaceURI: null,
+        before: currentId,
+        after
+      });
+      el.setAttribute(SVG_REFERENCE_ALIASES_ATTR, JSON.stringify(aliases));
+      el.setAttribute(ID_ATTR, after);
+    }
+    rewriteElementIdReferences(el, idMap);
+  }
+}
+function namespaceCollidingSvgIds(document, scopes, finalizedIds) {
+  if (scopes.length === 0)
+    return [];
+  const census = buildIdCensus(document);
+  const resolved = scopes.map(resolveScope);
+  const newlyEligible = resolved.flatMap(({ renamable }) => [...renamable]);
+  if (finalizedIds) {
+    for (const scope of resolved) {
+      for (const el of scope.renamable)
+        if (finalizedIds.has(el))
+          scope.renamable.delete(el);
+    }
+  }
+  const scopeIndexByRenamable = /* @__PURE__ */ new Map();
+  resolved.forEach(({ renamable }, index) => {
+    for (const el of renamable)
+      scopeIndexByRenamable.set(el, index);
+  });
+  const idMaps = planRenames(census, scopes, scopeIndexByRenamable);
+  const documentTargets = documentReferenceTargets(census, idMaps, scopeIndexByRenamable);
+  const referenceMaps = resolved.map((scope, index) => {
+    const local = localReferenceBindings(scopes[index].referenceTarget === "document" ? [] : scope.elements);
+    const inherited = [...documentTargets].filter(([id]) => !local.ids.has(id));
+    return new Map([...inherited, ...local.renamed, ...idMaps[index]]);
+  });
+  referenceMaps.forEach((idMap, index) => {
+    applyRenames(resolved[index], idMap);
+  });
+  for (const el of newlyEligible)
+    finalizedIds?.add(el);
+  return referenceMaps;
+}
+function rewriteSvgIdReferencesInCss(css, idMap, references = []) {
+  if (!css || idMap.size === 0 && references.length === 0)
+    return css;
+  if (!css.includes("#") && !css.includes("[") && !css.toLowerCase().includes("url("))
+    return css;
+  let root;
+  try {
+    root = postcss2.parse(css);
+  } catch {
+    return css;
+  }
+  let mutated = false;
+  const recordedIds = new Set(references.filter((alias) => alias.name === ID_ATTR).map((alias) => alias.before));
+  const ids = [...idMap].filter(([id]) => !recordedIds.has(id)).map(([id, renamed]) => ({
+    id,
+    replacement: `:is(#${escapeCssIdentifier(id)}, #${escapeCssIdentifier(renamed)})`
+  }));
+  root.walkRules((rule) => {
+    const rewritten = rule.selectors.map((selector) => rewriteSvgSelectors(selector, ids, references));
+    if (rewritten.some((selector, index) => selector !== rule.selectors[index])) {
+      rule.selectors = rewritten;
+      mutated = true;
+    }
+  });
+  root.walkDecls((decl) => {
+    const rewritten = rewriteUrlHashRefs(decl.value, idMap);
+    if (rewritten !== decl.value) {
+      decl.value = rewritten;
+      mutated = true;
+    }
+  });
+  root.walkAtRules((atRule) => {
+    if (!atRule.params)
+      return;
+    const rewritten = rewriteUrlHashRefs(atRule.params, idMap);
+    if (rewritten !== atRule.params) {
+      atRule.params = rewritten;
+      mutated = true;
+    }
+  });
+  return mutated ? root.toResult({ map: false }).css : css;
+}
+
+// ../core/dist/compiler/inlineSubCompositions.js
+var SIDE_EFFECT_RE = /\b(addEventListener|requestAnimationFrame|requestIdleCallback|setTimeout|setInterval|queueMicrotask|getContext|WebGL\w*|WebGPU\w*|gpu|Worker|WebSocket|EventSource|Audio\w*|\w*Observer|fetch|import|eval|Function|Promise|async|await|delayedCall|ScrollTrigger|Draggable|anime|customElements|registerProperty|addListener|BroadcastChannel|pushState|replaceState|adoptedStyleSheets|documentElement|getElementsByTagName|lottie|THREE|__hf[A-Z]\w*)\b|\.then\s*\(|\.animate\s*\(|\.ticker\b|repeat\s*:\s*-1|\.repeat\s*\(\s*-1|defineProperty\s*\(\s*(window|globalThis|self|document)\b|\bfonts\s*\.\s*add\b|\.on[a-z]+\s*=(?!=)|\bon(resize|scroll|message|key\w+|click|pointer\w+|mouse\w+|wheel|visibilitychange|hashchange|popstate|error|load)\s*=(?!=)|\[\s*["']on[a-z]+["']\s*\]|document\s*\.\s*(head|body)\b|querySelector(All)?\(\s*["'](head|body)["']|\bgsap\s*\.\s*(?:to|from|fromTo)\s*\(|\bgsap\s*\.\s*timeline\s*\((?:[^()]|\([^()]*\))*\)\s*\.\s*(?:to|from|fromTo|set|add|call)\s*\(/;
+var SWAP_SAFE_LIBRARY_URL = /^https:\/\/(cdn\.jsdelivr\.net\/npm|unpkg\.com)\/(gsap|three|d3|d3-[a-z-]+|topojson-client|clipper-lib)(@[^/]+)?\//;
+var isSwapSafeLibrary = (src) => URL.canParse(src) && SWAP_SAFE_LIBRARY_URL.test(new URL(src).href);
+function sceneScriptSwapRefusal(script) {
+  const match = SIDE_EFFECT_RE.exec(script);
+  return match ? `its script uses ${match[0].trim()}` : null;
+}
+var STRING_LITERAL_RE = /(["'`])((?:\\.|(?!\1)[^\\\n])*?)\1/g;
+var CREATES_ELEMENT_RE = /createElement\s*\(\s*$|createElementNS\s*\([^()]*,\s*$/;
+var isNotASelector = (script, at, literal) => CREATES_ELEMENT_RE.test(script.slice(Math.max(0, at - 60), at)) || literal.trim() === "*" && /,\s*$/.test(script.slice(Math.max(0, at - 20), at));
+function refuseSwapsReachedByRootScripts(document, rootScripts) {
+  const hosts = [...document.querySelectorAll(`[${SCENE_PART_ATTR}]`)];
+  const byName = /* @__PURE__ */ new Map();
+  for (const host of hosts) {
+    for (const el of [host, ...host.querySelectorAll("*")]) {
+      for (const name of [
+        el.localName,
+        el.id && `#${el.id}`,
+        ...[...el.classList].map((c) => `.${c}`)
+      ]) {
+        if (name)
+          byName.set(name, (byName.get(name) ?? /* @__PURE__ */ new Set()).add(host));
+      }
+    }
+  }
+  const namesKnown = (selector) => selector.split(",").some((alt) => alt.split(/[\s>+~]+/).every((part) => !/^[a-z][\w-]*$/i.test(part) || byName.has(part.toLowerCase()) || document.querySelector(part) !== null));
+  const literals = new Set(rootScripts.flatMap((s) => [...s.matchAll(STRING_LITERAL_RE)].filter((m) => !isNotASelector(s, m.index, m[2] ?? "")).map((m) => m[2] ?? "")));
+  for (const literal of literals) {
+    const open = hosts.filter((host) => !host.hasAttribute(SCENE_NO_SWAP_ATTR));
+    if (open.length === 0)
+      return;
+    const reached = literal.trim() === "*" ? open : /^[A-Za-z_][\w-]*$/.test(literal) ? [literal.toLowerCase(), `#${literal}`, `.${literal}`].flatMap((name) => [
+      ...byName.get(name) ?? []
+    ]) : /[#.[:>]|[\w\]*] *[\s,]+ *[\w*]/.test(literal) && literal.length <= 120 && namesKnown(literal) ? open.filter((host) => reaches(host, literal)) : [];
+    for (const host of reached)
+      if (!host.hasAttribute(SCENE_NO_SWAP_ATTR))
+        host.setAttribute(SCENE_NO_SWAP_ATTR, `a script outside the scene selects ${literal}`);
+  }
+}
+var reaches = (host, selector) => {
+  try {
+    return host.matches(selector) || host.querySelector(selector) !== null;
+  } catch {
+    return false;
+  }
+};
+function ensureExternalLinkTag(doc, link) {
+  const el = doc.createElement("link");
+  el.setAttribute("rel", link.rel);
+  el.setAttribute("href", link.href);
+  for (const name of ["crossorigin", "media", "title", "type"]) {
+    const value = link[name];
+    if (value != null)
+      el.setAttribute(name, value);
+  }
+  if (link.disabled)
+    el.setAttribute("disabled", "");
+  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}"]`;
+}
+function inlineSubCompositions(document, hosts, options) {
+  const { resolveHtml, parseHtml, hostIdentityMap, rewriteInlineStyles = false, flattenInnerRoot, compoundAuthoredRoot, readVariableDefaults, parseHostVariables, buildScopeSelector = defaultBuildScopeSelector, scriptErrorLabel = "[Framey] composition script error:", onMissingComposition, assetExists, tagScenes = false } = options;
+  const rootStyles = [...document.querySelectorAll("style")];
+  const styles = [];
+  const styleScenes = [];
+  const scripts = [];
+  const externalScriptSrcs = [];
+  const scriptItems = [];
+  const importMaps = [];
+  const moduleScripts = [];
+  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,
+    ancestry: [],
+    scene: void 0
+  }));
+  for (let queueIndex = 0; queueIndex < queue.length; queueIndex += 1) {
+    const { element: hostEl, ancestry, scene: parentScene } = queue[queueIndex];
+    const src = hostEl.getAttribute("data-composition-src");
+    if (!src)
+      continue;
+    const compHtml = resolveHtml(src);
+    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;
+    }
+    if (compHtml == null) {
+      onMissingComposition?.(src);
+      continue;
+    }
+    const compDoc = parseCopy(compHtml);
+    let compId;
+    let runtimeCompId;
+    if (hostIdentityMap) {
+      const identity = hostIdentityMap.get(hostEl);
+      compId = identity?.authoredCompositionId || null;
+      runtimeCompId = identity?.runtimeCompositionId || compId || "";
+    } else {
+      compId = hostEl.getAttribute("data-composition-id") || null;
+      runtimeCompId = compId || "";
+    }
+    const { contentHtml, hasTemplate } = resolveSubCompositionContent(compHtml, compDoc);
+    if (!contentHtml.trim()) {
+      onMissingComposition?.(src);
+      continue;
+    }
+    const contentDoc = parseCopy(contentHtml);
+    if (!contentDoc.documentElement) {
+      onMissingComposition?.(src);
+      continue;
+    }
+    const plan = planCompositionAssembly({
+      contentNode: contentDoc,
+      head: compDoc.head,
+      documentElement: compDoc.documentElement,
+      hasTemplate,
+      compositionId: compId
+    });
+    const innerRoot = plan.innerRoot;
+    const authoredRootId = plan.authoredRootId;
+    const scopeCompId = plan.authoredCompositionId || "";
+    const scriptCompositionId = plan.scriptCompositionId || "";
+    const runtimeScope = runtimeCompId ? buildScopeSelector(runtimeCompId) : "";
+    const scene = tagScenes ? parentScene ?? (runtimeCompId || src) : void 0;
+    if (scene && !parentScene) {
+      hostEl.setAttribute(SCENE_PART_ATTR, scene);
+      sceneHosts.set(scene, hostEl);
+    }
+    const refuseSwap = (why) => {
+      const host = scene ? sceneHosts.get(scene) : void 0;
+      if (!host || host.hasAttribute(SCENE_NO_SWAP_ATTR))
+        return;
+      const reason = why();
+      if (reason)
+        host.setAttribute(SCENE_NO_SWAP_ATTR, reason);
+    };
+    if (readVariableDefaults && parseHostVariables && runtimeCompId) {
+      const mergedVariables = {};
+      for (const carrier of plan.variableDefaultCarriers) {
+        Object.assign(mergedVariables, readVariableDefaults(carrier));
+      }
+      Object.assign(mergedVariables, parseHostVariables(hostEl));
+      if (Object.keys(mergedVariables).length > 0) {
+        variablesByComp[runtimeCompId] = mergedVariables;
+      }
+      warnUnknownEnumValues(compDoc.documentElement, mergedVariables, runtimeCompId);
+      warnUnknownEnumValues(innerRoot, mergedVariables, runtimeCompId);
+    }
+    const resolveSubAssetPath = (raw) => rewriteAssetPath(src, (raw || "").trim(), assetExists);
+    const scopeSubStyle = (raw) => {
+      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;
+    };
+    for (const link of plan.linkSources) {
+      const href = resolveSubAssetPath(link.getAttribute("href"));
+      if (href) {
+        const rel = (link.getAttribute("rel") || "").trim();
+        const crossorigin = link.hasAttribute("crossorigin") ? link.getAttribute("crossorigin") || "" : void 0;
+        const media = link.getAttribute("media") ?? void 0;
+        const title = link.getAttribute("title") ?? void 0;
+        const type = link.getAttribute("type") ?? void 0;
+        const disabled = link.hasAttribute("disabled") ? true : void 0;
+        externalLinks.push({ href, rel, crossorigin, media, title, type, disabled });
+      }
+    }
+    const styleStart = styles.length;
+    for (const styleEl of plan.styleSources) {
+      if (cssStyleMergeKey(styleEl) === void 0)
+        continue;
+      styles.push(compositionStyle(styleEl, scopeSubStyle(styleEl.textContent || "")));
+      if (scene)
+        styleScenes.push(scene);
+      styleEl.remove();
+    }
+    const styleEnd = styles.length;
+    for (const scriptEl of plan.scriptSources) {
+      const externalSrc = resolveSubAssetPath(scriptEl.getAttribute("src"));
+      const type = (scriptEl.getAttribute("type") || "").trim().toLowerCase();
+      refuseSwap(() => type === "importmap" || type === "module" ? "it runs a module script or import map" : !externalSrc ? sceneScriptSwapRefusal(scriptEl.textContent || "") : isSwapSafeLibrary(externalSrc) ? null : "it runs a script that is not a known library");
+      if (type === "importmap") {
+        const map = parseImportMap(scriptEl.textContent || "", (url) => {
+          const authored = url.trim();
+          const rebased = resolveSubAssetPath(authored);
+          if (rebased === authored)
+            return rebased;
+          const urlLike = /^(\/|\.\.?\/|[a-z][a-z\d+.-]*:)/i.test(rebased) ? rebased : `./${rebased}`;
+          return authored.endsWith("/") && !urlLike.endsWith("/") ? `${urlLike}/` : urlLike;
+        });
+        if (map)
+          importMaps.push(map);
+        else
+          console.warn(`[Framey] ${src}: import map is not valid JSON, so it is skipped.`);
+      } else if (type === "module" && !externalSrc) {
+        const prelude = scriptCompositionId ? scopedModulePrelude(runtimeCompId || scopeCompId || scriptCompositionId, src) : "";
+        moduleScripts.push(prelude + (scriptEl.textContent || ""));
+      } else if (externalSrc) {
+        if (!externalScriptSrcs.includes(externalSrc)) {
+          externalScriptSrcs.push(externalSrc);
+        }
+        scriptItems.push({
+          kind: "external",
+          src: externalSrc,
+          ...readExternalScriptAttributes(scriptEl),
+          ...scene ? { scene } : {}
+        });
+      } else {
+        const wrappedScript = scriptCompositionId ? wrapScopedCompositionScript(scriptEl.textContent || "", scriptCompositionId, scriptErrorLabel, runtimeScope || void 0, runtimeCompId || scopeCompId || scriptCompositionId, authoredRootId, src) : wrapInlineScriptWithErrorBoundary(scriptEl.textContent || "", scriptErrorLabel);
+        scripts.push(wrappedScript);
+        scriptItems.push({ kind: "inline", content: wrappedScript, ...scene ? { scene } : {} });
+      }
+      scriptEl.remove();
+    }
+    const assetEls = innerRoot ? innerRoot.querySelectorAll("[src], [href]") : contentDoc.querySelectorAll("[src], [href]");
+    rewriteAssetPaths(assetEls, src, (el, attr) => el.getAttribute(attr), (el, attr, val) => {
+      el.setAttribute(attr, val);
+    }, assetExists);
+    if (rewriteInlineStyles) {
+      const styledEls = innerRoot ? innerRoot.querySelectorAll("[style]") : contentDoc.querySelectorAll("[style]");
+      rewriteInlineStyleAssetUrls(styledEls, src, (el) => el.getAttribute("style"), (el, val) => {
+        el.setAttribute("style", val);
+      }, assetExists);
+    }
+    if (innerRoot?.hasAttribute("data-timeline-locked")) {
+      hostEl.setAttribute("data-timeline-locked", "");
+    }
+    if (innerRoot) {
+      const innerW = innerRoot.getAttribute("data-width");
+      const innerH = innerRoot.getAttribute("data-height");
+      if (innerW && !hostEl.getAttribute("data-width"))
+        hostEl.setAttribute("data-width", innerW);
+      if (innerH && !hostEl.getAttribute("data-height")) {
+        hostEl.setAttribute("data-height", innerH);
+      }
+    }
+    if (innerRoot) {
+      innerRoot.setAttribute("data-composition-file", src);
+      for (const child of extractedCompositionAssets(innerRoot))
+        child.remove();
+      if (flattenInnerRoot) {
+        const prepared = flattenInnerRoot(innerRoot);
+        if (!compId && scopeCompId) {
+          prepared.setAttribute("data-composition-id", scopeCompId);
+        }
+        hostEl.innerHTML = prepared.outerHTML || "";
+      } else {
+        hostEl.innerHTML = compId ? innerRoot.innerHTML || "" : innerRoot.outerHTML || "";
+        if (compId && authoredRootId) {
+          hostEl.setAttribute("data-hf-authored-id", authoredRootId);
+        }
+      }
+    } else {
+      for (const child of extractedCompositionAssets(contentDoc))
+        child.remove();
+      const bodyHtml = contentDoc.body?.innerHTML || "";
+      hostEl.innerHTML = bodyHtml || contentDoc.documentElement?.outerHTML || "";
+    }
+    for (const el of plan.inertScriptsOutsideRoot)
+      hostEl.insertAdjacentHTML("beforeend", el.outerHTML);
+    hostEl.setAttribute("data-composition-file", src);
+    hostEl.removeAttribute("data-composition-src");
+    const nestedAncestry = [...ancestry, src];
+    const nested = enumerateNestedCompositionHosts(hostEl, nestedAncestry);
+    for (const skipped of nested.skipped) {
+      onMissingComposition?.(skipped.src, skipped.reason);
+    }
+    for (const nestedHost of nested.hosts) {
+      queue.push({ element: nestedHost.host, ancestry: nestedAncestry, scene });
+    }
+    svgIdScopes.push({
+      root: hostEl,
+      namespace: runtimeCompId || scopeCompId,
+      exclude: nested.hosts.map((nestedHost) => nestedHost.host),
+      styleStart,
+      styleEnd
+    });
+  }
+  const svgIdMaps = namespaceCollidingSvgIds(document, [
+    ...svgIdScopes.map(({ root, namespace, exclude, styleStart, styleEnd }) => ({
+      root,
+      namespace,
+      exclude,
+      cssTexts: styles.slice(styleStart, styleEnd).map((style) => style.css)
+    })),
+    {
+      root: document.documentElement,
+      namespace: "",
+      referenceTarget: "document",
+      exclude: svgIdScopes.map(({ root }) => root),
+      cssTexts: rootStyles.map((style) => style.textContent ?? "")
+    }
+  ]);
+  svgIdMaps.slice(0, svgIdScopes.length).forEach((idMap, index) => {
+    const { styleStart, styleEnd } = svgIdScopes[index];
+    const references = readSvgReferenceAliases(svgIdScopes[index].root, SVG_REFERENCE_ALIASES_ATTR);
+    for (let i = styleStart; i < styleEnd; i += 1) {
+      styles[i].css = rewriteSvgIdReferencesInCss(styles[i].css, idMap, references);
+    }
+  });
+  const rootReferences = readSvgReferenceAliases(document.documentElement, SVG_REFERENCE_ALIASES_ATTR);
+  for (const style of rootStyles) {
+    style.textContent = rewriteSvgIdReferencesInCss(style.textContent ?? "", svgIdMaps[svgIdScopes.length], rootReferences);
+  }
+  return {
+    styles,
+    styleScenes,
+    scripts,
+    externalScriptSrcs,
+    scriptItems,
+    externalLinks,
+    variablesByComp,
+    importMaps,
+    moduleScripts
+  };
+}
+
+// ../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(hash2) {
+  const s = (hash2 >>> 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 { document, wrapped } = parseFragmentOrDocument(html);
+  if (!document.body) return html;
+  assignHfIds(document.body);
+  return wrapped ? document.body.innerHTML || "" : document.toString();
+}
+function parseFragmentOrDocument(html) {
+  const wrapped = !/^(?:<!doctype|<html[\s>/])/i.test(
+    html.replace(/^(?:\s|<!--(?:>|->|[\s\S]*?-->))*/, "")
+  );
+  const { document } = wrapped ? parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`) : parseHTML(html);
+  return { document, wrapped };
+}
+function stampHfIdsInPlace(html) {
+  const { document, wrapped } = parseFragmentOrDocument(html);
+  if (!document.body) return html;
+  const elements = wrapped ? getChildElements(document.body).flatMap(inDocumentOrder) : inDocumentOrder(document.documentElement);
+  const existing = elements.map((el) => el.getAttribute("data-hf-id"));
+  const pinned = existing.map((id) => id !== null && id.length > 0);
+  assignHfIds(document.body);
+  const minted = elements.map((el, n) => pinned[n] ? null : el.getAttribute("data-hf-id"));
+  const tags = startTags(html);
+  const inserts = tags && alignInserts(html, tags, elements, minted, existing);
+  return inserts ? spliceIds(html, inserts) : ensureHfIds(html);
+}
+function inDocumentOrder(el) {
+  return [el, ...getChildElements(el).flatMap(inDocumentOrder)];
+}
+var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "textarea", "title", "xmp", "noembed", "noframes"]);
+var IMPLIED = /* @__PURE__ */ new Set(["html", "head", "body", "tbody"]);
+function startTags(html) {
+  const tags = [];
+  let i = html.indexOf("<");
+  while (i >= 0) {
+    const name = html.startsWith("<!--", i) ? null : /^<([a-zA-Z][^\s/>]*)/.exec(html.slice(i, i + 128));
+    if (!name) {
+      i = nextTagAfter(html, i);
+      continue;
+    }
+    const end = closingBracket(html, i + name[0].length);
+    if (end < 0) return null;
+    const tag = name[1].toLowerCase();
+    tags.push({ name: tag, nameEnd: i + name[0].length, bracket: end });
+    const after = RAW_TEXT.has(tag) ? rawTextEnd(html, tag, end) : end;
+    i = after < 0 ? -1 : html.indexOf("<", after + 1);
+  }
+  return tags;
+}
+function rawTextEnd(html, tag, from) {
+  const endTag = new RegExp(`</${tag}(?=[\\s/>]|$)`, "gi");
+  endTag.lastIndex = from;
+  return endTag.exec(html)?.index ?? -1;
+}
+function nextTagAfter(html, lt) {
+  const comment = html.startsWith("<!--", lt);
+  const end = comment ? html.indexOf("-->", lt + 4) : html.indexOf(">", lt);
+  return end < 0 ? -1 : html.indexOf("<", end + 1);
+}
+function closingBracket(html, from) {
+  let quote = "";
+  for (let i = from; i < html.length; i++) {
+    const c = html[i];
+    if (quote) quote = c === quote ? "" : quote;
+    else if (c === '"' || c === "'") quote = c;
+    else if (c === ">") return i;
+  }
+  return -1;
+}
+function alignInserts(html, tags, elements, minted, existing) {
+  const walked = walkAlign(html, tags, elements, minted, existing);
+  if (!walked) return null;
+  return walked.next === tags.length ? walked.inserts : null;
+}
+function walkAlign(html, tags, elements, minted, existing) {
+  const state = { inserts: [], next: 0 };
+  for (const [n, el] of elements.entries()) {
+    if (!take(state, html, tags, el, minted[n] ?? null, existing[n] === "")) return null;
+  }
+  return state;
+}
+function take(state, html, tags, el, id, fillEmpty) {
+  const step = alignOne(html, tags[state.next], el, id, fillEmpty);
+  if (!step) return false;
+  if (step.insert) state.inserts.push(step.insert);
+  if (step.next) state.next += 1;
+  return true;
+}
+function alignOne(html, tag, el, id, fillEmpty) {
+  if (tag?.name === el.tagName.toLowerCase()) return matched(html, tag, id, fillEmpty);
+  if (IMPLIED.has(el.tagName.toLowerCase()) && !id) return { insert: null, next: false };
+  return null;
+}
+function matched(html, tag, id, fillEmpty) {
+  if (!id) return { insert: null, next: true };
+  const placed = placeId(html, tag, id, fillEmpty);
+  if (!placed) return null;
+  return { insert: placed, next: true };
+}
+function placeId(html, tag, id, fillEmpty) {
+  if (!fillEmpty) return { at: tag.nameEnd, text: ` data-hf-id="${id}"` };
+  const emptyAt = emptyHfIdValue(html, tag);
+  if (emptyAt === null) return null;
+  return { at: emptyAt, text: id };
+}
+function emptyHfIdValue(html, tag) {
+  const open = outsideQuotes(html.slice(tag.nameEnd, tag.bracket));
+  const match = /\sdata-hf-id\s*=\s*(["'])\1/i.exec(open);
+  if (!match) return null;
+  return tag.nameEnd + match.index + match[0].length - 1;
+}
+function outsideQuotes(open) {
+  let quote = "";
+  let out = "";
+  for (const c of open) {
+    out += quotedChar(quote, c);
+    quote = quoteOf(quote, c);
+  }
+  return out;
+}
+function quoteOf(quote, c) {
+  if (quote) return c === quote ? "" : quote;
+  return c === '"' || c === "'" ? c : "";
+}
+function quotedChar(quote, c) {
+  if (!quote || c === quote) return c;
+  return " ".repeat(c.length);
+}
+function spliceIds(html, inserts) {
+  let out = "";
+  let from = 0;
+  for (const { at, text } of inserts) {
+    out += html.slice(from, at) + text;
+    from = at;
+  }
+  return out + html.slice(from);
+}
+
+// ../core/dist/compiler/htmlBundler.js
+var DEFAULT_RUNTIME_SCRIPT_URL = "";
+function getRuntimeScriptUrl() {
+  const configured = (process.env.HYPERFRAME_RUNTIME_URL || "").trim();
+  return configured || DEFAULT_RUNTIME_SCRIPT_URL;
+}
+function injectInterceptor(html, runtimeMode = "inline") {
+  const sanitized = stripEmbeddedRuntimeScripts(html);
+  const runtimeScriptUrl = getRuntimeScriptUrl();
+  let tag;
+  if (runtimeScriptUrl) {
+    const escaped = runtimeScriptUrl.replace(/"/g, "&quot;");
+    tag = `<script ${RUNTIME_BOOTSTRAP_ATTR}="1" src="${escaped}"></script>`;
+  } else if (runtimeMode === "placeholder") {
+    tag = `<script ${RUNTIME_BOOTSTRAP_ATTR}="1" src=""></script>`;
+  } else {
+    const inlinedRuntime = getHyperframeRuntimeScript();
+    tag = `<script ${RUNTIME_BOOTSTRAP_ATTR}="1">${inlinedRuntime}</script>`;
+  }
+  return insertRuntimeTag(sanitized, tag);
+}
+function isRelativeUrl(url) {
+  return !isNonRelativeUrl(url) && !isAbsolute(url);
+}
+var bundleReads = new AsyncLocalStorage();
+function noteRead(filePath) {
+  bundleReads.getStore()?.(filePath);
+}
+function safeReadFile(filePath) {
+  noteRead(filePath);
+  if (!existsSync(filePath))
+    return null;
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var CSS_IMPORT_RE = /@import\s+(?:url\(\s*(["']?)([^)"']+)\1\s*\)|(["'])([^"']+)\3)\s*([^;]*);\s*/g;
+var CSS_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+function withCommentsStripped(css, fn) {
+  const comments = [];
+  const stripped = css.replace(CSS_COMMENT_RE, (m) => {
+    const idx = comments.length;
+    comments.push(m);
+    return `/*__hf_c${idx}__*/`;
+  });
+  const result = fn(stripped);
+  const restore = (s) => {
+    let out = s;
+    for (let i = 0; i < comments.length; i++) {
+      out = out.replace(`/*__hf_c${i}__*/`, comments[i]);
+    }
+    return out;
+  };
+  return { result, restore };
+}
+function resolveRelativeUrlPath(fromDir, basePath) {
+  return resolve2(fromDir, decodeWellFormedEscapes(basePath.replaceAll("\\", "/")));
+}
+function rebaseCssUrls(css, cssFileDir, projectDir) {
+  const resolvedRoot = resolve2(projectDir);
+  const resolvedDir = resolve2(cssFileDir);
+  if (resolvedDir === resolvedRoot)
+    return css;
+  return css.replace(CSS_URL_RE, (full, quote, urlValue) => {
+    const decoded = decodeCssEscapes(urlValue);
+    if (!decoded || !isRelativeUrl(decoded))
+      return full;
+    const { basePath, suffix } = splitUrlSuffix(decoded);
+    if (!basePath)
+      return full;
+    const absolutePath = resolveRelativeUrlPath(resolvedDir, basePath);
+    const rebased = encodeUrlPath(relative(resolvedRoot, absolutePath).split(sep).join("/"));
+    if (rebased === basePath)
+      return full;
+    const escapedSuffix = suffix.replace(/[\s\p{Cc}"'()\\<>]/gu, (char) => `\\${char.codePointAt(0).toString(16).padStart(6, "0")}`);
+    return `url(${quote || ""}${rebased}${escapedSuffix}${quote || ""})`;
+  });
+}
+function rebaseRelativePath(urlValue, fromDir, toDir) {
+  const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
+  if (!basePath)
+    return urlValue;
+  const absolutePath = resolveRelativeUrlPath(fromDir, basePath);
+  const rebased = encodeUrlPath(relative(resolve2(toDir), absolutePath).split(sep).join("/"));
+  return appendSuffixToUrl(rebased, suffix);
+}
+function rewriteSrcsetUrls(srcset, rewriteUrl) {
+  const parts = [];
+  let position = 0;
+  let written = 0;
+  while (position < srcset.length) {
+    while (position < srcset.length && /[ \t\n\r\f,]/.test(srcset.charAt(position)))
+      position++;
+    const start = position;
+    while (position < srcset.length && !/[ \t\n\r\f]/.test(srcset.charAt(position)))
+      position++;
+    let end = position;
+    while (end > start && srcset.charAt(end - 1) === ",")
+      end--;
+    if (end > start) {
+      const url = srcset.slice(start, end);
+      const rewritten = rewriteUrl(url);
+      if (rewritten !== url) {
+        parts.push(srcset.slice(written, start), rewritten);
+        written = end;
+      }
+    }
+    if (end < position)
+      continue;
+    let inParens = false;
+    while (position < srcset.length) {
+      const char = srcset.charAt(position++);
+      if (char === "(")
+        inParens = true;
+      else if (char === ")")
+        inParens = false;
+      else if (char === "," && !inParens)
+        break;
+    }
+  }
+  return parts.length > 0 ? parts.join("") + srcset.slice(written) : srcset;
+}
+function rebaseColorGradingLutPath(value, fromDir, toDir) {
+  if (!value.trim().startsWith("{"))
+    return value;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return value;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return value;
+  const lut = Reflect.get(parsed, "lut");
+  if (typeof lut === "string") {
+    if (!isRelativeUrl(lut))
+      return value;
+    Reflect.set(parsed, "lut", rebaseRelativePath(lut, fromDir, toDir));
+    return JSON.stringify(parsed);
+  }
+  if (typeof lut !== "object" || lut === null || Array.isArray(lut))
+    return value;
+  const lutSrc = Reflect.get(lut, "src");
+  if (typeof lutSrc !== "string" || !isRelativeUrl(lutSrc))
+    return value;
+  Reflect.set(lut, "src", rebaseRelativePath(lutSrc, fromDir, toDir));
+  return JSON.stringify(parsed);
+}
+function rebaseEntryAuthoredAssetPaths(document, sourceDir, projectDir) {
+  for (const styleEl of [...document.querySelectorAll("style")]) {
+    styleEl.textContent = rebaseCssUrls(styleEl.textContent || "", sourceDir, projectDir);
+  }
+  for (const el of [...document.querySelectorAll("[style]")]) {
+    const styleAttr = el.getAttribute("style");
+    if (styleAttr)
+      el.setAttribute("style", rebaseCssUrls(styleAttr, sourceDir, projectDir));
+  }
+  for (const el of [...document.querySelectorAll("[src], [href], [poster], [xlink\\:href]")]) {
+    if (el.tagName === "LINK" && (el.getAttribute("rel") || "").toLowerCase() === "stylesheet")
+      continue;
+    if (el.tagName === "SCRIPT" && el.hasAttribute("src"))
+      continue;
+    for (const attr of ["src", "href", "poster", "xlink:href"]) {
+      const value = el.getAttribute(attr);
+      if (!value || !isRelativeUrl(value))
+        continue;
+      el.setAttribute(attr, rebaseRelativePath(value, sourceDir, projectDir));
+    }
+  }
+  for (const el of [...document.querySelectorAll("[srcset]")]) {
+    const srcset = el.getAttribute("srcset");
+    if (srcset)
+      el.setAttribute("srcset", rewriteSrcsetUrls(srcset, (url) => isRelativeUrl(url) ? rebaseRelativePath(url, sourceDir, projectDir) : url));
+  }
+  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, rebaseColorGradingLutPath(value, sourceDir, projectDir));
+  }
+}
+function inlineCssFile(css, cssFileDir, projectDir, activeImports) {
+  const { result: strippedCss, restore: restoreComments } = withCommentsStripped(css, (s) => s);
+  const importPlaceholders = [];
+  const withPlaceholders = strippedCss.replace(CSS_IMPORT_RE, (full, _q1, urlPath, _q2, barePath, mediaQuery) => {
+    const importPath = urlPath ?? barePath;
+    if (!importPath || !isRelativeUrl(importPath))
+      return full;
+    const resolved = resolve2(cssFileDir, decodedUrlPath(importPath));
+    if (!isSafePath(projectDir, resolved))
+      return full;
+    if (activeImports.has(resolved))
+      return "";
+    const content = safeReadFile(resolved);
+    if (content == null)
+      return full;
+    activeImports.add(resolved);
+    const inlined = inlineCssFile(content, dirname(resolved), projectDir, activeImports);
+    activeImports.delete(resolved);
+    const trimmedMedia = (mediaQuery || "").trim();
+    const block = trimmedMedia ? `@media ${trimmedMedia} {
+${inlined}
+}
+` : inlined + "\n";
+    const idx = importPlaceholders.length;
+    importPlaceholders.push(block);
+    return `/*__hf_import_${idx}__*/`;
+  });
+  let rebased = rebaseCssUrls(withPlaceholders, cssFileDir, projectDir);
+  rebased = restoreComments(rebased);
+  for (let i = 0; i < importPlaceholders.length; i++) {
+    rebased = rebased.replace(`/*__hf_import_${i}__*/`, importPlaceholders[i]);
+  }
+  return rebased;
+}
+function safeReadFileBuffer(filePath) {
+  noteRead(filePath);
+  if (!existsSync(filePath))
+    return null;
+  try {
+    return readFileSync(filePath);
+  } catch {
+    return null;
+  }
+}
+function appendSuffixToUrl(baseUrl, suffix) {
+  if (!suffix)
+    return baseUrl;
+  if (suffix.startsWith("#"))
+    return `${baseUrl}${suffix}`;
+  if (suffix.startsWith("?")) {
+    const queryWithOptionalHash = suffix.slice(1);
+    if (!queryWithOptionalHash)
+      return baseUrl;
+    const hashIdx = queryWithOptionalHash.indexOf("#");
+    const queryPart = hashIdx >= 0 ? queryWithOptionalHash.slice(0, hashIdx) : queryWithOptionalHash;
+    const hashPart = hashIdx >= 0 ? queryWithOptionalHash.slice(hashIdx) : "";
+    if (!queryPart)
+      return `${baseUrl}${hashPart}`;
+    const joiner = baseUrl.includes("?") ? "&" : "?";
+    return `${baseUrl}${joiner}${queryPart}${hashPart}`;
+  }
+  return baseUrl;
+}
+var INLINE_MIME = {
+  ".svg": "image/svg+xml",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".cube": "text/plain",
+  ".xml": "application/xml",
+  // Fonts and raster images. A bundle handed to a consumer that stores it as a
+  // lone object — no sibling `assets/` directory — 404s on every surviving
+  // relative reference, and a missing font silently reflows the whole frame
+  // rather than failing loudly. Media (mp4/webm/mp3/wav) is deliberately absent:
+  // it is large, streamed rather than laid out, and its absence is obvious.
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif"
+};
+var MAX_INLINE_ASSET_BYTES = 2 * 1024 * 1024;
+var MAX_INLINED_BUNDLE_CHARS = 256 * 1024 * 1024;
+function safeStatSize(filePath) {
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return null;
+  }
+}
+function warnAssetTooLargeToInline(assetPath, byteLength) {
+  const mb = (byteLength / (1024 * 1024)).toFixed(1);
+  console.warn(`[Framey] Not inlining "${assetPath}" (${mb} MB exceeds the ${MAX_INLINE_ASSET_BYTES / (1024 * 1024)} MB inline limit). The bundle may not be self-contained.`);
+}
+function warnInlineBudgetExhausted(assetPath) {
+  console.warn(`[Framey] Not inlining "${assetPath}" and later assets: the bundle already inlines ${MAX_INLINED_BUNDLE_CHARS / (1024 * 1024)} MB of data URLs. The bundle may not be self-contained.`);
+}
+function createAssetInliner(resolveProjectPath, inlineAssets) {
+  const assets = /* @__PURE__ */ new Map();
+  let inlinedChars = 0;
+  let budgetExhausted = false;
+  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;
+    }
+    if (asset.dataUrl === null)
+      return null;
+    if (budgetExhausted || inlinedChars + asset.dataUrl.length > MAX_INLINED_BUNDLE_CHARS) {
+      if (!budgetExhausted)
+        warnInlineBudgetExhausted(basePath);
+      budgetExhausted = true;
+      return null;
+    }
+    inlinedChars += asset.dataUrl.length;
+    const hashIdx = suffix.indexOf("#");
+    return hashIdx < 0 ? asset.dataUrl : `${asset.dataUrl}${suffix.slice(hashIdx)}`;
+  };
+}
+function isExternalSvgFragmentUse(el, attr, urlValue) {
+  if (el.tagName.toLowerCase() !== "use")
+    return false;
+  if (attr !== "href" && attr !== "xlink:href")
+    return false;
+  if (!isRelativeUrl(urlValue))
+    return false;
+  const hashIdx = urlValue.indexOf("#");
+  if (hashIdx <= 0)
+    return false;
+  const pathBeforeFragment = urlValue.slice(0, hashIdx).split("?", 1)[0] ?? "";
+  return pathBeforeFragment.toLowerCase().endsWith(".svg");
+}
+function warnColorGradingLutNotInlined(lutSrc) {
+  const trimmed = lutSrc.trim();
+  if (!isRelativeUrl(trimmed))
+    return;
+  console.warn(`[Framey] Could not inline color grading LUT "${trimmed}". The rendered bundle may not be self-contained.`);
+}
+function rewriteColorGradingLutWithInlinedAssets(value, inlineAsset) {
+  if (!value.trim().startsWith("{"))
+    return value;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return value;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return value;
+  const lut = Reflect.get(parsed, "lut");
+  if (typeof lut === "string") {
+    const inlined2 = inlineAsset(lut);
+    if (!inlined2) {
+      warnColorGradingLutNotInlined(lut);
+      return value;
+    }
+    Reflect.set(parsed, "lut", inlined2);
+    return JSON.stringify(parsed);
+  }
+  if (typeof lut !== "object" || lut === null || Array.isArray(lut))
+    return value;
+  const lutSrc = Reflect.get(lut, "src");
+  if (typeof lutSrc !== "string")
+    return value;
+  const inlined = inlineAsset(lutSrc);
+  if (!inlined) {
+    warnColorGradingLutNotInlined(lutSrc);
+    return value;
+  }
+  Reflect.set(lut, "src", inlined);
+  return JSON.stringify(parsed);
+}
+function rewriteCssUrlsWithInlinedAssets(cssText, inlineAsset) {
+  if (!cssText)
+    return cssText;
+  return cssText.replace(/\burl\(\s*(["']?)([^)"']+)\1\s*\)/g, (_full, quote, rawUrl) => {
+    const maybeInlined = inlineAsset((rawUrl || "").trim());
+    if (!maybeInlined)
+      return _full;
+    return `url(${quote || ""}${maybeInlined}${quote || ""})`;
+  });
+}
+function cssAttributeSelector(attr, value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\3c ");
+  return `[${attr}="${escaped}"]`;
+}
+function uniqueCompositionId(baseId, index) {
+  return `${baseId}__hf${index}`;
+}
+function getBundledHostCompositionIdentity(host) {
+  const currentCompositionId = (host.getAttribute("data-composition-id") || "").trim() || null;
+  const authoredCompositionId = (host.getAttribute("data-hf-original-composition-id") || currentCompositionId || "").trim() || null;
+  return {
+    authoredCompositionId,
+    runtimeCompositionId: currentCompositionId
+  };
+}
+function getBundledTrackedCompositionHosts(document) {
+  const hosts = Array.from(document.querySelectorAll("[data-composition-src], [data-composition-id]"));
+  return hosts.filter((host) => {
+    if (host.hasAttribute("data-composition-src"))
+      return true;
+    const authoredCompositionId = getBundledHostCompositionIdentity(host).authoredCompositionId;
+    if (!authoredCompositionId)
+      return false;
+    return !!document.getElementById(`${authoredCompositionId}-template`);
+  });
+}
+function shouldAssignBundledRuntimeCompositionId(host, document) {
+  if (host.hasAttribute("data-composition-src"))
+    return true;
+  const authoredCompositionId = getBundledHostCompositionIdentity(host).authoredCompositionId;
+  if (!authoredCompositionId)
+    return false;
+  if (!document.getElementById(`${authoredCompositionId}-template`))
+    return false;
+  return host.children.length === 0;
+}
+function countBundledAuthoredCompositionIds(hosts) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const host of hosts) {
+    const authoredCompositionId = getBundledHostCompositionIdentity(host).authoredCompositionId;
+    if (!authoredCompositionId)
+      continue;
+    counts.set(authoredCompositionId, (counts.get(authoredCompositionId) || 0) + 1);
+  }
+  countPageRoot(counts, hosts);
+  return counts;
+}
+function assignBundledRuntimeCompositionIds(hosts, counts = countBundledAuthoredCompositionIds(hosts)) {
+  const instanceByCompositionId = /* @__PURE__ */ new Map();
+  const identities = /* @__PURE__ */ new Map();
+  for (const host of hosts) {
+    const { authoredCompositionId, runtimeCompositionId: previousRuntimeCompositionId } = getBundledHostCompositionIdentity(host);
+    const shouldAssign = shouldAssignBundledRuntimeCompositionId(host, host.ownerDocument);
+    if (!authoredCompositionId) {
+      identities.set(host, {
+        authoredCompositionId: null,
+        runtimeCompositionId: previousRuntimeCompositionId
+      });
+      continue;
+    }
+    const duplicateInstance = (counts.get(authoredCompositionId) || 0) > 1;
+    let runtimeCompositionId = previousRuntimeCompositionId || authoredCompositionId;
+    if (shouldAssign) {
+      const instanceIndex = duplicateInstance ? (instanceByCompositionId.get(authoredCompositionId) || 0) + 1 : 0;
+      if (duplicateInstance) {
+        instanceByCompositionId.set(authoredCompositionId, instanceIndex);
+        host.setAttribute("data-hf-original-composition-id", authoredCompositionId);
+      } else {
+        host.removeAttribute("data-hf-original-composition-id");
+      }
+      runtimeCompositionId = duplicateInstance ? uniqueCompositionId(authoredCompositionId, instanceIndex) : authoredCompositionId;
+      host.setAttribute("data-composition-id", runtimeCompositionId);
+    }
+    identities.set(host, {
+      authoredCompositionId,
+      runtimeCompositionId
+    });
+  }
+  return identities;
+}
+function prepareFlattenedInnerRoot(innerRoot) {
+  const prepared = innerRoot.cloneNode(true);
+  markFlattenedInnerRoot(prepared);
+  const w = prepared.getAttribute("data-width");
+  const h = prepared.getAttribute("data-height");
+  const widthVal = w ? `${w}px` : "100%";
+  const heightVal = h ? `${h}px` : "100%";
+  const existingStyle = (prepared.getAttribute("style") || "").trim();
+  const fill = `width:${widthVal};height:${heightVal}`;
+  prepared.setAttribute("style", existingStyle ? `${existingStyle};${fill}` : fill);
+  return prepared;
+}
+function enforceCompositionPixelSizing(document) {
+  const compositionEls = [
+    ...document.querySelectorAll("[data-composition-id][data-width][data-height]")
+  ];
+  if (compositionEls.length === 0)
+    return;
+  const sizeMap = /* @__PURE__ */ new Map();
+  for (const el of compositionEls) {
+    const compId = el.getAttribute("data-composition-id");
+    const w = Number(el.getAttribute("data-width"));
+    const h = Number(el.getAttribute("data-height"));
+    if (compId && Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+      sizeMap.set(compId, { w, h });
+    }
+  }
+  if (sizeMap.size === 0)
+    return;
+  for (const styleEl of document.querySelectorAll("style")) {
+    let css = styleEl.textContent || "";
+    let modified = false;
+    for (const [compId, { w, h }] of sizeMap) {
+      const escaped = compId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const blockRe = new RegExp(`(\\[data-composition-id=["']${escaped}["']\\]\\s*\\{)([^}]*)(})`, "g");
+      css = css.replace(blockRe, (_, open, body, close) => {
+        const newBody = body.replace(/(\bwidth\s*:\s*)100%/g, `$1${w}px`).replace(/(\bheight\s*:\s*)100%/g, `$1${h}px`);
+        if (newBody !== body)
+          modified = true;
+        return open + newBody + close;
+      });
+    }
+    if (modified)
+      styleEl.textContent = css;
+  }
+}
+function autoHealMissingCompositionIds(document) {
+  const compositionIdRe = /data-composition-id=["']([^"']+)["']/gi;
+  const referencedIds = /* @__PURE__ */ new Set();
+  for (const el of document.querySelectorAll("style, script")) {
+    const text = (el.textContent || "").trim();
+    if (!text)
+      continue;
+    let match;
+    while ((match = compositionIdRe.exec(text)) !== null) {
+      const compId = (match[1] || "").trim();
+      if (compId)
+        referencedIds.add(compId);
+    }
+  }
+  if (referencedIds.size === 0)
+    return;
+  const existingIds = /* @__PURE__ */ new Set();
+  for (const el of document.querySelectorAll("[data-composition-id]")) {
+    const id = (el.getAttribute("data-composition-id") || "").trim();
+    if (id)
+      existingIds.add(id);
+  }
+  for (const compId of referencedIds) {
+    if (compId === "root" || existingIds.has(compId))
+      continue;
+    const candidates = [`${compId}-layer`, `${compId}-comp`, compId];
+    for (const targetId of candidates) {
+      const found = document.getElementById(targetId);
+      if (found && !found.getAttribute("data-composition-id")) {
+        found.setAttribute("data-composition-id", compId);
+        break;
+      }
+    }
+  }
+}
+function joinCssHoistingImports(sheets) {
+  const imports = /* @__PURE__ */ new Set();
+  const cssParts = [];
+  for (const sheet of sheets) {
+    const rest = sheet.trim().replace(CSS_IMPORT_RE, (match) => {
+      imports.add(match.trim());
+      return "";
+    });
+    if (rest.trim())
+      cssParts.push(rest.trim());
+  }
+  return [...imports, ...cssParts].join("\n\n").trim();
+}
+function placeSceneStylesLikeRender(document) {
+  const styles = [...document.querySelectorAll("head style")];
+  const imports = /* @__PURE__ */ new Set();
+  for (const el of styles) {
+    el.textContent = (el.textContent || "").replace(CSS_IMPORT_RE, (match) => (imports.add(match.trim()), "")).trim();
+  }
+  styles.slice(1).reduce((previous, el) => (previous.after(el), el), styles[0]);
+  if (imports.size === 0)
+    return;
+  const hoisted = [...imports].join("\n\n");
+  const first = styles[0];
+  if (!first.hasAttribute(SCENE_PART_ATTR)) {
+    first.textContent = [hoisted, first.textContent].filter(Boolean).join("\n\n");
+    return;
+  }
+  const holder = document.createElement("style");
+  holder.textContent = hoisted;
+  first.before(holder);
+}
+function isAlwaysAppliedStyle(el) {
+  return cssStyleMergeKey(el) === UNCONDITIONAL_CSS_KEY && !el.closest("template, noscript, svg");
+}
+function pushRun(runs, scene, chunk) {
+  const last = runs.at(-1);
+  if (last && last.scene === scene)
+    last.chunks.push(chunk);
+  else
+    runs.push({ scene, chunks: [chunk] });
+}
+async function coalesceHeadStylesAndBodyScripts(document, provenance) {
+  const allHeadStyles = [...document.querySelectorAll("head style")];
+  const isScenePart = (el) => el.hasAttribute(SCENE_PART_ATTR);
+  for (const run of allHeadStyles.length > 1 ? headStyleRuns(allHeadStyles, isScenePart) : []) {
+    const merged = joinCssHoistingImports(run.map((el) => el.textContent || ""));
+    if (!merged)
+      continue;
+    run[0].textContent = merged;
+    for (const el of run.slice(1))
+      el.remove();
+  }
+  if (allHeadStyles.some(isScenePart))
+    placeSceneStylesLikeRender(document);
+  const isPinned = (el) => el.hasAttribute(RUNTIME_BOOTSTRAP_ATTR) || el.hasAttribute(SCENE_PART_ATTR);
+  for (const { members, anchor } of inlineScriptRuns([...document.querySelectorAll("body script")], isPinned)) {
+    const mergedJs = joinJsChunks(members.map((el) => el.textContent || ""));
+    if (mergedJs && !parsesAsScript(mergedJs)) {
+      for (const el of members)
+        el.textContent = await inlineScriptSource(el.textContent || "", provenance);
+      continue;
+    }
+    for (const el of members)
+      el.remove();
+    if (!mergedJs)
+      continue;
+    const inlineScript = document.createElement("script");
+    inlineScript.textContent = await inlineScriptSource(mergedJs, provenance);
+    if (anchor)
+      anchor.before(inlineScript);
+    else
+      document.body.appendChild(inlineScript);
+  }
+}
+function injectTextRenderingRule(document) {
+  const head = document.head;
+  if (!head)
+    return;
+  if (document.querySelector("style[data-hyperframes-text-rendering]"))
+    return;
+  const styleEl = document.createElement("style");
+  styleEl.setAttribute("data-hyperframes-text-rendering", "true");
+  styleEl.textContent = "html,body,*{text-rendering:geometricPrecision}";
+  head.insertBefore(styleEl, head.firstChild);
+}
+function joinJsChunks(chunks) {
+  return chunks.map((chunk) => chunk.trim()).filter((chunk) => chunk.length > 0).map((chunk) => chunk.endsWith(";") ? chunk : chunk + "\n;").join("\n");
+}
+function parsesAsScript(source) {
+  try {
+    parseJs(source, { ecmaVersion: "latest", sourceType: "script" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stripJsCommentsParserSafe(source, provenance) {
+  if (!source)
+    return source;
+  const { transform } = await import("esbuild");
+  try {
+    const result = await transform(source, {
+      loader: "js",
+      minify: false,
+      legalComments: "none",
+      ...provenance ? { sourcemap: "external", sourcefile: "hf-authored-bundle.js" } : {}
+    });
+    if (provenance) {
+      const sourceURL = `hf-inspect-${createHash("sha256").update(source).digest("hex")}.js`;
+      provenance({ input: source, output: result.code.trim(), sourceMap: result.map, sourceURL });
+      return `${result.code.trim()}
+//# sourceURL=${sourceURL}`;
+    }
+    return result.code.trim();
+  } catch {
+    return source;
+  }
+}
+async function inlineScriptSource(js, provenance) {
+  return escapeInlineScriptSource(await stripJsCommentsParserSafe(js, provenance));
+}
+function preserveLocalScriptIntegrity(doc, src, resolvePath) {
+  const path = resolvePath(src);
+  if (!path)
+    return false;
+  const pinned = [...doc.querySelectorAll("script[src][integrity]")].filter((el) => {
+    const candidate = el.getAttribute("src") || "";
+    return isRelativeUrl(candidate) && resolvePath(candidate) === path && el.getAttribute("integrity")?.trim();
+  });
+  for (const el of pinned)
+    ensureExternalScriptTag(doc, src, readExternalScriptAttributes(el));
+  return pinned.length > 0;
+}
+function hoistExternalScript(src, projectDir, doc, seenSrcs, chunks, attributes) {
+  if (attributes.integrity?.trim()) {
+    ensureExternalScriptTag(doc, src, attributes);
+    seenSrcs.add(src);
+    return;
+  }
+  if (seenSrcs.has(src))
+    return;
+  seenSrcs.add(src);
+  if (!isNonRelativeUrl(src) && !isAbsolute(src) && attributes.type !== "module") {
+    const jsPath = resolveWithinProject(projectDir, decodedUrlPath(src));
+    const js = jsPath ? safeReadFile(jsPath) : null;
+    if (js != null) {
+      chunks.push(() => preserveLocalScriptIntegrity(doc, src, (value) => resolveWithinProject(projectDir, decodedUrlPath(value))) ? "" : js);
+      return;
+    }
+  }
+  ensureExternalScriptTag(doc, src, attributes);
+}
+function hoistCompositionScripts(container, opts) {
+  for (const scriptEl of executableScripts(container)) {
+    const externalSrc = (scriptEl.getAttribute("src") || "").trim();
+    const type = (scriptEl.getAttribute("type") || "").trim().toLowerCase();
+    if (!externalSrc && type === "importmap") {
+      const map = parseImportMap(scriptEl.textContent || "", (url) => url);
+      if (map)
+        opts.importMaps.push(map);
+      else
+        console.warn(`[Framey] ${opts.compId}: import map is not valid JSON, so it is skipped.`);
+    } else if (!externalSrc && type === "module") {
+      const prelude = opts.compId ? scopedModulePrelude(opts.runtimeCompId || opts.compId) : "";
+      opts.moduleScripts.push(prelude + (scriptEl.textContent || ""));
+    } else if (externalSrc) {
+      hoistExternalScript(externalSrc, opts.projectDir, opts.document, opts.seenCompScriptSrcs, opts.compScriptChunks, readExternalScriptAttributes(scriptEl));
+    } else {
+      opts.compScriptChunks.push(opts.compId ? wrapScopedCompositionScript(scriptEl.textContent || "", opts.compId, "[Framey] composition script error:", opts.runtimeScope, opts.runtimeCompId || opts.compId, opts.authoredRootId) : wrapInlineScriptWithErrorBoundary(scriptEl.textContent || "", "[Framey] composition script error:"));
+    }
+    scriptEl.remove();
+  }
+}
+function bundleToSingleHtml(projectDir, options) {
+  const bundle = () => bundleProject(projectDir, options);
+  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))
+    return null;
+  const indexHtml = safeReadFile(resolve2(projectDir, "index.html"));
+  return indexHtml === null ? null : extractStandaloneEntryFromIndex(indexHtml, entryFile, entryHtml);
+}
+async function bundleProject(projectDir, options) {
+  const entryFile = options?.entryFile ?? "index.html";
+  const indexPath = resolveWithinProject(projectDir, entryFile);
+  if (!indexPath || !existsSync(indexPath)) {
+    throw new Error(`${entryFile} not found in project directory`);
+  }
+  noteRead(indexPath);
+  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) => {
+    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;
+  const rawHtml = readSource(mountedShell ?? entryHtml);
+  const compiled = await compileHtml(rawHtml, sourceDir, options?.probeMediaDuration);
+  if (options?.staticGuard !== false && !mountedShell) {
+    const staticGuard = await validateHyperframeHtmlContract(compiled);
+    if (!staticGuard.isValid) {
+      console.warn(`[StaticGuard] Invalid HyperFrame contract: ${staticGuard.missingKeys.join("; ")}`);
+    }
+  }
+  const withInterceptor = injectInterceptor(compiled, options?.runtime ?? "inline");
+  const document = parseHTMLContent(withInterceptor);
+  if (resolve2(sourceDir) !== resolve2(projectDir)) {
+    rebaseEntryAuthoredAssetPaths(document, sourceDir, projectDir);
+  }
+  for (const el of [...document.querySelectorAll('link[rel="stylesheet"]')]) {
+    const href = el.getAttribute("href");
+    if (!href || !isRelativeUrl(href) || cssStyleMergeKey(el) === void 0)
+      continue;
+    if (el.hasAttribute("disabled"))
+      continue;
+    const cssPath = resolveEntryUrl(href);
+    if (!cssPath)
+      continue;
+    const css = safeReadFile(cssPath);
+    if (css == null)
+      continue;
+    const style = document.createElement("style");
+    for (const name of ["media", "title"]) {
+      const value = el.getAttribute(name);
+      if (value !== null)
+        style.setAttribute(name, value);
+    }
+    style.textContent = inlineCssFile(css, dirname(cssPath), projectDir, /* @__PURE__ */ new Set([cssPath]));
+    el.replaceWith(style);
+  }
+  const rootScripts = options?.sceneParts ? [
+    ...document.querySelectorAll(`script:not([${RUNTIME_BOOTSTRAP_ATTR}])`),
+    ...[...document.querySelectorAll("template")].flatMap((t) => [
+      ...t.content.querySelectorAll("script")
+    ])
+  ].map((el) => {
+    const src = el.getAttribute("src");
+    const path = src && isRelativeUrl(src) ? resolveEntryUrl(src) : null;
+    return src ? path && safeReadFile(path) || "" : el.textContent || "";
+  }) : [];
+  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);
+      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,
+    rewriteInlineStyles: true,
+    // A sub-composition's SIBLING assets (a stylesheet next to it) must be
+    // re-pointed at its own directory when its content moves to the root
+    // document; project-root refs with no such sibling stay as authored.
+    assetExists: (path) => {
+      const resolved = resolveEntryPath(path);
+      if (resolved)
+        noteRead(resolved);
+      return resolved !== null && existsSync(resolved);
+    },
+    flattenInnerRoot: prepareFlattenedInnerRoot,
+    tagScenes: options?.sceneParts === true,
+    readVariableDefaults: readDeclaredDefaults,
+    parseHostVariables: parseHostVariableValues,
+    buildScopeSelector: (compId) => cssAttributeSelector("data-composition-id", compId),
+    scriptErrorLabel: "[Framey] composition script error:",
+    onMissingComposition: (srcPath, reason) => {
+      console.warn(`[Bundler] Skipping sub-composition "${srcPath}": ${reason ?? "the file could not be found"}.`);
+    }
+  });
+  refuseSwapsReachedByRootScripts(document, rootScripts);
+  const styleRuns = [];
+  subCompResult.styles.forEach((style, i) => pushRun(styleRuns, subCompResult.styleScenes[i], style));
+  const scriptRuns = [];
+  const compStyleChunks = [];
+  const compScriptChunks = [];
+  const compExternalLinks = [...subCompResult.externalLinks];
+  const compVariablesByComp = {
+    ...subCompResult.variablesByComp
+  };
+  const seenCompScriptSrcs = /* @__PURE__ */ new Set();
+  for (const scriptItem of subCompResult.scriptItems) {
+    if (scriptItem.kind === "inline") {
+      pushRun(scriptRuns, scriptItem.scene, scriptItem.content);
+      continue;
+    }
+    const extSrc = scriptItem.src;
+    if (scriptItem.integrity?.trim()) {
+      ensureExternalScriptTag(document, extSrc, scriptItem);
+      seenCompScriptSrcs.add(extSrc);
+      continue;
+    }
+    if (seenCompScriptSrcs.has(extSrc))
+      continue;
+    seenCompScriptSrcs.add(extSrc);
+    if (isRelativeUrl(extSrc) && scriptItem.type !== "module") {
+      const jsPath = resolveEntryUrl(extSrc);
+      const js = jsPath ? safeReadFile(jsPath) : null;
+      if (js != null) {
+        const chunk = () => preserveLocalScriptIntegrity(document, extSrc, resolveEntryUrl) ? "" : js;
+        pushRun(scriptRuns, scriptItem.scene, chunk);
+        continue;
+      }
+    }
+    ensureExternalScriptTag(document, extSrc, scriptItem);
+  }
+  const candidateInlineHosts = trackedCompositionHosts.filter((host) => !host.hasAttribute("data-composition-src"));
+  for (const templateEl of [...document.querySelectorAll("template[id]")]) {
+    const templateId = templateEl.getAttribute("id") || "";
+    const match = templateId.match(/^(.+)-template$/);
+    if (!match)
+      continue;
+    const compId = match[1];
+    if (!compId)
+      continue;
+    const hosts = candidateInlineHosts.filter((host) => hostIdentityByElement.get(host)?.authoredCompositionId === compId && host.children.length === 0);
+    if (hosts.length === 0)
+      continue;
+    const templateHtml = templateEl.innerHTML || "";
+    for (const host of hosts) {
+      const hostIdentity = hostIdentityByElement.get(host);
+      const runtimeCompId = hostIdentity?.runtimeCompositionId || compId;
+      const innerDoc = parseHTMLContent(templateHtml);
+      const plan = planCompositionAssembly({
+        contentNode: innerDoc,
+        hasTemplate: true,
+        compositionId: compId
+      });
+      const { innerRoot, authoredRootId } = plan;
+      const runtimeScope = runtimeCompId ? cssAttributeSelector("data-composition-id", runtimeCompId) : "";
+      const mergedVariables = runtimeCompId ? parseHostVariableValues(host) : {};
+      if (runtimeCompId && Object.keys(mergedVariables).length > 0) {
+        compVariablesByComp[runtimeCompId] = mergedVariables;
+      }
+      if (runtimeCompId) {
+        warnUnknownEnumValues(innerDoc.documentElement, mergedVariables, runtimeCompId);
+        warnUnknownEnumValues(innerRoot, mergedVariables, runtimeCompId);
+      }
+      pushSubCompVariableStyles(innerDoc, innerRoot, mergedVariables, runtimeScope, compStyleChunks);
+      if (innerRoot) {
+        for (const styleEl of [...innerRoot.querySelectorAll("style")]) {
+          if (cssStyleMergeKey(styleEl) === void 0)
+            continue;
+          const css = styleEl.textContent || "";
+          compStyleChunks.push(compositionStyle(styleEl, compId ? scopeCssToComposition(css, compId, runtimeScope, authoredRootId, {
+            scopeRootSelectors: true
+          }) : css));
+          styleEl.remove();
+        }
+        hoistCompositionScripts(innerRoot, {
+          projectDir,
+          document,
+          compId,
+          runtimeScope,
+          runtimeCompId,
+          authoredRootId: authoredRootId ?? void 0,
+          seenCompScriptSrcs,
+          compScriptChunks,
+          importMaps: subCompResult.importMaps,
+          moduleScripts: subCompResult.moduleScripts
+        });
+        const innerW = innerRoot.getAttribute("data-width");
+        const innerH = innerRoot.getAttribute("data-height");
+        if (innerW && !host.getAttribute("data-width"))
+          host.setAttribute("data-width", innerW);
+        if (innerH && !host.getAttribute("data-height"))
+          host.setAttribute("data-height", innerH);
+        const preparedInnerRoot = prepareFlattenedInnerRoot(innerRoot);
+        host.innerHTML = preparedInnerRoot.outerHTML || "";
+      } else {
+        for (const styleEl of [...innerDoc.querySelectorAll("style")]) {
+          if (cssStyleMergeKey(styleEl) === void 0)
+            continue;
+          const css = styleEl.textContent || "";
+          compStyleChunks.push(compositionStyle(styleEl, compId ? scopeCssToComposition(css, compId, runtimeScope, void 0, {
+            scopeRootSelectors: true
+          }) : css));
+          styleEl.remove();
+        }
+        hoistCompositionScripts(innerDoc, {
+          projectDir,
+          document,
+          compId,
+          runtimeScope,
+          runtimeCompId,
+          authoredRootId: void 0,
+          seenCompScriptSrcs,
+          compScriptChunks,
+          importMaps: subCompResult.importMaps,
+          moduleScripts: subCompResult.moduleScripts
+        });
+        host.innerHTML = innerDoc.body.innerHTML || "";
+      }
+      for (const el of plan.inertScriptsOutsideRoot)
+        host.insertAdjacentHTML("beforeend", el.outerHTML);
+    }
+    templateEl.remove();
+  }
+  for (const el of [...document.querySelectorAll("script[src]")]) {
+    const src = el.getAttribute("src");
+    if (!src || !isRelativeUrl(src))
+      continue;
+    if (preserveLocalScriptIntegrity(document, src, resolveEntryUrl))
+      continue;
+    if ((el.getAttribute("type") || "").trim().toLowerCase() === "module")
+      continue;
+    const jsPath = resolveEntryUrl(src);
+    const js = jsPath ? safeReadFile(jsPath) : null;
+    if (js == null)
+      continue;
+    el.setAttribute(INLINED_FILE_ATTR, src);
+    el.removeAttribute("src");
+    el.textContent = js;
+  }
+  for (const link of compExternalLinks)
+    ensureExternalLinkTag(document, link);
+  for (const css of compStyleChunks)
+    pushRun(styleRuns, void 0, css);
+  for (const chunk of compScriptChunks)
+    pushRun(scriptRuns, void 0, chunk);
+  const variablesByCompScript = buildVariablesByCompScript(compVariablesByComp);
+  if (variablesByCompScript) {
+    if (scriptRuns[0] && !scriptRuns[0].scene)
+      scriptRuns[0].chunks.unshift(variablesByCompScript);
+    else
+      scriptRuns.unshift({ chunks: [variablesByCompScript] });
+  }
+  for (const { scene, chunks } of styleRuns) {
+    const join = scene ? joinCssHoistingImports : (css) => css.join("\n\n");
+    for (const style of styleElementsFor(document, chunks, join)) {
+      if (scene)
+        style.setAttribute(SCENE_PART_ATTR, scene);
+      document.head.appendChild(style);
+    }
+  }
+  for (const { scene, chunks } of scriptRuns) {
+    const texts = chunks.map((chunk) => typeof chunk === "string" ? chunk : chunk());
+    const joined = joinJsChunks(texts);
+    const skipsRunMerge = Boolean(scene);
+    for (const text of parsesAsScript(joined) ? [joined] : texts.filter(Boolean)) {
+      const script = document.createElement("script");
+      if (scene)
+        script.setAttribute(SCENE_PART_ATTR, scene);
+      script.textContent = skipsRunMerge ? await inlineScriptSource(text, options?.scriptProvenance) : text;
+      document.body.appendChild(script);
+    }
+  }
+  emitMountedModuleScripts(document, subCompResult.importMaps, subCompResult.moduleScripts);
+  emitRootCompositionVariableStyles(document, compVariablesByComp);
+  enforceCompositionPixelSizing(document);
+  autoHealMissingCompositionIds(document);
+  await coalesceHeadStylesAndBodyScripts(document, options?.scriptProvenance);
+  for (const el of document.querySelectorAll(`script[${INLINED_FILE_ATTR}]`)) {
+    const js = el.textContent ?? "";
+    el.textContent = escapeInlineScriptSource(isJavaScriptType(el) ? await stripJsCommentsParserSafe(js, options?.scriptProvenance) : js);
+  }
+  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);
+      if (!value)
+        continue;
+      if (isExternalSvgFragmentUse(el, attr, value))
+        continue;
+      const inlined = inlineAsset(value);
+      if (inlined)
+        el.setAttribute(attr, inlined);
+    }
+  }
+  for (const el of [...document.querySelectorAll("[srcset]")]) {
+    const srcset = el.getAttribute("srcset");
+    if (srcset)
+      el.setAttribute("srcset", rewriteSrcsetUrls(srcset, (url) => inlineAsset(url) ?? url));
+  }
+  const liveStyles = [...document.querySelectorAll("style")].filter(isAlwaysAppliedStyle);
+  const liveCss = liveStyles.map((el) => el.textContent || "");
+  const { styles, faces } = options?.sceneParts ? hoistFontFaceRules(liveCss) : { styles: dedupeFontFaceRules(liveCss), faces: [] };
+  liveStyles.forEach((el, i) => {
+    el.textContent = styles[i] ?? "";
+  });
+  if (faces.length > 0) {
+    const holder = document.createElement("style");
+    holder.setAttribute(SCENE_FONTS_ATTR, "");
+    holder.textContent = faces.join("\n");
+    document.head.prepend(holder);
+  }
+  for (const styleEl of document.querySelectorAll("style")) {
+    styleEl.textContent = rewriteCssUrlsWithInlinedAssets(styleEl.textContent || "", inlineAsset);
+  }
+  for (const el of [...document.querySelectorAll("[style]")]) {
+    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, inlineAsset));
+      }
+    }
+  }
+  assignMediaRenderIds(document);
+  return document.toString();
+}
+function cssSafeVariableValue(value) {
+  return sanitizeCssValue(String(value)).replace(/</g, "\\3c ");
+}
+function compositionVariablesCssBlock(variables, selector) {
+  const lines = [];
+  for (const [id, value] of Object.entries(variables)) {
+    if (typeof value === "string" && value !== "" || typeof value === "number") {
+      lines.push(`  ${cssVariableName(id)}: ${cssSafeVariableValue(value)};`);
+    }
+  }
+  if (lines.length === 0)
+    return null;
+  return `${selector} {
+${lines.join("\n")}
+}`;
+}
+function emitRootCompositionVariableStyles(document, variablesByComp = {}, overrides = {}) {
+  const authoredDefines = authoredDefinesPredicate(document);
+  const layerFor = makeVariableLayer(authoredDefines, overrides);
+  const rules = [
+    ...hostScopedVariableRules(variablesByComp, overrides, authoredDefines),
+    ...rootDeclaredVariableRules(document, layerFor),
+    ...declarerVariableRules(document, layerFor)
+  ];
+  if (rules.length === 0)
+    return false;
+  const style = document.createElement("style");
+  style.setAttribute("data-hf-composition-variables", "");
+  style.textContent = rules.join("\n\n");
+  document.head.appendChild(style);
+  return true;
+}
+function authoredDefinesPredicate(document) {
+  const authoredCss = [...document.querySelectorAll("style:not([data-hf-composition-variables])")].map((s) => s.textContent || "").join("\n");
+  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) => {
+    const out = {};
+    for (const [id, value] of Object.entries(declared)) {
+      if (!authoredDefines(id))
+        out[id] = value;
+    }
+    for (const [id, value] of Object.entries(hostValues)) {
+      if (id in declared)
+        out[id] = value;
+    }
+    for (const [id, value] of Object.entries(overrides)) {
+      if (id in declared || id in hostValues)
+        out[id] = value;
+    }
+    return out;
+  };
+}
+function hostScopedVariableRules(variablesByComp, overrides, authoredDefines) {
+  const rules = [];
+  for (const [compId, vars] of Object.entries(variablesByComp)) {
+    const withOverrides = {};
+    for (const [id, value] of Object.entries(vars)) {
+      if (!authoredDefines(id))
+        withOverrides[id] = value;
+    }
+    for (const [id, value] of Object.entries(overrides)) {
+      if (id in vars)
+        withOverrides[id] = value;
+    }
+    const rule = compositionVariablesCssBlock(withOverrides, cssAttributeSelector("data-composition-id", compId));
+    if (rule)
+      rules.push(rule);
+  }
+  return rules;
+}
+function rootDeclaredVariableRules(document, layerFor) {
+  const htmlDeclared = readDeclaredDefaults(document.documentElement);
+  const htmlRule = compositionVariablesCssBlock(layerFor(htmlDeclared, {}), ":root");
+  return htmlRule ? [htmlRule] : [];
+}
+function declarerVariableRules(document, layerFor) {
+  const rules = [];
+  let markerSeq = 0;
+  for (const el of [...document.querySelectorAll("[data-composition-variables]")]) {
+    const declared = readDeclaredDefaults(el);
+    const hostEl = typeof el.closest === "function" ? el.parentElement?.closest("[data-variable-values]") : null;
+    const hostValues = hostEl ? parseHostVariableValues(hostEl) : {};
+    const vars = layerFor(declared, hostValues);
+    if (Object.keys(vars).length === 0)
+      continue;
+    markerSeq += 1;
+    el.setAttribute("data-hf-var-scope", String(markerSeq));
+    const rule = compositionVariablesCssBlock(vars, `[data-hf-var-scope="${markerSeq}"]`);
+    if (rule)
+      rules.push(rule);
+  }
+  return rules;
+}
+function pushSubCompVariableStyles(innerDoc, innerRoot, mergedVariables, runtimeScope, compStyleChunks) {
+  if (!runtimeScope)
+    return;
+  const declaredForCss = readDeclaredDefaults(innerDoc.documentElement);
+  const innerRootForVars = innerRoot ?? innerDoc.querySelector("[data-composition-variables]");
+  if (innerRootForVars)
+    Object.assign(declaredForCss, readDeclaredDefaults(innerRootForVars));
+  const cssVars = compositionVariablesCssBlock({ ...declaredForCss, ...mergedVariables }, runtimeScope);
+  if (cssVars)
+    compStyleChunks.push({ css: cssVars, media: null, title: null });
+}
+
+// ../core/dist/compiler/htmlParityContract.js
+function finiteAttribute(element, name) {
+  const raw = element.getAttribute(name);
+  if (raw === null || raw.trim() === "")
+    return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+function timing(element) {
+  const start = finiteAttribute(element, "data-start") ?? 0;
+  const duration = finiteAttribute(element, "data-duration") ?? (() => {
+    const end = finiteAttribute(element, "data-end");
+    return end === null ? null : Math.max(0, end - start);
+  })();
+  return {
+    start,
+    duration,
+    trackIndex: finiteAttribute(element, "data-track-index") ?? finiteAttribute(element, "data-layer")
+  };
+}
+function normalizeJson(value) {
+  if (value === null)
+    return null;
+  try {
+    return JSON.stringify(canonicalizeJson(JSON.parse(value)));
+  } catch {
+    return value.trim();
+  }
+}
+function canonicalizeJson(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalizeJson);
+  if (value === null || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, canonicalizeJson(nested)]));
+}
+function styleSignatures(document) {
+  return [...document.querySelectorAll("style")].map((style) => style.textContent ?? "").flatMap((css) => css.match(/[^{}]+\{[^{}]*--parity-contract\s*:[^{}]+\}/g) ?? []).map((rule) => rule.replace(/\s+/g, " ").replace(/\s*([:;{},])\s*/g, "$1").trim()).sort();
+}
+function parityFontFamilies(html) {
+  const families = /* @__PURE__ */ new Set();
+  for (const match of html.matchAll(/font-family\s*:\s*([^;}]+)/gi)) {
+    for (const family of match[1].split(",")) {
+      const normalized = family.trim().replace(/^['"]|['"]$/g, "");
+      if (normalized.startsWith("Parity"))
+        families.add(normalized);
+    }
+  }
+  return [...families].sort();
+}
+function resources(document) {
+  const resources2 = [];
+  for (const [index, element] of [
+    ...document.querySelectorAll("[src], [href], [poster]")
+  ].entries()) {
+    for (const attribute of ["src", "href", "poster"]) {
+      const value = element.getAttribute(attribute)?.trim();
+      if (!value)
+        continue;
+      if (element.tagName.toLowerCase() === "script" && /framey|runtime/i.test(value))
+        continue;
+      resources2.push({
+        identity: element.getAttribute("data-hf-id") ?? element.getAttribute("id") ?? `${element.tagName.toLowerCase()}[${index}]`,
+        attribute,
+        locality: /^https?:\/\//i.test(value) ? "remote" : "local"
+      });
+    }
+  }
+  return resources2.sort((left, right) => `${left.identity}:${left.attribute}`.localeCompare(`${right.identity}:${right.attribute}`));
+}
+function extractCompiledHtmlParityContract(html) {
+  const { document } = parseHTML(html);
+  const compositions = [...document.querySelectorAll("[data-composition-id]")].map((element) => {
+    const resolved = timing(element);
+    return {
+      id: element.getAttribute("data-composition-id") ?? "",
+      originalId: element.getAttribute("data-hf-original-composition-id"),
+      ...resolved,
+      width: finiteAttribute(element, "data-width"),
+      height: finiteAttribute(element, "data-height"),
+      variableValues: normalizeJson(element.getAttribute("data-variable-values"))
+    };
+  });
+  const timedElements = [
+    ...document.querySelectorAll("[data-start], [data-duration], [data-end], [data-track-index], [data-layer]")
+  ].filter((element) => !element.hasAttribute("data-composition-id")).map((element, index) => ({
+    identity: element.getAttribute("data-hf-id") ?? element.getAttribute("id") ?? `${element.tagName.toLowerCase()}[${index}]`,
+    ...timing(element)
+  }));
+  return {
+    compositions,
+    timedElements,
+    authoredStyleSignatures: styleSignatures(document),
+    parityFontFamilies: parityFontFamilies(html),
+    resources: resources(document),
+    runtimeBootstrap: /__hyperframes|data-hyperframes-(?:preview-)?runtime/i.test(html),
+    variableBootstrap: /__hfVariables(?:ByComp)?/.test(html)
+  };
+}
+
+// ../core/dist/compiler/scenePartsManifest.js
+import { createHash as createHash2 } from "crypto";
+var hash = (text) => createHash2("sha1").update(text).digest("hex").slice(0, 16);
+function addScenePartsManifest(html, ignore = []) {
+  const doc = parseHTMLContent(html);
+  const parts = [...doc.querySelectorAll(`[${SCENE_PART_ATTR}]`)];
+  if (parts.length === 0)
+    return html;
+  const byScene = /* @__PURE__ */ new Map();
+  for (const el of parts) {
+    const scene = el.getAttribute(SCENE_PART_ATTR) ?? "";
+    byScene.set(scene, [...byScene.get(scene) ?? [], el.outerHTML]);
+  }
+  for (const el of parts)
+    el.replaceWith(doc.createComment(`hf-scene:${el.getAttribute(SCENE_PART_ATTR)}`));
+  for (const el of [...ignore, `style[${SCENE_FONTS_ATTR}]`].flatMap((sel) => [
+    ...doc.querySelectorAll(sel)
+  ]))
+    el.remove();
+  const manifest = {
+    shared: hash(doc.toString()),
+    scenes: Object.fromEntries([...byScene].map(([scene, html2]) => [scene, hash(html2.join("\n"))]))
+  };
+  const content = JSON.stringify(manifest).replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  return injectTagsAtHeadStart(html, `<meta name="${SCENE_PARTS_META}" content="${content}">`);
+}
+
+export {
+  compileHtml,
+  ensureExternalScriptTag,
+  emitMountedModuleScripts,
+  FLATTENED_INNER_ROOT_STRIP_ATTRS,
+  extractStandaloneEntryFromIndex,
+  scopeCssToComposition,
+  wrapScopedCompositionScript,
+  buildVariablesByCompScript,
+  validateHyperframeHtmlContract,
+  ensureExternalLinkTag,
+  inlineSubCompositions,
+  EXCLUDED_TAGS,
+  mintHfId,
+  walkCompositionDescendants,
+  ensureHfIds,
+  stampHfIdsInPlace,
+  assignBundledRuntimeCompositionIds,
+  prepareFlattenedInnerRoot,
+  parsesAsScript,
+  bundleToSingleHtml,
+  emitRootCompositionVariableStyles,
+  extractCompiledHtmlParityContract,
+  addScenePartsManifest
+};