@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/chunk-Z6B37SNM.js

@@ -0,0 +1,3081 @@
+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_COLOR_GRADING_ATTR,
+  RUNTIME_BOOTSTRAP_ATTR,
+  clampDurations,
+  compileTimingAttrs,
+  escapeInlineScriptSource,
+  extractResolvedMedia,
+  getHyperframeRuntimeScript,
+  injectDurations,
+  injectTagsAtHeadStart,
+  insertRuntimeTag,
+  parseHTMLContent,
+  parseHostVariableValues,
+  queryByAttr,
+  readDeclaredDefaults,
+  shouldClampResolvedMediaDuration,
+  stripEmbeddedRuntimeScripts,
+  warnUnknownEnumValues
+} from "./chunk-HWKCIWQT.js";
+import {
+  cssVariableName
+} from "./chunk-VC76R6W2.js";
+import {
+  isSafePath,
+  resolveWithinProject
+} from "./chunk-OFQWTKPW.js";
+import {
+  lintHyperframeHtml
+} from "./chunk-ZJUKFZ2P.js";
+import {
+  CSS_URL_RE,
+  checkSubCompositionUsability,
+  isNonRelativeUrl,
+  resolveSubCompositionContent,
+  rewriteAssetPath,
+  rewriteAssetPaths,
+  rewriteCssAssetUrls,
+  rewriteInlineStyleAssetUrls
+} from "./chunk-TQFG7HTI.js";
+import {
+  parseHTML
+} from "./chunk-GK4AIFIH.js";
+
+// ../core/dist/compiler/htmlCompiler.js
+import { resolve } from "path";
+function resolveMediaSrc(src, projectDir) {
+  return src.startsWith("http://") || src.startsWith("https://") ? src : resolve(projectDir, 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);
+    }
+  }
+  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/scriptRuns.js
+var JAVASCRIPT_TYPES = /* @__PURE__ */ new Set([
+  "",
+  "application/ecmascript",
+  "application/javascript",
+  "application/x-ecmascript",
+  "application/x-javascript",
+  "text/ecmascript",
+  "text/javascript",
+  "text/javascript1.0",
+  "text/javascript1.1",
+  "text/javascript1.2",
+  "text/javascript1.3",
+  "text/javascript1.4",
+  "text/javascript1.5",
+  "text/jscript",
+  "text/livescript",
+  "text/x-ecmascript",
+  "text/x-javascript"
+]);
+function isJavaScriptType(el) {
+  return JAVASCRIPT_TYPES.has((el.getAttribute("type") || "").trim().toLowerCase());
+}
+function isClassicInline(el) {
+  return !el.hasAttribute("nomodule") && isJavaScriptType(el);
+}
+function isSeparateExecution(el, isPinned) {
+  return el.hasAttribute("src") || el.hasAttribute("defer") || el.hasAttribute("async") || isPinned(el) || (el.getAttribute("type") || "").trim().toLowerCase() === "module";
+}
+function inlineScriptRuns(scripts, isPinned = () => false) {
+  const runs = [];
+  let members = [];
+  for (const el of scripts) {
+    if (isSeparateExecution(el, isPinned)) {
+      if (members.length === 0)
+        continue;
+      runs.push({ members, anchor: el });
+      members = [];
+    } else if (isClassicInline(el)) {
+      members.push(el);
+    }
+  }
+  if (members.length > 0)
+    runs.push({ members, anchor: null });
+  return runs;
+}
+var AFTER_FONTS_SCRIPT_TYPE = "text/hf-after-fonts";
+var AFTER_FONTS_MODULE_TYPE = `${AFTER_FONTS_SCRIPT_TYPE}+module`;
+var AFTER_FONTS_SCRIPTS = `script[type="${AFTER_FONTS_SCRIPT_TYPE}"], script[type="${AFTER_FONTS_MODULE_TYPE}"]`;
+var AFTER_FONTS_CLAIM = "__hfAfterFontsClaimed";
+var INLINED_FILE_ATTR = "data-hf-inlined-src";
+var DEFERRED_FILE = `[defer][src], [defer][${INLINED_FILE_ATTR}]`;
+var AFTER_FONTS_FALLBACK_ATTR = "data-hf-after-fonts-fallback";
+var afterFontsFallback = () => `document.addEventListener("DOMContentLoaded", function () {
+  if (window.${AFTER_FONTS_CLAIM}) return;
+  var T = "${AFTER_FONTS_SCRIPT_TYPE}";
+  var all = [].slice.call(document.querySelectorAll('${AFTER_FONTS_SCRIPTS}'));
+  if (!all.length) return;
+  console.warn("[hyperframes] the runtime has no web-font gate; composition scripts run without waiting for fonts");
+  var late = function (el) { return el.type !== T || el.matches('${DEFERRED_FILE}'); };
+  var queue = all.filter(function (el) { return !late(el); }).concat(all.filter(late));
+  (function next() {
+    var el = queue.shift();
+    if (!el) return;
+    var s = document.createElement("script");
+    for (var i = 0; i < el.attributes.length; i++) s.setAttribute(el.attributes[i].name, el.attributes[i].value);
+    if (el.type === T) s.removeAttribute("type"); else s.type = "module";
+    s.async = el.hasAttribute("async");
+    s.text = el.text;
+    var waits = s.type !== "module" && s.hasAttribute("src") && !s.async && !s.noModule;
+    if (waits) { s.addEventListener("load", next); s.addEventListener("error", next); }
+    el.replaceWith(s);
+    if (!waits) next();
+  })();
+});`;
+function deferScriptsUntilFonts(document, isFramework = () => false) {
+  let deferred = false;
+  for (const el of document.querySelectorAll("body script")) {
+    if (isFramework(el) || el.closest("noscript, svg"))
+      continue;
+    if (isClassicInline(el))
+      el.setAttribute("type", AFTER_FONTS_SCRIPT_TYPE);
+    else if ((el.getAttribute("type") || "").trim().toLowerCase() === "module") {
+      el.setAttribute("type", AFTER_FONTS_MODULE_TYPE);
+    } else
+      continue;
+    deferred = true;
+  }
+  if (!deferred || !document.head || document.querySelector(`script[${AFTER_FONTS_FALLBACK_ATTR}]`)) {
+    return;
+  }
+  const fallback = document.createElement("script");
+  fallback.setAttribute(AFTER_FONTS_FALLBACK_ATTR, "");
+  fallback.textContent = afterFontsFallback();
+  document.head.insertBefore(fallback, document.head.firstChild);
+}
+function cssStyleMergeKey(el) {
+  const rawType = el.getAttribute("type") ?? "";
+  const type = el.tagName.toLowerCase() === "link" ? rawType.split(";")[0].trim() : rawType;
+  if (type !== "" && type.toLowerCase() !== "text/css")
+    return void 0;
+  const media = (el.getAttribute("media") ?? "").trim().toLowerCase();
+  return JSON.stringify([media === "all" ? "" : media, el.getAttribute("title") ?? ""]);
+}
+var UNCONDITIONAL_CSS_KEY = JSON.stringify(["", ""]);
+function linkDedupeKey(el) {
+  return JSON.stringify([
+    el.getAttribute("href"),
+    (el.getAttribute("rel") ?? "").trim().toLowerCase(),
+    cssStyleMergeKey(el) ?? el.getAttribute("type"),
+    el.hasAttribute("disabled")
+  ]);
+}
+function hasSameLink(scope, link) {
+  const key = linkDedupeKey(link);
+  return [...scope.querySelectorAll("link[href]")].some((other) => !other.closest("noscript") && linkDedupeKey(other) === key);
+}
+function headStyleRuns(styles, isPinned = () => false) {
+  const runs = [];
+  let previousKey;
+  for (const el of styles) {
+    const key = isPinned(el) ? void 0 : cssStyleMergeKey(el);
+    if (key !== void 0 && key === previousKey)
+      runs.at(-1).push(el);
+    else if (key !== void 0)
+      runs.push([el]);
+    previousKey = key;
+  }
+  return runs;
+}
+function compositionStyle(el, css) {
+  return { css, media: el.getAttribute("media"), title: el.getAttribute("title") };
+}
+function styleElementsFor(document, sheets, join) {
+  const elements = sheets.map(({ css, media, title }) => {
+    const el = document.createElement("style");
+    if (media !== null)
+      el.setAttribute("media", media);
+    if (title !== null)
+      el.setAttribute("title", title);
+    el.textContent = css;
+    return el;
+  });
+  return headStyleRuns(elements).map((run) => {
+    run[0].textContent = join(run.map((el) => el.textContent || ""));
+    return run[0];
+  });
+}
+
+// ../core/dist/sceneParts.js
+var SCENE_PART_ATTR = "data-hf-scene";
+var SCENE_PARTS_META = "hf-scene-parts";
+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
+var rebaseEntries = (entries, rebase) => entries && Object.fromEntries(Object.entries(entries).map(([specifier, url]) => [specifier, rebase(url)]));
+function parseImportMap(json, rebase) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const { imports, scopes } = parsed;
+  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 (!(specifier in into))
+      into[specifier] = url;
+    else if (into[specifier] !== url) {
+      console.warn(`[HyperFrames] 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("[HyperFrames] 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 ?? {})) {
+      mergeEntries(scopes[prefix] ??= {}, 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 { resolve as resolve2, relative, dirname, isAbsolute, sep } from "path";
+import { transformSync } from "esbuild";
+
+// ../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 || next === "\n")
+    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 decodeCssIdentifierAt(text, start) {
+  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])|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\[(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^\]"'])*\]/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;
+}
+
+// ../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 escapeCssAttributeValue(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}="${escapeCssAttributeValue(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}="${escapeCssAttributeValue(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="${escapeCssAttributeValue(trimmedCompositionId)}"]`;
+  let root;
+  try {
+    root = postcss.parse(css);
+  } catch {
+    return "";
+  }
+  root.walkRules((rule) => {
+    if (isInsideGlobalAtRule(rule))
+      return;
+    if (isNestedInsideAnotherRule(rule))
+      return;
+    rule.selectors = rule.selectors.map((selector) => scopeSelector(selector, scope, trimmedCompositionId, authoredRootId, options?.compoundAuthoredRoot, options?.scopeRootSelectors));
+  });
+  return root.toResult({ map: false }).css;
+}
+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(";");
+}
+function dedupeFontFaceRules(styleTexts) {
+  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)) {
+        node.remove();
+        changed = true;
+      } else {
+        seen.add(key);
+      }
+    }
+    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 = "[HyperFrames] 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*\]`);
+  return `(function(){
+  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 __hfCssEscape = function(value) {
+    var text = value + "";
+    if (typeof CSS !== "undefined" && CSS && typeof CSS.escape === "function") {
+      try { return CSS.escape(text); } catch {}
+    }
+    return text.replace(/[^a-zA-Z0-9_-]/g, function(char) { return "\\\\" + char; });
+  };
+  // Decode complete CSS identifiers before comparing authored ids.
+  var __hfRewriteIdSelectors = function(selector, entries) {
+    if (!entries || !entries.length || typeof selector !== "string" || selector.indexOf("#") === -1) {
+      return selector;
+    }
+    var result = "";
+    var bracketDepth = 0;
+    var quote = null;
+    for (var index = 0; index < selector.length; index += 1) {
+      var char = selector[index];
+      if (char === "\\\\") {
+        var escape = selector.slice(index).match(/^\\\\(?:[0-9a-fA-F]{1,6}(?:\\r\\n|[ \\t\\r\\n\\f])?|[\\s\\S])/);
+        if (escape) {
+          result += escape[0];
+          index += escape[0].length - 1;
+          continue;
+        }
+      }
+      if (quote) {
+        result += char;
+        if (char === quote) {
+          quote = null;
+        }
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        result += char;
+        continue;
+      }
+      if (char === "[") {
+        bracketDepth += 1;
+        result += char;
+        continue;
+      }
+      if (char === "]") {
+        bracketDepth = Math.max(0, bracketDepth - 1);
+        result += char;
+        continue;
+      }
+      if (char === "#" && bracketDepth === 0) {
+        var token = selector.slice(index + 1).match(/^(?:[\\w\\u0080-\\uffff-]|\\\\(?:[0-9a-fA-F]{1,6}(?:\\r\\n|[ \\t\\r\\n\\f])?|[^\\r\\n\\f]))+/);
+        if (token) {
+          var decoded = token[0].replace(/\\\\([0-9a-fA-F]{1,6})(?:\\r\\n|[ \\t\\r\\n\\f])?|\\\\([^\\r\\n\\f])/g, function(_, hex, escaped) {
+            if (!hex) return escaped;
+            var code = parseInt(hex, 16);
+            return String.fromCodePoint(!code || code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff) ? 0xfffd : code);
+          });
+          var matched = entries.find(function(entry) { return entry.id === decoded; });
+          result += matched ? matched.replacement : "#" + token[0];
+          index += token[0].length;
+          continue;
+        }
+      }
+      result += char;
+    }
+    return result;
+  };
+  var __hfAuthoredRootEntries = __hfAuthoredRootSelector
+    ? [{ id: __hfAuthoredRootId, replacement: __hfAuthoredRootSelector }]
+    : [];
+  // Include both renamed and untouched instances. Each wrapper refreshes this
+  // document-wide cache because preview scene swaps can introduce new ids.
+  var __hfRenamedIdEntries = function() {
+    if (window.__hfRenamedIdSelectorEntries) return window.__hfRenamedIdSelectorEntries;
+    var entries = [];
+    var seen = Object.create(null);
+    var nodes;
+    try {
+      nodes = window.document.querySelectorAll("[" + __hfAuthoredRootAttr + "][id]");
+    } catch {
+      nodes = [];
+    }
+    for (var i = 0; i < nodes.length; i += 1) {
+      var authored = nodes[i].getAttribute(__hfAuthoredRootAttr);
+      if (!authored || seen[authored] || authored === nodes[i].id) continue;
+      seen[authored] = true;
+      var escaped = __hfCssEscape(authored);
+      entries.push({
+        id: authored,
+        replacement: ":is(#" + escaped + ", [" + __hfAuthoredRootAttr + '="' + __hfEscapeAttr(authored) + '"])',
+      });
+    }
+    window.__hfRenamedIdSelectorEntries = entries;
+    return window.__hfRenamedIdSelectorEntries;
+  };
+  // element.querySelector("#authored") on an arbitrary Element never passes
+  // through the scoped document proxy, so the same rewrite is installed once
+  // per document on Element.prototype \u2014 only when at least one id was
+  // actually renamed, so a document without collisions runs untouched
+  // natives. Document.prototype is deliberately NOT patched: an unscoped
+  // document-wide lookup cannot know which instance it means, and rewriting
+  // it would only widen the ambiguity.
+  var __hfInstallRenamedIdSelectorShim = function() {
+    if (window.__hfRenamedIdSelectorShim) return;
+    var entries = __hfRenamedIdEntries();
+    if (!entries.length) return;
+    var proto = window.Element && window.Element.prototype;
+    if (!proto || typeof proto.querySelector !== "function" || typeof proto.querySelectorAll !== "function") {
+      return;
+    }
+    var nativeQuerySelector = proto.querySelector;
+    var nativeQuerySelectorAll = proto.querySelectorAll;
+    proto.querySelector = function(selector) {
+      return nativeQuerySelector.call(this, __hfRewriteIdSelectors(selector, __hfRenamedIdEntries()));
+    };
+    proto.querySelectorAll = function(selector) {
+      return nativeQuerySelectorAll.call(this, __hfRewriteIdSelectors(selector, __hfRenamedIdEntries()));
+    };
+    window.__hfRenamedIdSelectorShim = true;
+  };
+  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);
+    normalized = __hfRewriteIdSelectors(normalized, __hfAuthoredRootEntries);
+    return __hfRewriteIdSelectors(normalized, __hfRenamedIdEntries());
+  };
+  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 authoredValue = Reflect.get(target, prop, target);
+          return authoredValue === undefined
+            ? Reflect.get(target, __hfTimelineCompId, target)
+            : authoredValue;
+        },
+        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
+          // instead of replacing one with the other.
+          var authoredSet = Reflect.set(target, __hfCompId, value, target);
+          var runtimeSet = Reflect.set(target, __hfTimelineCompId, value, target);
+          return authoredSet && 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") return __hfQueryAll(target);
+    if (!Array.isArray(target)) return target;
+    return target.reduce(function(resolved, item) {
+      if (typeof item === "string") {
+        return resolved.concat(Array.prototype.slice.call(__hfQueryAll(item)));
+      }
+      resolved.push(item);
+      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() {
+    try {
+      (function(document, gsap, window, __hyperframes) {
+${source.replace(/<\/(script)/gi, "<\\/$1")}
+      }).call(window, __hfScopedDocument, __hfScopedGsap, __hfScopedWindow, __hfScopedHyperframes);
+    } catch (_err) {
+      console.error(__hfErrorLabel, __hfCompId, _err);
+    }
+  };
+  // 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();
+  window.__hfRenamedIdSelectorEntries = null;
+  __hfInstallRenamedIdSelectorShim();
+  __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/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 rewriteHrefValue(value, idMap) {
+  if (!value.startsWith("#"))
+    return null;
+  const mapped = idMap.get(value.slice(1));
+  return mapped ? `#${mapped}` : null;
+}
+function rewriteElementIdReferences(el, idMap) {
+  const attrs = el.attributes ? Array.from(el.attributes) : [];
+  for (const attr of attrs) {
+    const { name, value } = attr;
+    if (!value)
+      continue;
+    if (isHrefAttrName(name)) {
+      const rewritten = rewriteHrefValue(value, idMap);
+      if (rewritten) {
+        el.setAttribute(name, rewritten);
+        continue;
+      }
+    }
+    if (value.toLowerCase().includes("url(")) {
+      const rewritten = rewriteUrlHashRefs(value, idMap);
+      if (rewritten !== value)
+        el.setAttribute(name, rewritten);
+    }
+  }
+}
+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)
+        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 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]);
+  }
+  return { elementsById, usedIds };
+}
+function hasAnyCollision(census) {
+  for (const elements of census.elementsById.values()) {
+    if (elements.length > 1)
+      return true;
+  }
+  return false;
+}
+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 planRenames(census, scopes, scopeIndexByRenamable) {
+  const idMaps = scopes.map(() => /* @__PURE__ */ new Map());
+  for (const [id, elements] of census.elementsById) {
+    if (elements.length < 2)
+      continue;
+    const keeper = elements.find((el) => !scopeIndexByRenamable.has(el)) ?? elements[0];
+    for (const el of elements) {
+      if (el === keeper)
+        continue;
+      const scopeIndex = scopeIndexByRenamable.get(el);
+      if (scopeIndex === void 0)
+        continue;
+      const idMap = idMaps[scopeIndex];
+      if (!idMap.has(id)) {
+        idMap.set(id, mintNamespacedId(scopes[scopeIndex].namespace, id, census.usedIds));
+      }
+    }
+  }
+  return idMaps;
+}
+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);
+      el.setAttribute(ID_ATTR, idMap.get(currentId));
+    }
+    rewriteElementIdReferences(el, idMap);
+  }
+}
+function namespaceCollidingSvgIds(document, scopes) {
+  const untouched = scopes.map(() => /* @__PURE__ */ new Map());
+  if (scopes.length === 0)
+    return untouched;
+  const census = buildIdCensus(document);
+  if (!hasAnyCollision(census))
+    return untouched;
+  const resolved = scopes.map(resolveScope);
+  const scopeIndexByRenamable = /* @__PURE__ */ new Map();
+  resolved.forEach(({ renamable }, index) => {
+    for (const el of renamable)
+      scopeIndexByRenamable.set(el, index);
+  });
+  if (scopeIndexByRenamable.size === 0)
+    return untouched;
+  const idMaps = planRenames(census, scopes, scopeIndexByRenamable);
+  const referenceMaps = resolved.map((scope, index) => {
+    const references = new Map(idMaps[index]);
+    const localIds = new Set(scope.elements.map((el) => el.getAttribute(ID_ATTR)));
+    for (const [id, elements] of census.elementsById) {
+      if (localIds.has(id))
+        continue;
+      const targetScope = scopeIndexByRenamable.get(elements[0]);
+      if (targetScope === void 0)
+        continue;
+      const mapped = idMaps[targetScope].get(id);
+      if (mapped)
+        references.set(id, mapped);
+    }
+    return references;
+  });
+  referenceMaps.forEach((idMap, index) => {
+    if (idMap.size > 0)
+      applyRenames(resolved[index], idMap);
+  });
+  return referenceMaps;
+}
+function renameIdTokensInSelector(selector, idMap) {
+  return replaceSelectorIdTokens(selector, [...idMap.keys()], (matchedId) => `#${escapeCssIdentifier(idMap.get(matchedId))}`);
+}
+function rewriteSvgIdReferencesInCss(css, idMap) {
+  if (!css || idMap.size === 0)
+    return css;
+  if (!css.includes("#") && !css.toLowerCase().includes("url("))
+    return css;
+  let root;
+  try {
+    root = postcss2.parse(css);
+  } catch {
+    return css;
+  }
+  let mutated = false;
+  root.walkRules((rule) => {
+    const rewritten = rule.selectors.map((selector) => renameIdTokensInSelector(selector, idMap));
+    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/compositionAssembly.js
+var COMPOSITION_ID_ATTR = "data-composition-id";
+var COMPOSITION_SRC_ATTR = "data-composition-src";
+var COMPOSITION_ROOT_SELECTOR = `[${COMPOSITION_ID_ATTR}]`;
+var COMPOSITION_HOST_SELECTOR = `[${COMPOSITION_SRC_ATTR}]`;
+var STYLE_SELECTOR = "style";
+var SCRIPT_SELECTOR = "script";
+var HOISTED_LINK_SELECTOR = 'link[rel="stylesheet"], link[rel="preconnect"]';
+var EXTRACTED_COMPOSITION_ASSET_SELECTOR = `${STYLE_SELECTOR}, ${SCRIPT_SELECTOR}, ${HOISTED_LINK_SELECTOR}`;
+var MAX_SUB_COMPOSITION_DEPTH = 20;
+function toArray(items) {
+  return items ? Array.from(items) : [];
+}
+function planCompositionAssembly(input) {
+  const { contentNode, head, documentElement, hasTemplate, compositionId } = input;
+  const compositionRoots = toArray(contentNode.querySelectorAll(COMPOSITION_ROOT_SELECTOR));
+  const innerRoot = compositionId ? compositionRoots.find((root) => root.getAttribute(COMPOSITION_ID_ATTR) === compositionId) ?? null : compositionRoots[0] ?? null;
+  const declaredCompositionId = (innerRoot ?? compositionRoots[0])?.getAttribute(COMPOSITION_ID_ATTR)?.trim() || "";
+  const assetHead = hasTemplate ? null : head ?? null;
+  return {
+    innerRoot,
+    authoredCompositionId: compositionId || declaredCompositionId || null,
+    scriptCompositionId: declaredCompositionId || compositionId || null,
+    authoredRootId: innerRoot?.getAttribute("id")?.trim() || null,
+    styleSources: [
+      ...toArray(assetHead?.querySelectorAll(STYLE_SELECTOR)),
+      ...toArray(contentNode.querySelectorAll(STYLE_SELECTOR))
+    ],
+    scriptSources: [
+      ...toArray(assetHead?.querySelectorAll(SCRIPT_SELECTOR)),
+      ...toArray(contentNode.querySelectorAll(SCRIPT_SELECTOR))
+    ],
+    linkSources: [
+      ...toArray(head?.querySelectorAll(HOISTED_LINK_SELECTOR)),
+      ...toArray(contentNode.querySelectorAll(HOISTED_LINK_SELECTOR))
+    ],
+    variableDefaultCarriers: [documentElement, innerRoot].filter((carrier) => carrier != null)
+  };
+}
+function enumerateNestedCompositionHosts(assembledHost, ancestry) {
+  const hosts = [];
+  const skipped = [];
+  for (const nestedHost of assembledHost.querySelectorAll(COMPOSITION_HOST_SELECTOR)) {
+    const src = nestedHost.getAttribute(COMPOSITION_SRC_ATTR);
+    if (!src)
+      continue;
+    if (ancestry.includes(src)) {
+      skipped.push({ src, reason: "circular composition reference" });
+      continue;
+    }
+    if (ancestry.length >= MAX_SUB_COMPOSITION_DEPTH) {
+      skipped.push({ src, reason: "nesting depth exceeded" });
+      continue;
+    }
+    hosts.push({ host: nestedHost, src });
+  }
+  return { hosts, skipped };
+}
+
+// ../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);
+}
+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 = "[HyperFrames] composition script error:", onMissingComposition, assetExists, tagScenes = false } = options;
+  const styles = [];
+  const styleScenes = [];
+  const scripts = [];
+  const externalScriptSrcs = [];
+  const scriptItems = [];
+  const importMaps = [];
+  const moduleScripts = [];
+  const externalLinks = [];
+  const variablesByComp = {};
+  const svgIdScopes = [];
+  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);
+    const validity = checkSubCompositionUsability(compHtml, parseHtml);
+    if (!validity.ok) {
+      onMissingComposition?.(src, validity.detail);
+      continue;
+    }
+    if (compHtml == null) {
+      onMissingComposition?.(src);
+      continue;
+    }
+    const compDoc = parseHtml(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 = parseHtml(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 css = rewriteCssAssetUrls(raw, src, assetExists);
+      return scopeCompId ? scopeCssToComposition(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(`[HyperFrames] ${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 [...innerRoot.querySelectorAll(EXTRACTED_COMPOSITION_ASSET_SELECTOR)])
+        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 [...contentDoc.querySelectorAll(EXTRACTED_COMPOSITION_ASSET_SELECTOR)])
+        child.remove();
+      const bodyHtml = contentDoc.body?.innerHTML || "";
+      hostEl.innerHTML = bodyHtml || contentDoc.documentElement?.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)
+  })));
+  svgIdMaps.forEach((idMap, index) => {
+    if (idMap.size === 0)
+      return;
+    const { styleStart, styleEnd } = svgIdScopes[index];
+    for (let i = styleStart; i < styleEnd; i += 1) {
+      styles[i].css = rewriteSvgIdReferencesInCss(styles[i].css, idMap);
+    }
+  });
+  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 wrapped = !/<!doctype|<html[\s>]/i.test(html);
+  const { document } = wrapped ? parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`) : parseHTML(html);
+  if (!document.body) return html;
+  assignHfIds(document.body);
+  return wrapped ? document.body.innerHTML || "" : document.toString();
+}
+
+// ../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 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) => {
+    if (!urlValue || !isRelativeUrl(urlValue))
+      return full;
+    const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
+    if (!basePath)
+      return full;
+    const absolutePath = resolve2(resolvedDir, basePath);
+    const rebased = relative(resolvedRoot, absolutePath).split(sep).join("/");
+    if (rebased === basePath)
+      return full;
+    return `url(${quote || ""}${rebased}${suffix}${quote || ""})`;
+  });
+}
+function rebaseRelativePath(urlValue, fromDir, toDir) {
+  const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
+  if (!basePath)
+    return urlValue;
+  const absolutePath = resolve2(fromDir, basePath);
+  const rebased = relative(resolve2(toDir), absolutePath).split(sep).join("/");
+  return appendSuffixToUrl(rebased, suffix);
+}
+function rebaseSrcsetPaths(srcsetValue, fromDir, toDir) {
+  if (!srcsetValue)
+    return srcsetValue;
+  return srcsetValue.split(",").map((rawCandidate) => {
+    const candidate = rawCandidate.trim();
+    if (!candidate)
+      return candidate;
+    const parts = candidate.split(/\s+/);
+    const first = parts[0] ?? "";
+    if (parts.length === 0 || !isRelativeUrl(first))
+      return candidate;
+    parts[0] = rebaseRelativePath(first, fromDir, toDir);
+    return parts.join(" ");
+  }).join(", ");
+}
+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", rebaseSrcsetPaths(srcset, sourceDir, projectDir));
+  }
+  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, visited = /* @__PURE__ */ new Set()) {
+  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, importPath);
+    if (!isSafePath(projectDir, resolved))
+      return full;
+    if (visited.has(resolved))
+      return "";
+    const content = safeReadFile(resolved);
+    if (content == null)
+      return full;
+    visited.add(resolved);
+    const inlined = inlineCssFile(content, dirname(resolved), projectDir, visited);
+    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 splitUrlSuffix(urlValue) {
+  const queryIdx = urlValue.indexOf("?");
+  const hashIdx = urlValue.indexOf("#");
+  if (queryIdx < 0 && hashIdx < 0)
+    return { basePath: urlValue, suffix: "" };
+  const cutIdx = queryIdx < 0 ? hashIdx : hashIdx < 0 ? queryIdx : Math.min(queryIdx, hashIdx);
+  return { basePath: urlValue.slice(0, cutIdx), suffix: urlValue.slice(cutIdx) };
+}
+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;
+function safeStatSize(filePath) {
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return null;
+  }
+}
+function warnAssetTooLargeToInline(assetPath, byteLength) {
+  const mb = (byteLength / (1024 * 1024)).toFixed(1);
+  console.warn(`[HyperFrames] Not inlining "${assetPath}" (${mb} MB exceeds the ${MAX_INLINE_ASSET_BYTES / (1024 * 1024)} MB inline limit). The bundle may not be self-contained.`);
+}
+function maybeInlineRelativeAssetUrl(urlValue, projectDir, inlineAssets) {
+  if (!inlineAssets)
+    return null;
+  if (!urlValue || !isRelativeUrl(urlValue))
+    return null;
+  const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
+  if (!basePath)
+    return null;
+  const filePath = resolveWithinProject(projectDir, basePath);
+  if (!filePath)
+    return null;
+  const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0] ?? "";
+  const mimeType = INLINE_MIME[ext];
+  if (!mimeType)
+    return null;
+  const byteLength = safeStatSize(filePath);
+  if (byteLength !== null && byteLength > MAX_INLINE_ASSET_BYTES) {
+    warnAssetTooLargeToInline(basePath, byteLength);
+    return null;
+  }
+  const content = safeReadFileBuffer(filePath);
+  if (content == null)
+    return null;
+  const dataUrl = `data:${mimeType};base64,${content.toString("base64")}`;
+  return appendSuffixToUrl(dataUrl, suffix);
+}
+function 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(`[HyperFrames] Could not inline color grading LUT "${trimmed}". The rendered bundle may not be self-contained.`);
+}
+function rewriteColorGradingLutWithInlinedAssets(value, projectDir) {
+  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 = maybeInlineRelativeAssetUrl(lut, projectDir, true);
+    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 = maybeInlineRelativeAssetUrl(lutSrc, projectDir, true);
+  if (!inlined) {
+    warnColorGradingLutNotInlined(lutSrc);
+    return value;
+  }
+  Reflect.set(lut, "src", inlined);
+  return JSON.stringify(parsed);
+}
+function rewriteSrcsetWithInlinedAssets(srcsetValue, projectDir, inlineAssets) {
+  if (!srcsetValue)
+    return srcsetValue;
+  return srcsetValue.split(",").map((rawCandidate) => {
+    const candidate = rawCandidate.trim();
+    if (!candidate)
+      return candidate;
+    const parts = candidate.split(/\s+/);
+    if (parts.length === 0)
+      return candidate;
+    const maybeInlined = maybeInlineRelativeAssetUrl(parts[0] ?? "", projectDir, inlineAssets);
+    if (maybeInlined)
+      parts[0] = maybeInlined;
+    return parts.join(" ");
+  }).join(", ");
+}
+function rewriteCssUrlsWithInlinedAssets(cssText, projectDir, inlineAssets) {
+  if (!cssText)
+    return cssText;
+  return cssText.replace(/\burl\(\s*(["']?)([^)"']+)\1\s*\)/g, (_full, quote, rawUrl) => {
+    const maybeInlined = maybeInlineRelativeAssetUrl((rawUrl || "").trim(), projectDir, inlineAssets);
+    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);
+  }
+  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] });
+}
+function coalesceHeadStylesAndBodyScripts(document) {
+  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 || ""));
+    for (const el of members)
+      el.remove();
+    if (!mergedJs)
+      continue;
+    const inlineScript = document.createElement("script");
+    inlineScript.textContent = escapeInlineScriptSource(stripJsCommentsParserSafe(mergedJs));
+    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 stripJsCommentsParserSafe(source) {
+  if (!source)
+    return source;
+  try {
+    const result = transformSync(source, { loader: "js", minify: false, legalComments: "none" });
+    return result.code.trim();
+  } catch {
+    return source;
+  }
+}
+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, src);
+    const js = jsPath ? safeReadFile(jsPath) : null;
+    if (js != null) {
+      chunks.push(() => preserveLocalScriptIntegrity(doc, src, (value) => resolveWithinProject(projectDir, value)) ? "" : js);
+      return;
+    }
+  }
+  ensureExternalScriptTag(doc, src, attributes);
+}
+function hoistCompositionScripts(container, opts) {
+  for (const scriptEl of [...container.querySelectorAll("script")]) {
+    const externalSrc = (scriptEl.getAttribute("src") || "").trim();
+    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, "[HyperFrames] composition script error:", opts.runtimeScope, opts.runtimeCompId || opts.compId, opts.authoredRootId) : wrapInlineScriptWithErrorBoundary(scriptEl.textContent || "", "[HyperFrames] composition script error:"));
+    }
+    scriptEl.remove();
+  }
+}
+function bundleToSingleHtml(projectDir, options) {
+  const bundle = () => bundleProject(projectDir, options);
+  return options?.onRead ? bundleReads.run(options.onRead, bundle) : bundle();
+}
+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`);
+  }
+  const sourceDir = dirname(indexPath);
+  const resolveEntryPath = (relativePath) => {
+    const resolved = resolve2(sourceDir, relativePath);
+    return isSafePath(projectDir, resolved) ? resolved : null;
+  };
+  const readSource = options?.stampHfIds ? ensureHfIds : (html) => html;
+  noteRead(indexPath);
+  const rawHtml = readSource(readFileSync(indexPath, "utf-8"));
+  const compiled = await compileHtml(rawHtml, sourceDir, options?.probeMediaDuration);
+  if (options?.staticGuard !== false) {
+    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 = resolveEntryPath(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);
+    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) ? resolveEntryPath(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 subCompResult = inlineSubCompositions(document, subCompositionHosts, {
+    resolveHtml: (srcPath) => {
+      if (!isRelativeUrl(srcPath))
+        return null;
+      const compPath = resolveEntryPath(srcPath);
+      const html = compPath ? safeReadFile(compPath) : null;
+      return html === null ? null : readSource(html);
+    },
+    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: "[HyperFrames] 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 = resolveEntryPath(extSrc);
+      const js = jsPath ? safeReadFile(jsPath) : null;
+      if (js != null) {
+        const chunk = () => preserveLocalScriptIntegrity(document, extSrc, resolveEntryPath) ? "" : 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 innerRoot = queryByAttr(innerDoc, "data-composition-id", compId);
+      const authoredRootId = innerRoot?.getAttribute("id")?.trim() || null;
+      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
+        });
+        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
+        });
+        host.innerHTML = innerDoc.body.innerHTML || "";
+      }
+    }
+    templateEl.remove();
+  }
+  for (const el of [...document.querySelectorAll("script[src]")]) {
+    const src = el.getAttribute("src");
+    if (!src || !isRelativeUrl(src))
+      continue;
+    if (preserveLocalScriptIntegrity(document, src, resolveEntryPath))
+      continue;
+    if ((el.getAttribute("type") || "").trim().toLowerCase() === "module")
+      continue;
+    const jsPath = resolveEntryPath(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 script = document.createElement("script");
+    if (scene)
+      script.setAttribute(SCENE_PART_ATTR, scene);
+    script.textContent = joinJsChunks(chunks.map((chunk) => typeof chunk === "string" ? chunk : chunk()));
+    document.body.appendChild(script);
+  }
+  emitMountedModuleScripts(document, subCompResult.importMaps, subCompResult.moduleScripts);
+  emitRootCompositionVariableStyles(document, compVariablesByComp);
+  enforceCompositionPixelSizing(document);
+  autoHealMissingCompositionIds(document);
+  coalesceHeadStylesAndBodyScripts(document);
+  for (const el of document.querySelectorAll(`script[${INLINED_FILE_ATTR}]`)) {
+    const js = el.textContent ?? "";
+    el.textContent = escapeInlineScriptSource(isJavaScriptType(el) ? stripJsCommentsParserSafe(js) : js);
+  }
+  deferScriptsUntilFonts(document, (el) => el.hasAttribute(RUNTIME_BOOTSTRAP_ATTR));
+  injectTextRenderingRule(document);
+  const inlineAssets = options?.inlineAssets !== false;
+  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 = maybeInlineRelativeAssetUrl(value, projectDir, inlineAssets);
+      if (inlined)
+        el.setAttribute(attr, inlined);
+    }
+  }
+  for (const el of [...document.querySelectorAll("[srcset]")]) {
+    const srcset = el.getAttribute("srcset");
+    if (srcset)
+      el.setAttribute("srcset", rewriteSrcsetWithInlinedAssets(srcset, projectDir, inlineAssets));
+  }
+  if (!options?.sceneParts) {
+    const liveStyles = [...document.querySelectorAll("style")].filter(isAlwaysAppliedStyle);
+    const dedupedStyles = dedupeFontFaceRules(liveStyles.map((el) => el.textContent || ""));
+    liveStyles.forEach((el, i) => {
+      el.textContent = dedupedStyles[i] ?? "";
+    });
+  }
+  for (const styleEl of document.querySelectorAll("style")) {
+    styleEl.textContent = rewriteCssUrlsWithInlinedAssets(styleEl.textContent || "", projectDir, inlineAssets);
+  }
+  for (const el of [...document.querySelectorAll("[style]")]) {
+    el.setAttribute("style", rewriteCssUrlsWithInlinedAssets(el.getAttribute("style") || "", projectDir, inlineAssets));
+  }
+  if (inlineAssets && options?.inlineColorGradingLuts !== false) {
+    for (const el of [...document.querySelectorAll(`[${HF_COLOR_GRADING_ATTR}]`)]) {
+      const value = el.getAttribute(HF_COLOR_GRADING_ATTR);
+      if (value) {
+        el.setAttribute(HF_COLOR_GRADING_ATTR, rewriteColorGradingLutWithInlinedAssets(value, projectDir));
+      }
+    }
+  }
+  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");
+  return (id) => new RegExp(`${cssVariableName(id)}\\s*:`).test(authoredCss);
+}
+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" && /hyperframes|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 } from "crypto";
+var hash = (text) => createHash("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.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,
+  inlineScriptRuns,
+  AFTER_FONTS_SCRIPT_TYPE,
+  deferScriptsUntilFonts,
+  cssStyleMergeKey,
+  headStyleRuns,
+  compositionStyle,
+  styleElementsFor,
+  ensureExternalScriptTag,
+  emitMountedModuleScripts,
+  FLATTENED_INNER_ROOT_STRIP_ATTRS,
+  scopeCssToComposition,
+  wrapScopedCompositionScript,
+  buildVariablesByCompScript,
+  validateHyperframeHtmlContract,
+  ensureExternalLinkTag,
+  inlineSubCompositions,
+  EXCLUDED_TAGS,
+  mintHfId,
+  walkCompositionDescendants,
+  ensureHfIds,
+  assignBundledRuntimeCompositionIds,
+  prepareFlattenedInnerRoot,
+  bundleToSingleHtml,
+  emitRootCompositionVariableStyles,
+  extractCompiledHtmlParityContract,
+  addScenePartsManifest
+};