npm - hyperframes - Versions diffs - 0.4.12 → 0.4.13-alpha.1 - Mend

hyperframes 0.4.12 → 0.4.13-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/cli.js +4259 -24
package/dist/hyperframe-runtime.js +3 -3
package/dist/hyperframe.manifest.json +1 -1
package/dist/hyperframe.runtime.iife.js +3 -3
package/dist/studio/assets/hyperframes-player-BOs_kypk.js +198 -0
package/dist/studio/assets/index-BKkR67xb.css +1 -0
package/dist/studio/assets/index-rN5doSq1.js +93 -0
package/dist/studio/index.html +2 -2
package/package.json +1 -1
package/dist/studio/assets/hyperframes-player-5iD9BZnx.js +0 -198
package/dist/studio/assets/index-CVDXfFQ6.js +0 -93
package/dist/studio/assets/index-jmDaI2F7.css +0 -1

package/dist/cli.js CHANGED Viewed

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.12" : "0.0.0-dev";
+    VERSION = true ? "0.4.13-alpha.1" : "0.0.0-dev";
   }
 });
@@ -2291,13 +2291,82 @@ var init_banner = __esm({
 });
 // ../core/src/core.types.ts
+function isStringVariable(v) {
+  return v.type === "string";
+}
+function isNumberVariable(v) {
+  return v.type === "number";
+}
+function isColorVariable(v) {
+  return v.type === "color";
+}
+function isBooleanVariable(v) {
+  return v.type === "boolean";
+}
+function isEnumVariable(v) {
+  return v.type === "enum";
+}
+function isTextElement(el) {
+  return el.type === "text";
+}
+function isMediaElement(el) {
+  return el.type === "video" || el.type === "image" || el.type === "audio";
+}
+function isCompositionElement(el) {
+  return el.type === "composition";
+}
+function getDefaultStageZoom(resolution) {
+  const { width, height } = CANVAS_DIMENSIONS[resolution];
+  return {
+    scale: 1,
+    focusX: width / 2,
+    focusY: height / 2
+  };
+}
+var CANVAS_DIMENSIONS, TIMELINE_COLORS, DEFAULT_DURATIONS;
 var init_core_types = __esm({
   "../core/src/core.types.ts"() {
     "use strict";
+    CANVAS_DIMENSIONS = {
+      landscape: { width: 1920, height: 1080 },
+      portrait: { width: 1080, height: 1920 }
+    };
+    TIMELINE_COLORS = {
+      video: "#ec4899",
+      image: "#3b82f6",
+      text: "#06b6d4",
+      audio: "#10b981",
+      composition: "#f97316"
+    };
+    DEFAULT_DURATIONS = {
+      video: 5,
+      image: 5,
+      text: 2,
+      audio: 5,
+      composition: 5
+    };
   }
 });
 // ../core/src/templates/base.ts
+function generateBaseHtml(resolution = "portrait") {
+  return `<!DOCTYPE html>
+<html data-resolution="${resolution}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body>
+  <div id="stage">
+    <div id="stage-zoom-container"></div>
+  </div>
+</body>
+</html>`;
+}
+function getStageStyles(resolution = "portrait") {
+  const { width, height } = CANVAS_DIMENSIONS[resolution];
+  return `position: relative; width: ${width}px; height: ${height}px; overflow: hidden; background: #000;`;
+}
 var init_base = __esm({
   "../core/src/templates/base.ts"() {
     "use strict";
@@ -2306,9 +2375,17 @@ var init_base = __esm({
 });
 // ../core/src/templates/constants.ts
+var GSAP_CDN, BASE_STYLES, ELEMENT_BASE_STYLES, MEDIA_STYLES, TEXT_STYLES, ZOOM_CONTAINER_STYLES;
 var init_constants = __esm({
   "../core/src/templates/constants.ts"() {
     "use strict";
+    GSAP_CDN = "https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/gsap.min.js";
+    BASE_STYLES = `* { margin: 0; padding: 0; box-sizing: border-box; }
+html, body { width: 100%; height: 100%; overflow: hidden; background: #000; display: flex; align-items: center; justify-content: center; }`;
+    ELEMENT_BASE_STYLES = `position: absolute; visibility: hidden;`;
+    MEDIA_STYLES = `width: 100%; height: 100%; object-fit: contain;`;
+    TEXT_STYLES = `display: flex; align-items: center; justify-content: center; font-family: system-ui, -apple-system, sans-serif; font-size: 48px; font-weight: bold; color: white; text-shadow: 2px 2px 4px rgba(0,0,0,0.8); width: 100%; height: 100%;`;
+    ZOOM_CONTAINER_STYLES = `position: absolute; inset: 0; transform-origin: 0 0;`;
   }
 });
@@ -2440,10 +2517,145 @@ function parseGsapCall(method, argsStr, idNum) {
     ease
   };
 }
+function serializeGsapAnimations(animations, timelineVar = "tl", options) {
+  const sorted = [...animations].sort((a, b) => a.position - b.position);
+  const lines = sorted.map((anim) => {
+    const selector = `"${anim.targetSelector}"`;
+    const props = { ...anim.properties };
+    if (anim.duration !== void 0) props.duration = anim.duration;
+    if (anim.ease) props.ease = anim.ease;
+    const propsStr = serializeObject(props);
+    switch (anim.method) {
+      case "set":
+        return `    ${timelineVar}.set(${selector}, ${propsStr}, ${anim.position});`;
+      case "to":
+        return `    ${timelineVar}.to(${selector}, ${propsStr}, ${anim.position});`;
+      case "from":
+        return `    ${timelineVar}.from(${selector}, ${propsStr}, ${anim.position});`;
+      case "fromTo": {
+        const fromStr = serializeObject(anim.fromProperties || {});
+        return `    ${timelineVar}.fromTo(${selector}, ${fromStr}, ${propsStr}, ${anim.position});`;
+      }
+    }
+  });
+  let mediaSync = "";
+  if (options?.includeMediaSync) {
+    mediaSync = `
+    // Sync media playback
+    ${timelineVar}.eventCallback("onUpdate", function() {
+      const time = ${timelineVar}.time();
+      document.querySelectorAll("video[data-start], audio[data-start]").forEach(function(media) {
+        const start = parseFloat(media.dataset.start);
+        const end = parseFloat(media.dataset.end) || Infinity;
+        const mediaTime = time - start;
+        if (time >= start && time < end) {
+          if (Math.abs(media.currentTime - mediaTime) > 0.1) {
+            media.currentTime = mediaTime;
+          }
+          if (media.paused && !${timelineVar}.paused()) {
+            media.play().catch(function() {});
+          }
+        } else if (!media.paused) {
+          media.pause();
+        }
+      });
+    });`;
+  }
+  return `
+    const ${timelineVar} = gsap.timeline({ paused: true });
+${lines.join("\n")}${mediaSync}
+  `;
+}
+function serializeObject(obj) {
+  const entries2 = Object.entries(obj).map(([key2, value]) => {
+    if (typeof value === "string") {
+      return `${key2}: "${value}"`;
+    }
+    return `${key2}: ${value}`;
+  });
+  return `{ ${entries2.join(", ")} }`;
+}
+function updateAnimationInScript(script, animationId, updates) {
+  const parsed = parseGsapScript(script);
+  const updated = parsed.animations.map((anim) => {
+    if (anim.id === animationId) {
+      return { ...anim, ...updates };
+    }
+    return anim;
+  });
+  return serializeGsapAnimations(updated, parsed.timelineVar);
+}
+function addAnimationToScript(script, animation) {
+  const parsed = parseGsapScript(script);
+  const id = `anim-${Date.now()}`;
+  const newAnim = { ...animation, id };
+  parsed.animations.push(newAnim);
+  return {
+    script: serializeGsapAnimations(parsed.animations, parsed.timelineVar),
+    id
+  };
+}
+function removeAnimationFromScript(script, animationId) {
+  const parsed = parseGsapScript(script);
+  const filtered = parsed.animations.filter((a) => a.id !== animationId);
+  return serializeGsapAnimations(filtered, parsed.timelineVar);
+}
 function getAnimationsForElement(animations, elementId) {
   const selector = `#${elementId}`;
   return animations.filter((a) => a.targetSelector === selector);
 }
+function validateCompositionGsap(script) {
+  const errors = [];
+  const warnings = [];
+  for (const { pattern, message } of FORBIDDEN_GSAP_PATTERNS) {
+    if (pattern.test(script)) {
+      errors.push(message);
+    }
+  }
+  if (/yoyo\s*:\s*true/.test(script)) {
+    warnings.push("yoyo animations may behave unexpectedly when scrubbing");
+  }
+  if (/stagger\s*:/.test(script)) {
+    warnings.push("stagger animations may not serialize correctly");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function keyframesToGsapAnimations(elementId, keyframes, elementStartTime, base) {
+  const sorted = [...keyframes].sort((a, b) => a.time - b.time);
+  const animations = [];
+  const baseX = base?.x ?? 0;
+  const baseY = base?.y ?? 0;
+  const baseScale = base?.scale ?? 1;
+  sorted.forEach((kf, i2) => {
+    const absoluteTime = elementStartTime + kf.time;
+    const isFirst = i2 === 0;
+    const prevKf = i2 > 0 ? sorted[i2 - 1] : null;
+    const duration = prevKf ? kf.time - prevKf.time : void 0;
+    const position = prevKf ? elementStartTime + prevKf.time : absoluteTime;
+    const properties = {};
+    for (const [key2, value] of Object.entries(kf.properties)) {
+      if (typeof value !== "number") continue;
+      if (key2 === "x") properties.x = baseX + value;
+      else if (key2 === "y") properties.y = baseY + value;
+      else if (key2 === "scale") properties.scale = baseScale * value;
+      else properties[key2] = value;
+    }
+    animations.push({
+      id: `${elementId}-kf-${kf.id}`,
+      targetSelector: `#${elementId}`,
+      method: isFirst ? "set" : "to",
+      position,
+      properties,
+      duration: isFirst ? void 0 : duration,
+      ease: kf.ease
+    });
+  });
+  return animations;
+}
 function gsapAnimationsToKeyframes(animations, elementStartTime, options) {
   const validMethods = ["set", "to", "from", "fromTo"];
   const baseX = options?.baseX ?? 0;
@@ -2485,7 +2697,7 @@ function gsapAnimationsToKeyframes(animations, elementStartTime, options) {
     return kf;
   }).filter((kf) => kf !== null).sort((a, b) => a.time - b.time);
 }
-var GSAP_METHODS, SUPPORTED_PROPS;
+var GSAP_METHODS, SUPPORTED_PROPS, SUPPORTED_EASES, FORBIDDEN_GSAP_PATTERNS;
 var init_gsapParser = __esm({
   "../core/src/parsers/gsapParser.ts"() {
     "use strict";
@@ -2503,6 +2715,74 @@ var init_gsapParser = __esm({
       "width",
       "height"
     ];
+    SUPPORTED_EASES = [
+      "none",
+      "power1.in",
+      "power1.out",
+      "power1.inOut",
+      "power2.in",
+      "power2.out",
+      "power2.inOut",
+      "power3.in",
+      "power3.out",
+      "power3.inOut",
+      "power4.in",
+      "power4.out",
+      "power4.inOut",
+      "back.in",
+      "back.out",
+      "back.inOut",
+      "elastic.in",
+      "elastic.out",
+      "elastic.inOut",
+      "bounce.in",
+      "bounce.out",
+      "bounce.inOut",
+      "expo.in",
+      "expo.out",
+      "expo.inOut"
+    ];
+    FORBIDDEN_GSAP_PATTERNS = [
+      { pattern: /\.call\s*\(/, message: "call() method not allowed" },
+      {
+        pattern: /\.add\s*\(\s*function/,
+        message: "add(function) not allowed"
+      },
+      {
+        pattern: /\.add\s*\(\s*\(/,
+        message: "add() with arrow function not allowed"
+      },
+      { pattern: /onComplete\s*:/, message: "onComplete callback not allowed" },
+      { pattern: /onStart\s*:/, message: "onStart callback not allowed" },
+      { pattern: /onUpdate\s*:/, message: "onUpdate callback not allowed" },
+      {
+        pattern: /onRepeat\s*:/,
+        message: "onRepeat callback not allowed"
+      },
+      {
+        pattern: /onReverseComplete\s*:/,
+        message: "onReverseComplete callback not allowed"
+      },
+      {
+        pattern: /repeat\s*:\s*-1/,
+        message: "Infinite repeat (repeat: -1) not allowed"
+      },
+      {
+        pattern: /Math\.random\s*\(/,
+        message: "Random values (Math.random) not allowed"
+      },
+      {
+        pattern: /Date\.now\s*\(/,
+        message: "Date-dependent values (Date.now) not allowed"
+      },
+      { pattern: /new\s+Date\s*\(/, message: "Date constructor not allowed" },
+      { pattern: /setTimeout\s*\(/, message: "setTimeout not allowed" },
+      { pattern: /setInterval\s*\(/, message: "setInterval not allowed" },
+      {
+        pattern: /requestAnimationFrame\s*\(/,
+        message: "requestAnimationFrame not allowed"
+      }
+    ];
   }
 });
@@ -2908,6 +3188,241 @@ function normalizeKeyframes(keyframes, baseX, baseY, baseScale) {
     };
   });
 }
+function updateElementInHtml(html, elementId, updates) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const el = doc.getElementById(elementId) || doc.querySelector(`[data-name="${elementId}"]`);
+  if (!el) return html;
+  if (updates.startTime !== void 0) {
+    el.setAttribute("data-start", String(updates.startTime));
+    if (el.hasAttribute("data-end") && updates.duration !== void 0) {
+      el.setAttribute("data-end", String(updates.startTime + updates.duration));
+    }
+  }
+  if (updates.duration !== void 0) {
+    const start = parseFloat(el.getAttribute("data-start") || "0");
+    el.setAttribute("data-end", String(start + updates.duration));
+    el.removeAttribute("data-duration");
+  }
+  if (updates.name !== void 0) {
+    el.setAttribute("data-name", updates.name);
+  }
+  if (updates.zIndex !== void 0) {
+    el.setAttribute("data-layer", String(updates.zIndex));
+  }
+  if ("src" in updates && updates.src !== void 0) {
+    el.setAttribute("src", updates.src);
+  }
+  if ("content" in updates && updates.content !== void 0) {
+    const textEl = el.firstElementChild;
+    if (textEl) {
+      textEl.textContent = updates.content;
+    }
+  }
+  if ("color" in updates && updates.color !== void 0) {
+    el.setAttribute("data-color", updates.color);
+  }
+  if ("fontSize" in updates && updates.fontSize !== void 0) {
+    el.setAttribute("data-font-size", String(updates.fontSize));
+  }
+  if ("textShadow" in updates) {
+    if (updates.textShadow === false) {
+      el.setAttribute("data-text-shadow", "false");
+    } else {
+      el.removeAttribute("data-text-shadow");
+    }
+  }
+  if ("volume" in updates) {
+    if (updates.volume !== void 0 && updates.volume !== 1) {
+      el.setAttribute("data-volume", String(updates.volume));
+    } else {
+      el.removeAttribute("data-volume");
+    }
+  }
+  if ("hasAudio" in updates) {
+    if (updates.hasAudio === true) {
+      el.setAttribute("data-has-audio", "true");
+    } else {
+      el.removeAttribute("data-has-audio");
+    }
+  }
+  return "<!DOCTYPE html>\n" + doc.documentElement.outerHTML;
+}
+function addElementToHtml(html, element) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const container = doc.querySelector("#stage-zoom-container") || doc.querySelector(".container") || doc.querySelector("#stage") || doc.body;
+  const id = element.id || `element-${Date.now()}`;
+  let newEl;
+  switch (element.type) {
+    case "video": {
+      const mediaEl = element;
+      newEl = doc.createElement("video");
+      newEl.setAttribute("muted", "");
+      newEl.setAttribute("playsinline", "");
+      if (mediaEl.src) newEl.setAttribute("src", mediaEl.src);
+      if (mediaEl.volume !== void 0 && mediaEl.volume !== 1) {
+        newEl.setAttribute("data-volume", String(mediaEl.volume));
+      }
+      if (mediaEl.hasAudio) {
+        newEl.setAttribute("data-has-audio", "true");
+      }
+      break;
+    }
+    case "image": {
+      const mediaEl = element;
+      newEl = doc.createElement("img");
+      if (mediaEl.src) newEl.setAttribute("src", mediaEl.src);
+      newEl.setAttribute("alt", element.name);
+      break;
+    }
+    case "audio": {
+      const mediaEl = element;
+      newEl = doc.createElement("audio");
+      if (mediaEl.src) newEl.setAttribute("src", mediaEl.src);
+      if (mediaEl.volume !== void 0 && mediaEl.volume !== 1) {
+        newEl.setAttribute("data-volume", String(mediaEl.volume));
+      }
+      break;
+    }
+    case "text":
+    default: {
+      const textEl = element;
+      newEl = doc.createElement("div");
+      const textContent2 = doc.createElement("div");
+      textContent2.textContent = textEl.content || element.name;
+      newEl.appendChild(textContent2);
+      if (textEl.color) {
+        newEl.setAttribute("data-color", textEl.color);
+      }
+      if (textEl.fontSize) {
+        newEl.setAttribute("data-font-size", String(textEl.fontSize));
+      }
+      break;
+    }
+  }
+  newEl.id = id;
+  newEl.setAttribute("data-start", String(element.startTime));
+  newEl.setAttribute("data-end", String(element.startTime + element.duration));
+  newEl.setAttribute("data-layer", String(element.zIndex));
+  newEl.setAttribute("data-name", element.name);
+  container.appendChild(newEl);
+  return {
+    html: "<!DOCTYPE html>\n" + doc.documentElement.outerHTML,
+    id
+  };
+}
+function removeElementFromHtml(html, elementId) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const el = doc.getElementById(elementId);
+  if (el) {
+    el.remove();
+  }
+  return "<!DOCTYPE html>\n" + doc.documentElement.outerHTML;
+}
+function extractCompositionMetadata(html) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const htmlEl = doc.documentElement;
+  const compositionId = htmlEl.getAttribute("data-composition-id");
+  const durationStr = htmlEl.getAttribute("data-composition-duration");
+  const compositionDuration = durationStr ? parseFloat(durationStr) : null;
+  const variables = parseCompositionVariables(htmlEl);
+  return {
+    compositionId,
+    compositionDuration: compositionDuration && isFinite(compositionDuration) ? compositionDuration : null,
+    variables
+  };
+}
+function parseCompositionVariables(htmlEl) {
+  const variablesAttr = htmlEl.getAttribute("data-composition-variables");
+  if (!variablesAttr) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(variablesAttr);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter((v) => {
+      if (typeof v !== "object" || v === null) return false;
+      if (typeof v.id !== "string" || typeof v.label !== "string") return false;
+      if (!["string", "number", "color", "boolean", "enum"].includes(v.type)) return false;
+      switch (v.type) {
+        case "string":
+          return typeof v.default === "string";
+        case "number":
+          return typeof v.default === "number";
+        case "color":
+          return typeof v.default === "string";
+        case "boolean":
+          return typeof v.default === "boolean";
+        case "enum":
+          return typeof v.default === "string" && Array.isArray(v.options);
+        default:
+          return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function validateCompositionHtml(html) {
+  const errors = [];
+  const warnings = [];
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const htmlEl = doc.documentElement;
+  const compositionId = htmlEl.getAttribute("data-composition-id");
+  if (!compositionId) {
+    errors.push("Missing data-composition-id attribute on <html> element");
+  }
+  const durationStr = htmlEl.getAttribute("data-composition-duration");
+  if (!durationStr) {
+    errors.push("Missing data-composition-duration attribute on <html> element");
+  } else {
+    const duration = parseFloat(durationStr);
+    if (!isFinite(duration) || duration <= 0) {
+      errors.push("data-composition-duration must be a positive finite number");
+    }
+  }
+  const stage = doc.getElementById("stage");
+  if (!stage) {
+    errors.push("Missing #stage element");
+  }
+  if (/\son\w+\s*=/i.test(html)) {
+    errors.push("Inline event handlers (onclick, onload, etc.) not allowed");
+  }
+  if (/javascript\s*:/i.test(html)) {
+    errors.push("javascript: URLs not allowed");
+  }
+  const scripts = doc.querySelectorAll("script");
+  if (scripts.length > 2) {
+    warnings.push("Multiple script tags detected - only GSAP CDN and main script expected");
+  }
+  const gsapScript = extractGsapScript(doc);
+  if (gsapScript) {
+    const gsapValidation = validateCompositionGsap(gsapScript);
+    errors.push(...gsapValidation.errors);
+    warnings.push(...gsapValidation.warnings);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function extractGsapScript(doc) {
+  const scripts = doc.querySelectorAll("script");
+  for (const script of scripts) {
+    const content = script.textContent || "";
+    if (content.includes("gsap.timeline") || content.includes(".set(") || content.includes(".to(")) {
+      return content;
+    }
+  }
+  return null;
+}
 var MEDIA_TYPES;
 var init_htmlParser = __esm({
   "../core/src/parsers/htmlParser.ts"() {
@@ -2919,12 +3434,519 @@ var init_htmlParser = __esm({
 });
 // ../core/src/generators/hyperframes.ts
+function generateGoogleFontsUrl(fontFamilies) {
+  if (fontFamilies.length === 0) return null;
+  const families = fontFamilies.filter((f3) => f3 in FONT_WEIGHTS).map((f3) => {
+    const weights = FONT_WEIGHTS[f3];
+    const encodedName = f3.replace(/ /g, "+");
+    return `family=${encodedName}:wght@${weights}`;
+  });
+  if (families.length === 0) return null;
+  return `${GOOGLE_FONTS_BASE}?${families.join("&")}&display=swap`;
+}
+function sortElements(elements) {
+  return [...elements].sort((a, b) => {
+    if (a.zIndex !== b.zIndex) {
+      return (a.zIndex ?? 0) - (b.zIndex ?? 0);
+    }
+    return a.startTime - b.startTime;
+  });
+}
+function generateHyperframesStyles(elements, resolution, customStyles) {
+  const { width, height } = CANVAS_DIMENSIONS[resolution];
+  const sortedElements = sortElements(elements);
+  const elementStyles = sortedElements.map((el) => generateElementStyles(el)).join("\n");
+  const usedFonts = /* @__PURE__ */ new Set();
+  for (const el of sortedElements) {
+    if (isTextElement(el) && el.fontFamily) {
+      usedFonts.add(el.fontFamily);
+    }
+  }
+  usedFonts.add("Inter");
+  const googleFontsUrl = generateGoogleFontsUrl([...usedFonts]);
+  const googleFontsLink = googleFontsUrl ? `<link data-hf-fonts="true" rel="preconnect" href="https://fonts.googleapis.com">
+  <link data-hf-fonts="true" rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link data-hf-fonts="true" href="${googleFontsUrl}" rel="stylesheet">` : "";
+  const coreCss = `${BASE_STYLES}
+#stage { position: relative; width: ${width}px; height: ${height}px; overflow: hidden; background: #fff; }
+#stage-zoom-container { ${ZOOM_CONTAINER_STYLES} }
+${elementStyles}`.trim();
+  const customCss = customStyles?.trim() ? customStyles.trim() : "";
+  return { coreCss, customCss, googleFontsLink };
+}
+function generateElementStyles(element) {
+  const baseStyles = "position: absolute;";
+  if (isTextElement(element)) {
+    const fontSize = element.fontSize ?? 48;
+    const fontWeight = element.fontWeight ?? 700;
+    const fontFamily = element.fontFamily ?? "Inter";
+    const color = element.color ?? "white";
+    const textShadow = element.textShadow !== false ? "text-shadow: 2px 2px 4px rgba(0,0,0,0.8);" : "";
+    const textOutline = element.textOutline ? `-webkit-text-stroke: ${element.textOutlineWidth ?? 2}px ${element.textOutlineColor ?? "#000000"}; paint-order: stroke fill;` : "";
+    const textHighlight = element.textHighlight ? `background-color: ${element.textHighlightColor ?? "yellow"}; padding: ${element.textHighlightPadding ?? 4}px ${(element.textHighlightPadding ?? 4) * 1.5}px; border-radius: ${element.textHighlightRadius ?? 4}px; box-decoration-break: clone; -webkit-box-decoration-break: clone;` : "";
+    return `    #${element.id} { ${baseStyles} width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; pointer-events: none; }
+    #${element.id} > div { font-family: '${fontFamily}', sans-serif; font-size: ${fontSize}px; font-weight: ${fontWeight}; color: ${color}; ${textShadow} ${textOutline} ${textHighlight} pointer-events: auto; cursor: grab; white-space: pre-wrap; text-align: center; }`;
+  }
+  switch (element.type) {
+    case "video":
+      return `    #${element.id} { ${baseStyles} width: 100%; height: 100%; object-fit: contain; transform-origin: center center; }`;
+    case "image":
+      return `    #${element.id} { ${baseStyles} max-width: 100%; max-height: 100%; transform-origin: center center; }`;
+    case "audio":
+      return `    #${element.id} { ${baseStyles} }`;
+    case "composition":
+      return `    #${element.id} { ${baseStyles} width: 100%; height: 100%; position: absolute; }`;
+  }
+}
+function generateGsapTimelineScript(elements, totalDuration, options = {}) {
+  const {
+    animations,
+    generateDefaultAnimations = true,
+    resolution = "landscape",
+    keyframes,
+    stageZoomKeyframes
+  } = options;
+  const { width, height } = CANVAS_DIMENSIONS[resolution];
+  const sortedElements = sortElements(elements);
+  const hasMedia = sortedElements.some((el) => el.type === "video" || el.type === "audio");
+  let keyframeAnimations = [];
+  if (keyframes) {
+    for (const element of sortedElements) {
+      const elementKeyframes = keyframes[element.id];
+      if (elementKeyframes && elementKeyframes.length > 0) {
+        const baseScale = isMediaElement(element) || isCompositionElement(element) ? element.scale ?? 1 : 1;
+        const converted = keyframesToGsapAnimations(
+          element.id,
+          elementKeyframes,
+          element.startTime,
+          {
+            x: element.x ?? 0,
+            y: element.y ?? 0,
+            scale: baseScale
+          }
+        );
+        keyframeAnimations = keyframeAnimations.concat(converted);
+      }
+    }
+  }
+  const zoomAnimations = generateZoomGsapAnimations(stageZoomKeyframes || [], width, height);
+  const initialPositionSets = generateInitialPositionSets(sortedElements, keyframes);
+  const visibilityAnimations = generateVisibilityForElementsWithoutKeyframes(
+    sortedElements,
+    keyframes
+  );
+  let gsapScript;
+  if (animations && animations.length > 0) {
+    const allAnimations = [...animations, ...keyframeAnimations];
+    gsapScript = serializeGsapAnimations(allAnimations, "tl", {
+      includeMediaSync: hasMedia
+    });
+    const prependAnimations = [initialPositionSets, visibilityAnimations].filter(Boolean).join("\n");
+    if (prependAnimations) {
+      gsapScript = gsapScript.replace(
+        "const tl = gsap.timeline({ paused: true });",
+        `const tl = gsap.timeline({ paused: true });
+${prependAnimations}`
+      );
+    }
+    if (zoomAnimations) {
+      gsapScript += "\n" + zoomAnimations;
+    }
+  } else if (keyframeAnimations.length > 0) {
+    gsapScript = serializeGsapAnimations(keyframeAnimations, "tl", {
+      includeMediaSync: hasMedia
+    });
+    const prependAnimations = [initialPositionSets, visibilityAnimations].filter(Boolean).join("\n");
+    if (prependAnimations) {
+      gsapScript = gsapScript.replace(
+        "const tl = gsap.timeline({ paused: true });",
+        `const tl = gsap.timeline({ paused: true });
+${prependAnimations}`
+      );
+    }
+    if (zoomAnimations) {
+      gsapScript += "\n" + zoomAnimations;
+    }
+  } else if (generateDefaultAnimations) {
+    gsapScript = generateDefaultGsapAnimations(
+      sortedElements,
+      totalDuration,
+      stageZoomKeyframes,
+      width,
+      height
+    );
+  } else {
+    gsapScript = `
+    const tl = gsap.timeline({ paused: true });
+${initialPositionSets ? initialPositionSets + "\n" : ""}    tl.to({}, { duration: ${totalDuration || 1} });
+    `;
+    if (zoomAnimations) {
+      gsapScript += "\n" + zoomAnimations;
+    }
+  }
+  return gsapScript;
+}
+function generateHyperframesHtml(elements, totalDuration, options = {}) {
+  const {
+    animations,
+    styles,
+    generateDefaultAnimations = true,
+    resolution = "landscape",
+    compositionId = `comp-${Date.now()}`,
+    keyframes,
+    stageZoomKeyframes,
+    includeScripts = false,
+    includeStyles = false
+  } = options;
+  const maxZoomTime = stageZoomKeyframes && stageZoomKeyframes.length > 0 ? Math.max(...stageZoomKeyframes.map((kf) => kf.time)) : 0;
+  const calculatedDuration = elements.length > 0 ? Math.max(...elements.map((el) => el.startTime + el.duration), totalDuration, maxZoomTime) : Math.max(totalDuration, maxZoomTime);
+  const sortedElements = sortElements(elements);
+  const elementsHtml = sortedElements.map((el) => generateElementHtml(el, keyframes?.[el.id])).join("\n      ");
+  const customStyles = styles || "";
+  const zoomKeyframesAttr = stageZoomKeyframes && stageZoomKeyframes.length > 0 ? ` data-zoom-keyframes='${JSON.stringify(stageZoomKeyframes).replace(/'/g, "&#39;")}'` : "";
+  const { coreCss, customCss, googleFontsLink } = generateHyperframesStyles(
+    sortedElements,
+    resolution,
+    customStyles
+  );
+  const gsapScript = includeScripts ? generateGsapTimelineScript(sortedElements, totalDuration, {
+    animations,
+    generateDefaultAnimations,
+    resolution,
+    keyframes,
+    stageZoomKeyframes
+  }) : "";
+  const gsapCdnTag = includeScripts ? `  <script src="${GSAP_CDN}"></script>` : "";
+  const gsapScriptTag = includeScripts ? `  <script>
+${gsapScript}
+  </script>` : "";
+  const styleTags = includeStyles ? [
+    coreCss ? `  <style data-hf-core="true">
+    ${coreCss.split("\n").join("\n    ")}
+  </style>` : "",
+    customCss ? `  <style data-hf-custom="true">
+    ${customCss.split("\n").join("\n    ")}
+  </style>` : ""
+  ].filter(Boolean).join("\n") : "";
+  const customStylesAttr = customStyles ? ` data-custom-styles='${JSON.stringify(customStyles).replace(/'/g, "&#39;")}'` : "";
+  const resolutionAttr = ` data-resolution="${resolution}"`;
+  return `<!DOCTYPE html>
+<html data-composition-id="${compositionId}" data-composition-duration="${calculatedDuration}"${resolutionAttr}${customStylesAttr}>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  ${includeStyles ? googleFontsLink : ""}
+  ${gsapCdnTag}
+${styleTags ? `  ${styleTags}` : ""}
+</head>
+<body>
+  <div id="stage">
+    <div id="stage-zoom-container"${zoomKeyframesAttr}>
+      ${elementsHtml}
+    </div>
+  </div>
+  ${gsapScriptTag}
+</body>
+</html>`;
+}
+function calculateZoomTransform(scale, focusX, focusY, canvasWidth, canvasHeight) {
+  const centerX = canvasWidth / 2;
+  const centerY = canvasHeight / 2;
+  const x4 = centerX - focusX * scale;
+  const y2 = centerY - focusY * scale;
+  return { x: x4, y: y2 };
+}
+function generateZoomGsapAnimations(zoomKeyframes, canvasWidth, canvasHeight) {
+  if (!zoomKeyframes || zoomKeyframes.length === 0) {
+    return "";
+  }
+  const sortedKeyframes = [...zoomKeyframes].sort((a, b) => a.time - b.time);
+  const animations = [];
+  animations.push("    // Stage zoom animations");
+  for (let i2 = 0; i2 < sortedKeyframes.length; i2++) {
+    const kf = sortedKeyframes[i2];
+    if (!kf) continue;
+    const { x: x4, y: y2 } = calculateZoomTransform(
+      kf.zoom.scale,
+      kf.zoom.focusX,
+      kf.zoom.focusY,
+      canvasWidth,
+      canvasHeight
+    );
+    if (i2 === 0) {
+      animations.push(
+        `    tl.set("#stage-zoom-container", { scale: ${kf.zoom.scale}, x: ${x4}, y: ${y2} }, ${kf.time});`
+      );
+    } else {
+      const prevKf = sortedKeyframes[i2 - 1];
+      if (!prevKf) continue;
+      const duration = kf.time - prevKf.time;
+      const ease = kf.ease ? `, ease: "${kf.ease}"` : "";
+      animations.push(
+        `    tl.to("#stage-zoom-container", { scale: ${kf.zoom.scale}, x: ${x4}, y: ${y2}, duration: ${duration}${ease} }, ${prevKf.time});`
+      );
+    }
+  }
+  return animations.join("\n");
+}
+function generateElementHtml(element, keyframes) {
+  const baseAttrs = [
+    `id="${element.id}"`,
+    `data-start="${element.startTime}"`,
+    `data-end="${element.startTime + element.duration}"`,
+    `data-layer="${element.zIndex}"`,
+    `data-name="${element.name}"`
+  ];
+  if (element.x !== void 0 && element.x !== 0) {
+    baseAttrs.push(`data-x="${element.x}"`);
+  }
+  if (element.y !== void 0 && element.y !== 0) {
+    baseAttrs.push(`data-y="${element.y}"`);
+  }
+  if (element.scale !== void 0 && element.scale !== 1) {
+    baseAttrs.push(`data-scale="${element.scale}"`);
+  }
+  if (element.opacity !== void 0 && element.opacity !== 1) {
+    baseAttrs.push(`data-opacity="${element.opacity}"`);
+  }
+  if (keyframes && keyframes.length > 0) {
+    const kfJson = JSON.stringify(keyframes);
+    baseAttrs.push(`data-keyframes='${kfJson.replace(/'/g, "&#39;")}'`);
+  }
+  if (isTextElement(element)) {
+    const textAttrs = [...baseAttrs, `data-type="text"`];
+    if (element.color) {
+      textAttrs.push(`data-color="${element.color}"`);
+    }
+    if (element.fontSize) {
+      textAttrs.push(`data-font-size="${element.fontSize}"`);
+    }
+    if (element.fontWeight) {
+      textAttrs.push(`data-font-weight="${element.fontWeight}"`);
+    }
+    if (element.fontFamily) {
+      textAttrs.push(`data-font-family="${element.fontFamily}"`);
+    }
+    if (element.textShadow === false) {
+      textAttrs.push(`data-text-shadow="false"`);
+    }
+    if (element.textOutline) {
+      textAttrs.push(`data-text-outline="true"`);
+      if (element.textOutlineColor) {
+        textAttrs.push(`data-text-outline-color="${element.textOutlineColor}"`);
+      }
+      if (element.textOutlineWidth) {
+        textAttrs.push(`data-text-outline-width="${element.textOutlineWidth}"`);
+      }
+    }
+    if (element.textHighlight) {
+      textAttrs.push(`data-text-highlight="true"`);
+      if (element.textHighlightColor) {
+        textAttrs.push(`data-text-highlight-color="${element.textHighlightColor}"`);
+      }
+      if (element.textHighlightPadding) {
+        textAttrs.push(`data-text-highlight-padding="${element.textHighlightPadding}"`);
+      }
+      if (element.textHighlightRadius) {
+        textAttrs.push(`data-text-highlight-radius="${element.textHighlightRadius}"`);
+      }
+    }
+    const content = element.content || element.name;
+    return `<div ${textAttrs.join(" ")}><div>${content}</div></div>`;
+  }
+  if (isCompositionElement(element)) {
+    const compositionAttrs = [
+      ...baseAttrs,
+      `data-type="composition"`,
+      `data-composition-id="${element.compositionId}"`
+    ];
+    if (element.sourceDuration) {
+      compositionAttrs.push(`data-source-duration="${element.sourceDuration}"`);
+    }
+    if (element.sourceWidth) {
+      compositionAttrs.push(`data-source-width="${element.sourceWidth}"`);
+    }
+    if (element.sourceHeight) {
+      compositionAttrs.push(`data-source-height="${element.sourceHeight}"`);
+    }
+    if (element.variableValues && Object.keys(element.variableValues).length > 0) {
+      const varJson = JSON.stringify(element.variableValues);
+      compositionAttrs.push(`data-variable-values='${varJson.replace(/'/g, "&#39;")}'`);
+    }
+    const attrs2 = compositionAttrs.join(" ");
+    let iframeSrc = element.src.split("?")[0];
+    if (element.variableValues && Object.keys(element.variableValues).length > 0) {
+      const params = new URLSearchParams();
+      for (const [key2, value] of Object.entries(element.variableValues)) {
+        params.set(key2, String(value));
+      }
+      iframeSrc = `${iframeSrc}?${params.toString()}`;
+    }
+    return `<div ${attrs2} style="width: 100%; height: 100%;">
+      <iframe src="${iframeSrc}" sandbox="allow-scripts allow-same-origin" style="width: 100%; height: 100%; border: none; pointer-events: none;"></iframe>
+      <div class="composition-click-overlay" style="position: absolute; inset: 0; cursor: pointer;"></div>
+    </div>`;
+  }
+  if (isMediaElement(element)) {
+    if (element.mediaStartTime) {
+      baseAttrs.push(`data-media-start="${element.mediaStartTime}"`);
+    }
+    if (element.sourceDuration) {
+      baseAttrs.push(`data-source-duration="${element.sourceDuration}"`);
+    }
+    if (element.isAroll) {
+      baseAttrs.push(`data-aroll="true"`);
+    }
+    if (element.volume !== void 0 && element.volume !== 1) {
+      baseAttrs.push(`data-volume="${element.volume}"`);
+    }
+    if (element.type === "video" && element.hasAudio) {
+      baseAttrs.push(`data-has-audio="true"`);
+    }
+  }
+  const attrs = baseAttrs.join(" ");
+  switch (element.type) {
+    case "video":
+      return `<video ${attrs} src="${element.src}" playsinline></video>`;
+    case "image":
+      return `<img ${attrs} src="${element.src}" alt="${element.name}" />`;
+    case "audio":
+      return `<audio ${attrs} src="${element.src}"></audio>`;
+    default:
+      return "";
+  }
+}
+function generateInitialPositionSets(elements, keyframes) {
+  const sets = [];
+  const timeEpsilon = 1e-3;
+  for (const el of elements) {
+    const elementKeyframes = keyframes?.[el.id];
+    const hasBaseKeyframe = elementKeyframes?.some(
+      (kf) => Math.abs(kf.time) <= timeEpsilon && (kf.properties.x !== void 0 || kf.properties.y !== void 0 || kf.properties.scale !== void 0)
+    );
+    const xVal = el.x ?? 0;
+    const yVal = el.y ?? 0;
+    const scaleVal = isMediaElement(el) ? el.scale ?? 1 : 1;
+    if (el.type === "audio") continue;
+    if (isCompositionElement(el)) continue;
+    if (hasBaseKeyframe) {
+      continue;
+    }
+    if (scaleVal !== 1) {
+      sets.push(`    tl.set("#${el.id}", { x: ${xVal}, y: ${yVal}, scale: ${scaleVal} }, 0);`);
+    } else if (xVal !== 0 || yVal !== 0) {
+      sets.push(`    tl.set("#${el.id}", { x: ${xVal}, y: ${yVal} }, 0);`);
+    }
+  }
+  return sets.length > 0 ? sets.join("\n") : "";
+}
+function generateVisibilityForElementsWithoutKeyframes(elements, keyframes) {
+  const animations = [];
+  for (const el of elements) {
+    const elementKeyframes = keyframes?.[el.id];
+    const opacityKeyframes = elementKeyframes?.filter((kf) => kf.properties.opacity !== void 0) || [];
+    const start = el.startTime;
+    const end = el.startTime + el.duration;
+    const safeName = el.name.replace(/[\r\n]+/g, " ");
+    animations.push(`    // ${safeName} (visibility)`);
+    animations.push(`    tl.set("#${el.id}", { visibility: "hidden" }, 0);`);
+    let elementOpacity = el.opacity ?? 1;
+    if (opacityKeyframes.length > 0) {
+      const firstOpacityKeyframe = [...opacityKeyframes].sort((a, b) => a.time - b.time)[0];
+      if (firstOpacityKeyframe?.properties.opacity !== void 0) {
+        elementOpacity = firstOpacityKeyframe.properties.opacity;
+      }
+    }
+    const needsOpacity = elementOpacity !== 1 || opacityKeyframes.length > 0;
+    if (needsOpacity) {
+      animations.push(
+        `    tl.set("#${el.id}", { visibility: "visible", opacity: ${elementOpacity} }, ${start});`
+      );
+    } else {
+      animations.push(`    tl.set("#${el.id}", { visibility: "visible" }, ${start});`);
+    }
+    animations.push(`    tl.set("#${el.id}", { visibility: "hidden" }, ${end});`);
+  }
+  return animations.length > 0 ? animations.join("\n") : "";
+}
+function generateDefaultGsapAnimations(elements, totalDuration, stageZoomKeyframes, canvasWidth, canvasHeight) {
+  if (elements.length === 0 && (!stageZoomKeyframes || stageZoomKeyframes.length === 0)) {
+    return `
+    const tl = gsap.timeline({ paused: true });
+    tl.to({}, { duration: ${totalDuration || 1} });
+    `;
+  }
+  const animations = [];
+  const initialPositionSets = generateInitialPositionSets(elements);
+  if (initialPositionSets) {
+    animations.push(initialPositionSets);
+  }
+  for (const el of elements) {
+    const start = el.startTime;
+    const end = el.startTime + el.duration;
+    const safeName = el.name.replace(/[\r\n]+/g, " ");
+    const elementOpacity = el.opacity ?? 1;
+    animations.push(`    // ${safeName}`);
+    animations.push(`    tl.set("#${el.id}", { visibility: "hidden" }, 0);`);
+    if (elementOpacity !== 1) {
+      animations.push(
+        `    tl.set("#${el.id}", { visibility: "visible", opacity: ${elementOpacity} }, ${start});`
+      );
+    } else {
+      animations.push(`    tl.set("#${el.id}", { visibility: "visible" }, ${start});`);
+    }
+    animations.push(`    tl.set("#${el.id}", { visibility: "hidden" }, ${end});`);
+  }
+  const mediaElements = elements.filter((el) => el.type === "video" || el.type === "audio");
+  const mediaSync = mediaElements.length > 0 ? `
+    // Sync media playback
+    tl.eventCallback("onUpdate", function() {
+      const time = tl.time();
+      document.querySelectorAll("video[data-start], audio[data-start]").forEach(function(media) {
+        const start = parseFloat(media.dataset.start);
+        const end = parseFloat(media.dataset.end) || Infinity;
+        const mediaTime = time - start;
+        if (time >= start && time < end) {
+          if (Math.abs(media.currentTime - mediaTime) > 0.1) {
+            media.currentTime = mediaTime;
+          }
+          if (media.paused && !tl.paused()) {
+            media.play().catch(function() {});
+          }
+        } else if (!media.paused) {
+          media.pause();
+        }
+      });
+    });` : "";
+  const zoomAnimations = stageZoomKeyframes && stageZoomKeyframes.length > 0 && canvasWidth && canvasHeight ? "\n" + generateZoomGsapAnimations(stageZoomKeyframes, canvasWidth, canvasHeight) : "";
+  return `
+    const tl = gsap.timeline({ paused: true });
+${animations.join("\n")}
+    ${mediaSync}${zoomAnimations}
+  `;
+}
+var GOOGLE_FONTS_BASE, FONT_WEIGHTS;
 var init_hyperframes = __esm({
   "../core/src/generators/hyperframes.ts"() {
     "use strict";
     init_core_types();
     init_gsapParser();
     init_constants();
+    GOOGLE_FONTS_BASE = "https://fonts.googleapis.com/css2";
+    FONT_WEIGHTS = {
+      Inter: "400;500;600;700;800;900",
+      Roboto: "400;500;700;900",
+      Montserrat: "400;500;600;700;800;900",
+      Poppins: "400;500;600;700;800;900",
+      "Bebas Neue": "400",
+      Oswald: "400;500;600;700",
+      Anton: "400",
+      "Playfair Display": "400;500;600;700;800;900",
+      Lora: "400;500;600;700",
+      Pacifico: "400",
+      "Permanent Marker": "400",
+      "Fira Code": "400;500;600;700"
+    };
   }
 });
@@ -4769,6 +5791,36 @@ var init_rewriteSubCompPaths = __esm({
 import { buildSync } from "esbuild";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+function applyDefaultParityMode(script, enabled) {
+  const parityFlagPattern = /var\s+_parityModeEnabled\s*=\s*(?:true|false)\s*;/;
+  if (!parityFlagPattern.test(script)) return script;
+  return script.replace(
+    parityFlagPattern,
+    `var _parityModeEnabled = ${enabled ? "true" : "false"};`
+  );
+}
+function buildHyperframesRuntimeScript(options = {}) {
+  const entryPath = resolve2(dirname2(fileURLToPath(import.meta.url)), "../runtime/entry.ts");
+  const result = buildSync({
+    entryPoints: [entryPath],
+    bundle: true,
+    write: false,
+    platform: "browser",
+    format: "iife",
+    target: ["es2020"],
+    minify: options.minify ?? true,
+    legalComments: "none"
+  });
+  let script = result.outputFiles[0]?.text ?? "";
+  if (typeof options.defaultParityMode === "boolean") {
+    script = applyDefaultParityMode(script, options.defaultParityMode);
+  }
+  if (options.sourceUrl && options.sourceUrl.trim()) {
+    script = `${script}
+//# sourceURL=${options.sourceUrl.trim()}`;
+  }
+  return script;
+}
 var init_hyperframesRuntime_engine = __esm({
   "../core/src/inline-scripts/hyperframesRuntime.engine.ts"() {
     "use strict";
@@ -4776,18 +5828,52 @@ var init_hyperframesRuntime_engine = __esm({
 });
 // ../core/src/inline-scripts/runtimeContract.ts
+var HYPERFRAME_RUNTIME_GLOBALS, HYPERFRAME_BRIDGE_SOURCES, HYPERFRAME_CONTROL_ACTIONS;
 var init_runtimeContract = __esm({
   "../core/src/inline-scripts/runtimeContract.ts"() {
     "use strict";
+    HYPERFRAME_RUNTIME_GLOBALS = {
+      player: "__player",
+      playerReady: "__playerReady",
+      renderReady: "__renderReady",
+      timelines: "__timelines",
+      clipManifest: "__clipManifest"
+    };
+    HYPERFRAME_BRIDGE_SOURCES = {
+      parent: "hf-parent",
+      preview: "hf-preview"
+    };
+    HYPERFRAME_CONTROL_ACTIONS = [
+      "play",
+      "pause",
+      "seek",
+      "set-muted",
+      "set-playback-rate",
+      "enable-pick-mode",
+      "disable-pick-mode"
+    ];
   }
 });
 // ../core/src/inline-scripts/hyperframe.ts
+function loadHyperframeRuntimeSource() {
+  return buildHyperframesRuntimeScript();
+}
+var HYPERFRAME_RUNTIME_ARTIFACTS, HYPERFRAME_RUNTIME_CONTRACT;
 var init_hyperframe = __esm({
   "../core/src/inline-scripts/hyperframe.ts"() {
     "use strict";
     init_hyperframesRuntime_engine();
     init_runtimeContract();
+    HYPERFRAME_RUNTIME_ARTIFACTS = {
+      iife: "hyperframe.runtime.iife.js",
+      esm: "hyperframe.runtime.mjs",
+      manifest: "hyperframe.manifest.json"
+    };
+    HYPERFRAME_RUNTIME_CONTRACT = {
+      globals: HYPERFRAME_RUNTIME_GLOBALS,
+      messageSources: HYPERFRAME_BRIDGE_SOURCES
+    };
   }
 });
@@ -4798,6 +5884,14 @@ function quantizeTimeToFrame(timeSeconds, fps) {
   const frameIndex = Math.floor(safeTime * safeFps + 1e-9);
   return frameIndex / safeFps;
 }
+function copyMediaVisualStyles(targetStyle, sourceStyle, properties = MEDIA_VISUAL_STYLE_PROPERTIES) {
+  for (const property of properties) {
+    const value = sourceStyle.getPropertyValue(property);
+    if (value) {
+      targetStyle.setProperty(property, value);
+    }
+  }
+}
 var MEDIA_VISUAL_STYLE_PROPERTIES;
 var init_parityContract = __esm({
   "../core/src/inline-scripts/parityContract.ts"() {
@@ -4834,6 +5928,30 @@ var init_parityContract = __esm({
 });
 // ../core/src/adapters/gsap.ts
+function createGSAPFrameAdapter(options) {
+  const { fps, timeline } = options;
+  const adapterId = options.id ?? "gsap";
+  const getDurationSeconds = () => {
+    const totalDuration = typeof timeline.totalDuration === "function" ? timeline.totalDuration() : timeline.duration();
+    return Number.isFinite(totalDuration) && totalDuration > 0 ? totalDuration : 0;
+  };
+  return {
+    id: adapterId,
+    init: () => {
+      timeline.pause?.();
+    },
+    getDurationFrames: () => {
+      const durationSeconds = getDurationSeconds();
+      return Math.max(0, Math.ceil(durationSeconds * fps));
+    },
+    seekFrame: (frame) => {
+      const clampedFrame = Number.isFinite(frame) ? Math.max(0, frame) : 0;
+      const targetSeconds = clampedFrame / fps;
+      timeline.pause?.();
+      timeline.seek(targetSeconds, false);
+    }
+  };
+}
 var init_gsap2 = __esm({
   "../core/src/adapters/gsap.ts"() {
     "use strict";
@@ -4841,13 +5959,1144 @@ var init_gsap2 = __esm({
 });
 // ../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/generated/bidi-data.js
+var latin1BidiTypes, nonLatin1BidiRanges;
 var init_bidi_data = __esm({
   "../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/generated/bidi-data.js"() {
     "use strict";
+    latin1BidiTypes = [
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "S",
+      "B",
+      "S",
+      "WS",
+      "B",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "B",
+      "B",
+      "B",
+      "S",
+      "WS",
+      "ON",
+      "ON",
+      "ET",
+      "ET",
+      "ET",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ES",
+      "CS",
+      "ES",
+      "CS",
+      "CS",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "CS",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "B",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "CS",
+      "ON",
+      "ET",
+      "ET",
+      "ET",
+      "ET",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "ON",
+      "ON",
+      "BN",
+      "ON",
+      "ON",
+      "ET",
+      "ET",
+      "EN",
+      "EN",
+      "ON",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "EN",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L"
+    ];
+    nonLatin1BidiRanges = [
+      [697, 698, "ON"],
+      [706, 719, "ON"],
+      [722, 735, "ON"],
+      [741, 749, "ON"],
+      [751, 767, "ON"],
+      [768, 879, "NSM"],
+      [884, 885, "ON"],
+      [894, 894, "ON"],
+      [900, 901, "ON"],
+      [903, 903, "ON"],
+      [1014, 1014, "ON"],
+      [1155, 1161, "NSM"],
+      [1418, 1418, "ON"],
+      [1421, 1422, "ON"],
+      [1423, 1423, "ET"],
+      [1424, 1424, "R"],
+      [1425, 1469, "NSM"],
+      [1470, 1470, "R"],
+      [1471, 1471, "NSM"],
+      [1472, 1472, "R"],
+      [1473, 1474, "NSM"],
+      [1475, 1475, "R"],
+      [1476, 1477, "NSM"],
+      [1478, 1478, "R"],
+      [1479, 1479, "NSM"],
+      [1480, 1535, "R"],
+      [1536, 1541, "AN"],
+      [1542, 1543, "ON"],
+      [1544, 1544, "AL"],
+      [1545, 1546, "ET"],
+      [1547, 1547, "AL"],
+      [1548, 1548, "CS"],
+      [1549, 1549, "AL"],
+      [1550, 1551, "ON"],
+      [1552, 1562, "NSM"],
+      [1563, 1610, "AL"],
+      [1611, 1631, "NSM"],
+      [1632, 1641, "AN"],
+      [1642, 1642, "ET"],
+      [1643, 1644, "AN"],
+      [1645, 1647, "AL"],
+      [1648, 1648, "NSM"],
+      [1649, 1749, "AL"],
+      [1750, 1756, "NSM"],
+      [1757, 1757, "AN"],
+      [1758, 1758, "ON"],
+      [1759, 1764, "NSM"],
+      [1765, 1766, "AL"],
+      [1767, 1768, "NSM"],
+      [1769, 1769, "ON"],
+      [1770, 1773, "NSM"],
+      [1774, 1775, "AL"],
+      [1776, 1785, "EN"],
+      [1786, 1808, "AL"],
+      [1809, 1809, "NSM"],
+      [1810, 1839, "AL"],
+      [1840, 1866, "NSM"],
+      [1867, 1957, "AL"],
+      [1958, 1968, "NSM"],
+      [1969, 1983, "AL"],
+      [1984, 2026, "R"],
+      [2027, 2035, "NSM"],
+      [2036, 2037, "R"],
+      [2038, 2041, "ON"],
+      [2042, 2044, "R"],
+      [2045, 2045, "NSM"],
+      [2046, 2069, "R"],
+      [2070, 2073, "NSM"],
+      [2074, 2074, "R"],
+      [2075, 2083, "NSM"],
+      [2084, 2084, "R"],
+      [2085, 2087, "NSM"],
+      [2088, 2088, "R"],
+      [2089, 2093, "NSM"],
+      [2094, 2136, "R"],
+      [2137, 2139, "NSM"],
+      [2140, 2143, "R"],
+      [2144, 2191, "AL"],
+      [2192, 2193, "AN"],
+      [2194, 2198, "AL"],
+      [2199, 2207, "NSM"],
+      [2208, 2249, "AL"],
+      [2250, 2273, "NSM"],
+      [2274, 2274, "AN"],
+      [2275, 2306, "NSM"],
+      [2362, 2362, "NSM"],
+      [2364, 2364, "NSM"],
+      [2369, 2376, "NSM"],
+      [2381, 2381, "NSM"],
+      [2385, 2391, "NSM"],
+      [2402, 2403, "NSM"],
+      [2433, 2433, "NSM"],
+      [2492, 2492, "NSM"],
+      [2497, 2500, "NSM"],
+      [2509, 2509, "NSM"],
+      [2530, 2531, "NSM"],
+      [2546, 2547, "ET"],
+      [2555, 2555, "ET"],
+      [2558, 2558, "NSM"],
+      [2561, 2562, "NSM"],
+      [2620, 2620, "NSM"],
+      [2625, 2626, "NSM"],
+      [2631, 2632, "NSM"],
+      [2635, 2637, "NSM"],
+      [2641, 2641, "NSM"],
+      [2672, 2673, "NSM"],
+      [2677, 2677, "NSM"],
+      [2689, 2690, "NSM"],
+      [2748, 2748, "NSM"],
+      [2753, 2757, "NSM"],
+      [2759, 2760, "NSM"],
+      [2765, 2765, "NSM"],
+      [2786, 2787, "NSM"],
+      [2801, 2801, "ET"],
+      [2810, 2815, "NSM"],
+      [2817, 2817, "NSM"],
+      [2876, 2876, "NSM"],
+      [2879, 2879, "NSM"],
+      [2881, 2884, "NSM"],
+      [2893, 2893, "NSM"],
+      [2901, 2902, "NSM"],
+      [2914, 2915, "NSM"],
+      [2946, 2946, "NSM"],
+      [3008, 3008, "NSM"],
+      [3021, 3021, "NSM"],
+      [3059, 3064, "ON"],
+      [3065, 3065, "ET"],
+      [3066, 3066, "ON"],
+      [3072, 3072, "NSM"],
+      [3076, 3076, "NSM"],
+      [3132, 3132, "NSM"],
+      [3134, 3136, "NSM"],
+      [3142, 3144, "NSM"],
+      [3146, 3149, "NSM"],
+      [3157, 3158, "NSM"],
+      [3170, 3171, "NSM"],
+      [3192, 3198, "ON"],
+      [3201, 3201, "NSM"],
+      [3260, 3260, "NSM"],
+      [3276, 3277, "NSM"],
+      [3298, 3299, "NSM"],
+      [3328, 3329, "NSM"],
+      [3387, 3388, "NSM"],
+      [3393, 3396, "NSM"],
+      [3405, 3405, "NSM"],
+      [3426, 3427, "NSM"],
+      [3457, 3457, "NSM"],
+      [3530, 3530, "NSM"],
+      [3538, 3540, "NSM"],
+      [3542, 3542, "NSM"],
+      [3633, 3633, "NSM"],
+      [3636, 3642, "NSM"],
+      [3647, 3647, "ET"],
+      [3655, 3662, "NSM"],
+      [3761, 3761, "NSM"],
+      [3764, 3772, "NSM"],
+      [3784, 3790, "NSM"],
+      [3864, 3865, "NSM"],
+      [3893, 3893, "NSM"],
+      [3895, 3895, "NSM"],
+      [3897, 3897, "NSM"],
+      [3898, 3901, "ON"],
+      [3953, 3966, "NSM"],
+      [3968, 3972, "NSM"],
+      [3974, 3975, "NSM"],
+      [3981, 3991, "NSM"],
+      [3993, 4028, "NSM"],
+      [4038, 4038, "NSM"],
+      [4141, 4144, "NSM"],
+      [4146, 4151, "NSM"],
+      [4153, 4154, "NSM"],
+      [4157, 4158, "NSM"],
+      [4184, 4185, "NSM"],
+      [4190, 4192, "NSM"],
+      [4209, 4212, "NSM"],
+      [4226, 4226, "NSM"],
+      [4229, 4230, "NSM"],
+      [4237, 4237, "NSM"],
+      [4253, 4253, "NSM"],
+      [4957, 4959, "NSM"],
+      [5008, 5017, "ON"],
+      [5120, 5120, "ON"],
+      [5760, 5760, "WS"],
+      [5787, 5788, "ON"],
+      [5906, 5908, "NSM"],
+      [5938, 5939, "NSM"],
+      [5970, 5971, "NSM"],
+      [6002, 6003, "NSM"],
+      [6068, 6069, "NSM"],
+      [6071, 6077, "NSM"],
+      [6086, 6086, "NSM"],
+      [6089, 6099, "NSM"],
+      [6107, 6107, "ET"],
+      [6109, 6109, "NSM"],
+      [6128, 6137, "ON"],
+      [6144, 6154, "ON"],
+      [6155, 6157, "NSM"],
+      [6158, 6158, "BN"],
+      [6159, 6159, "NSM"],
+      [6277, 6278, "NSM"],
+      [6313, 6313, "NSM"],
+      [6432, 6434, "NSM"],
+      [6439, 6440, "NSM"],
+      [6450, 6450, "NSM"],
+      [6457, 6459, "NSM"],
+      [6464, 6464, "ON"],
+      [6468, 6469, "ON"],
+      [6622, 6655, "ON"],
+      [6679, 6680, "NSM"],
+      [6683, 6683, "NSM"],
+      [6742, 6742, "NSM"],
+      [6744, 6750, "NSM"],
+      [6752, 6752, "NSM"],
+      [6754, 6754, "NSM"],
+      [6757, 6764, "NSM"],
+      [6771, 6780, "NSM"],
+      [6783, 6783, "NSM"],
+      [6832, 6877, "NSM"],
+      [6880, 6891, "NSM"],
+      [6912, 6915, "NSM"],
+      [6964, 6964, "NSM"],
+      [6966, 6970, "NSM"],
+      [6972, 6972, "NSM"],
+      [6978, 6978, "NSM"],
+      [7019, 7027, "NSM"],
+      [7040, 7041, "NSM"],
+      [7074, 7077, "NSM"],
+      [7080, 7081, "NSM"],
+      [7083, 7085, "NSM"],
+      [7142, 7142, "NSM"],
+      [7144, 7145, "NSM"],
+      [7149, 7149, "NSM"],
+      [7151, 7153, "NSM"],
+      [7212, 7219, "NSM"],
+      [7222, 7223, "NSM"],
+      [7376, 7378, "NSM"],
+      [7380, 7392, "NSM"],
+      [7394, 7400, "NSM"],
+      [7405, 7405, "NSM"],
+      [7412, 7412, "NSM"],
+      [7416, 7417, "NSM"],
+      [7616, 7679, "NSM"],
+      [8125, 8125, "ON"],
+      [8127, 8129, "ON"],
+      [8141, 8143, "ON"],
+      [8157, 8159, "ON"],
+      [8173, 8175, "ON"],
+      [8189, 8190, "ON"],
+      [8192, 8202, "WS"],
+      [8203, 8205, "BN"],
+      [8207, 8207, "R"],
+      [8208, 8231, "ON"],
+      [8232, 8232, "WS"],
+      [8233, 8233, "B"],
+      [8234, 8238, "BN"],
+      [8239, 8239, "CS"],
+      [8240, 8244, "ET"],
+      [8245, 8259, "ON"],
+      [8260, 8260, "CS"],
+      [8261, 8286, "ON"],
+      [8287, 8287, "WS"],
+      [8288, 8303, "BN"],
+      [8304, 8304, "EN"],
+      [8308, 8313, "EN"],
+      [8314, 8315, "ES"],
+      [8316, 8318, "ON"],
+      [8320, 8329, "EN"],
+      [8330, 8331, "ES"],
+      [8332, 8334, "ON"],
+      [8352, 8399, "ET"],
+      [8400, 8432, "NSM"],
+      [8448, 8449, "ON"],
+      [8451, 8454, "ON"],
+      [8456, 8457, "ON"],
+      [8468, 8468, "ON"],
+      [8470, 8472, "ON"],
+      [8478, 8483, "ON"],
+      [8485, 8485, "ON"],
+      [8487, 8487, "ON"],
+      [8489, 8489, "ON"],
+      [8494, 8494, "ET"],
+      [8506, 8507, "ON"],
+      [8512, 8516, "ON"],
+      [8522, 8525, "ON"],
+      [8528, 8543, "ON"],
+      [8585, 8587, "ON"],
+      [8592, 8721, "ON"],
+      [8722, 8722, "ES"],
+      [8723, 8723, "ET"],
+      [8724, 9013, "ON"],
+      [9083, 9108, "ON"],
+      [9110, 9257, "ON"],
+      [9280, 9290, "ON"],
+      [9312, 9351, "ON"],
+      [9352, 9371, "EN"],
+      [9450, 9899, "ON"],
+      [9901, 10239, "ON"],
+      [10496, 11123, "ON"],
+      [11126, 11263, "ON"],
+      [11493, 11498, "ON"],
+      [11503, 11505, "NSM"],
+      [11513, 11519, "ON"],
+      [11647, 11647, "NSM"],
+      [11744, 11775, "NSM"],
+      [11776, 11869, "ON"],
+      [11904, 11929, "ON"],
+      [11931, 12019, "ON"],
+      [12032, 12245, "ON"],
+      [12272, 12287, "ON"],
+      [12288, 12288, "WS"],
+      [12289, 12292, "ON"],
+      [12296, 12320, "ON"],
+      [12330, 12333, "NSM"],
+      [12336, 12336, "ON"],
+      [12342, 12343, "ON"],
+      [12349, 12351, "ON"],
+      [12441, 12442, "NSM"],
+      [12443, 12444, "ON"],
+      [12448, 12448, "ON"],
+      [12539, 12539, "ON"],
+      [12736, 12773, "ON"],
+      [12783, 12783, "ON"],
+      [12829, 12830, "ON"],
+      [12880, 12895, "ON"],
+      [12924, 12926, "ON"],
+      [12977, 12991, "ON"],
+      [13004, 13007, "ON"],
+      [13175, 13178, "ON"],
+      [13278, 13279, "ON"],
+      [13311, 13311, "ON"],
+      [19904, 19967, "ON"],
+      [42128, 42182, "ON"],
+      [42509, 42511, "ON"],
+      [42607, 42610, "NSM"],
+      [42611, 42611, "ON"],
+      [42612, 42621, "NSM"],
+      [42622, 42623, "ON"],
+      [42654, 42655, "NSM"],
+      [42736, 42737, "NSM"],
+      [42752, 42785, "ON"],
+      [42888, 42888, "ON"],
+      [43010, 43010, "NSM"],
+      [43014, 43014, "NSM"],
+      [43019, 43019, "NSM"],
+      [43045, 43046, "NSM"],
+      [43048, 43051, "ON"],
+      [43052, 43052, "NSM"],
+      [43064, 43065, "ET"],
+      [43124, 43127, "ON"],
+      [43204, 43205, "NSM"],
+      [43232, 43249, "NSM"],
+      [43263, 43263, "NSM"],
+      [43302, 43309, "NSM"],
+      [43335, 43345, "NSM"],
+      [43392, 43394, "NSM"],
+      [43443, 43443, "NSM"],
+      [43446, 43449, "NSM"],
+      [43452, 43453, "NSM"],
+      [43493, 43493, "NSM"],
+      [43561, 43566, "NSM"],
+      [43569, 43570, "NSM"],
+      [43573, 43574, "NSM"],
+      [43587, 43587, "NSM"],
+      [43596, 43596, "NSM"],
+      [43644, 43644, "NSM"],
+      [43696, 43696, "NSM"],
+      [43698, 43700, "NSM"],
+      [43703, 43704, "NSM"],
+      [43710, 43711, "NSM"],
+      [43713, 43713, "NSM"],
+      [43756, 43757, "NSM"],
+      [43766, 43766, "NSM"],
+      [43882, 43883, "ON"],
+      [44005, 44005, "NSM"],
+      [44008, 44008, "NSM"],
+      [44013, 44013, "NSM"],
+      [64285, 64285, "R"],
+      [64286, 64286, "NSM"],
+      [64287, 64296, "R"],
+      [64297, 64297, "ES"],
+      [64298, 64335, "R"],
+      [64336, 64450, "AL"],
+      [64451, 64466, "ON"],
+      [64467, 64829, "AL"],
+      [64830, 64847, "ON"],
+      [64848, 64911, "AL"],
+      [64912, 64913, "ON"],
+      [64914, 64967, "AL"],
+      [64968, 64975, "ON"],
+      [64976, 65007, "BN"],
+      [65008, 65020, "AL"],
+      [65021, 65023, "ON"],
+      [65024, 65039, "NSM"],
+      [65040, 65049, "ON"],
+      [65056, 65071, "NSM"],
+      [65072, 65103, "ON"],
+      [65104, 65104, "CS"],
+      [65105, 65105, "ON"],
+      [65106, 65106, "CS"],
+      [65108, 65108, "ON"],
+      [65109, 65109, "CS"],
+      [65110, 65118, "ON"],
+      [65119, 65119, "ET"],
+      [65120, 65121, "ON"],
+      [65122, 65123, "ES"],
+      [65124, 65126, "ON"],
+      [65128, 65128, "ON"],
+      [65129, 65130, "ET"],
+      [65131, 65131, "ON"],
+      [65136, 65278, "AL"],
+      [65279, 65279, "BN"],
+      [65281, 65282, "ON"],
+      [65283, 65285, "ET"],
+      [65286, 65290, "ON"],
+      [65291, 65291, "ES"],
+      [65292, 65292, "CS"],
+      [65293, 65293, "ES"],
+      [65294, 65295, "CS"],
+      [65296, 65305, "EN"],
+      [65306, 65306, "CS"],
+      [65307, 65312, "ON"],
+      [65339, 65344, "ON"],
+      [65371, 65381, "ON"],
+      [65504, 65505, "ET"],
+      [65506, 65508, "ON"],
+      [65509, 65510, "ET"],
+      [65512, 65518, "ON"],
+      [65520, 65528, "BN"],
+      [65529, 65533, "ON"],
+      [65534, 65535, "BN"],
+      [65793, 65793, "ON"],
+      [65856, 65932, "ON"],
+      [65936, 65948, "ON"],
+      [65952, 65952, "ON"],
+      [66045, 66045, "NSM"],
+      [66272, 66272, "NSM"],
+      [66273, 66299, "EN"],
+      [66422, 66426, "NSM"],
+      [67584, 67870, "R"],
+      [67871, 67871, "ON"],
+      [67872, 68096, "R"],
+      [68097, 68099, "NSM"],
+      [68100, 68100, "R"],
+      [68101, 68102, "NSM"],
+      [68103, 68107, "R"],
+      [68108, 68111, "NSM"],
+      [68112, 68151, "R"],
+      [68152, 68154, "NSM"],
+      [68155, 68158, "R"],
+      [68159, 68159, "NSM"],
+      [68160, 68324, "R"],
+      [68325, 68326, "NSM"],
+      [68327, 68408, "R"],
+      [68409, 68415, "ON"],
+      [68416, 68863, "R"],
+      [68864, 68899, "AL"],
+      [68900, 68903, "NSM"],
+      [68904, 68911, "AL"],
+      [68912, 68921, "AN"],
+      [68922, 68927, "AL"],
+      [68928, 68937, "AN"],
+      [68938, 68968, "R"],
+      [68969, 68973, "NSM"],
+      [68974, 68974, "ON"],
+      [68975, 69215, "R"],
+      [69216, 69246, "AN"],
+      [69247, 69290, "R"],
+      [69291, 69292, "NSM"],
+      [69293, 69311, "R"],
+      [69312, 69327, "AL"],
+      [69328, 69336, "ON"],
+      [69337, 69369, "AL"],
+      [69370, 69375, "NSM"],
+      [69376, 69423, "R"],
+      [69424, 69445, "AL"],
+      [69446, 69456, "NSM"],
+      [69457, 69487, "AL"],
+      [69488, 69505, "R"],
+      [69506, 69509, "NSM"],
+      [69510, 69631, "R"],
+      [69633, 69633, "NSM"],
+      [69688, 69702, "NSM"],
+      [69714, 69733, "ON"],
+      [69744, 69744, "NSM"],
+      [69747, 69748, "NSM"],
+      [69759, 69761, "NSM"],
+      [69811, 69814, "NSM"],
+      [69817, 69818, "NSM"],
+      [69826, 69826, "NSM"],
+      [69888, 69890, "NSM"],
+      [69927, 69931, "NSM"],
+      [69933, 69940, "NSM"],
+      [70003, 70003, "NSM"],
+      [70016, 70017, "NSM"],
+      [70070, 70078, "NSM"],
+      [70089, 70092, "NSM"],
+      [70095, 70095, "NSM"],
+      [70191, 70193, "NSM"],
+      [70196, 70196, "NSM"],
+      [70198, 70199, "NSM"],
+      [70206, 70206, "NSM"],
+      [70209, 70209, "NSM"],
+      [70367, 70367, "NSM"],
+      [70371, 70378, "NSM"],
+      [70400, 70401, "NSM"],
+      [70459, 70460, "NSM"],
+      [70464, 70464, "NSM"],
+      [70502, 70508, "NSM"],
+      [70512, 70516, "NSM"],
+      [70587, 70592, "NSM"],
+      [70606, 70606, "NSM"],
+      [70608, 70608, "NSM"],
+      [70610, 70610, "NSM"],
+      [70625, 70626, "NSM"],
+      [70712, 70719, "NSM"],
+      [70722, 70724, "NSM"],
+      [70726, 70726, "NSM"],
+      [70750, 70750, "NSM"],
+      [70835, 70840, "NSM"],
+      [70842, 70842, "NSM"],
+      [70847, 70848, "NSM"],
+      [70850, 70851, "NSM"],
+      [71090, 71093, "NSM"],
+      [71100, 71101, "NSM"],
+      [71103, 71104, "NSM"],
+      [71132, 71133, "NSM"],
+      [71219, 71226, "NSM"],
+      [71229, 71229, "NSM"],
+      [71231, 71232, "NSM"],
+      [71264, 71276, "ON"],
+      [71339, 71339, "NSM"],
+      [71341, 71341, "NSM"],
+      [71344, 71349, "NSM"],
+      [71351, 71351, "NSM"],
+      [71453, 71453, "NSM"],
+      [71455, 71455, "NSM"],
+      [71458, 71461, "NSM"],
+      [71463, 71467, "NSM"],
+      [71727, 71735, "NSM"],
+      [71737, 71738, "NSM"],
+      [71995, 71996, "NSM"],
+      [71998, 71998, "NSM"],
+      [72003, 72003, "NSM"],
+      [72148, 72151, "NSM"],
+      [72154, 72155, "NSM"],
+      [72160, 72160, "NSM"],
+      [72193, 72198, "NSM"],
+      [72201, 72202, "NSM"],
+      [72243, 72248, "NSM"],
+      [72251, 72254, "NSM"],
+      [72263, 72263, "NSM"],
+      [72273, 72278, "NSM"],
+      [72281, 72283, "NSM"],
+      [72330, 72342, "NSM"],
+      [72344, 72345, "NSM"],
+      [72544, 72544, "NSM"],
+      [72546, 72548, "NSM"],
+      [72550, 72550, "NSM"],
+      [72752, 72758, "NSM"],
+      [72760, 72765, "NSM"],
+      [72850, 72871, "NSM"],
+      [72874, 72880, "NSM"],
+      [72882, 72883, "NSM"],
+      [72885, 72886, "NSM"],
+      [73009, 73014, "NSM"],
+      [73018, 73018, "NSM"],
+      [73020, 73021, "NSM"],
+      [73023, 73029, "NSM"],
+      [73031, 73031, "NSM"],
+      [73104, 73105, "NSM"],
+      [73109, 73109, "NSM"],
+      [73111, 73111, "NSM"],
+      [73459, 73460, "NSM"],
+      [73472, 73473, "NSM"],
+      [73526, 73530, "NSM"],
+      [73536, 73536, "NSM"],
+      [73538, 73538, "NSM"],
+      [73562, 73562, "NSM"],
+      [73685, 73692, "ON"],
+      [73693, 73696, "ET"],
+      [73697, 73713, "ON"],
+      [78912, 78912, "NSM"],
+      [78919, 78933, "NSM"],
+      [90398, 90409, "NSM"],
+      [90413, 90415, "NSM"],
+      [92912, 92916, "NSM"],
+      [92976, 92982, "NSM"],
+      [94031, 94031, "NSM"],
+      [94095, 94098, "NSM"],
+      [94178, 94178, "ON"],
+      [94180, 94180, "NSM"],
+      [113821, 113822, "NSM"],
+      [113824, 113827, "BN"],
+      [117760, 117973, "ON"],
+      [118e3, 118009, "EN"],
+      [118010, 118012, "ON"],
+      [118016, 118451, "ON"],
+      [118458, 118480, "ON"],
+      [118496, 118512, "ON"],
+      [118528, 118573, "NSM"],
+      [118576, 118598, "NSM"],
+      [119143, 119145, "NSM"],
+      [119155, 119162, "BN"],
+      [119163, 119170, "NSM"],
+      [119173, 119179, "NSM"],
+      [119210, 119213, "NSM"],
+      [119273, 119274, "ON"],
+      [119296, 119361, "ON"],
+      [119362, 119364, "NSM"],
+      [119365, 119365, "ON"],
+      [119552, 119638, "ON"],
+      [120513, 120513, "ON"],
+      [120539, 120539, "ON"],
+      [120571, 120571, "ON"],
+      [120597, 120597, "ON"],
+      [120629, 120629, "ON"],
+      [120655, 120655, "ON"],
+      [120687, 120687, "ON"],
+      [120713, 120713, "ON"],
+      [120745, 120745, "ON"],
+      [120771, 120771, "ON"],
+      [120782, 120831, "EN"],
+      [121344, 121398, "NSM"],
+      [121403, 121452, "NSM"],
+      [121461, 121461, "NSM"],
+      [121476, 121476, "NSM"],
+      [121499, 121503, "NSM"],
+      [121505, 121519, "NSM"],
+      [122880, 122886, "NSM"],
+      [122888, 122904, "NSM"],
+      [122907, 122913, "NSM"],
+      [122915, 122916, "NSM"],
+      [122918, 122922, "NSM"],
+      [123023, 123023, "NSM"],
+      [123184, 123190, "NSM"],
+      [123566, 123566, "NSM"],
+      [123628, 123631, "NSM"],
+      [123647, 123647, "ET"],
+      [124140, 124143, "NSM"],
+      [124398, 124399, "NSM"],
+      [124643, 124643, "NSM"],
+      [124646, 124646, "NSM"],
+      [124654, 124655, "NSM"],
+      [124661, 124661, "NSM"],
+      [124928, 125135, "R"],
+      [125136, 125142, "NSM"],
+      [125143, 125251, "R"],
+      [125252, 125258, "NSM"],
+      [125259, 126063, "R"],
+      [126064, 126143, "AL"],
+      [126144, 126207, "R"],
+      [126208, 126287, "AL"],
+      [126288, 126463, "R"],
+      [126464, 126703, "AL"],
+      [126704, 126705, "ON"],
+      [126706, 126719, "AL"],
+      [126720, 126975, "R"],
+      [126976, 127019, "ON"],
+      [127024, 127123, "ON"],
+      [127136, 127150, "ON"],
+      [127153, 127167, "ON"],
+      [127169, 127183, "ON"],
+      [127185, 127221, "ON"],
+      [127232, 127242, "EN"],
+      [127243, 127247, "ON"],
+      [127279, 127279, "ON"],
+      [127338, 127343, "ON"],
+      [127405, 127405, "ON"],
+      [127584, 127589, "ON"],
+      [127744, 128728, "ON"],
+      [128732, 128748, "ON"],
+      [128752, 128764, "ON"],
+      [128768, 128985, "ON"],
+      [128992, 129003, "ON"],
+      [129008, 129008, "ON"],
+      [129024, 129035, "ON"],
+      [129040, 129095, "ON"],
+      [129104, 129113, "ON"],
+      [129120, 129159, "ON"],
+      [129168, 129197, "ON"],
+      [129200, 129211, "ON"],
+      [129216, 129217, "ON"],
+      [129232, 129240, "ON"],
+      [129280, 129623, "ON"],
+      [129632, 129645, "ON"],
+      [129648, 129660, "ON"],
+      [129664, 129674, "ON"],
+      [129678, 129734, "ON"],
+      [129736, 129736, "ON"],
+      [129741, 129756, "ON"],
+      [129759, 129770, "ON"],
+      [129775, 129784, "ON"],
+      [129792, 129938, "ON"],
+      [129940, 130031, "ON"],
+      [130032, 130041, "EN"],
+      [130042, 130042, "ON"],
+      [131070, 131071, "BN"],
+      [196606, 196607, "BN"],
+      [262142, 262143, "BN"],
+      [327678, 327679, "BN"],
+      [393214, 393215, "BN"],
+      [458750, 458751, "BN"],
+      [524286, 524287, "BN"],
+      [589822, 589823, "BN"],
+      [655358, 655359, "BN"],
+      [720894, 720895, "BN"],
+      [786430, 786431, "BN"],
+      [851966, 851967, "BN"],
+      [917502, 917759, "BN"],
+      [917760, 917999, "NSM"],
+      [918e3, 921599, "BN"],
+      [983038, 983039, "BN"],
+      [1048574, 1048575, "BN"],
+      [1114110, 1114111, "BN"]
+    ];
   }
 });
 // ../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/bidi.js
+function classifyCodePoint(codePoint) {
+  if (codePoint <= 255)
+    return latin1BidiTypes[codePoint];
+  let lo = 0;
+  let hi = nonLatin1BidiRanges.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const range = nonLatin1BidiRanges[mid];
+    if (codePoint < range[0]) {
+      hi = mid - 1;
+      continue;
+    }
+    if (codePoint > range[1]) {
+      lo = mid + 1;
+      continue;
+    }
+    return range[2];
+  }
+  return "L";
+}
+function computeBidiLevels(str) {
+  const len = str.length;
+  if (len === 0)
+    return null;
+  const types3 = new Array(len);
+  let sawBidi = false;
+  for (let i2 = 0; i2 < len; ) {
+    const first = str.charCodeAt(i2);
+    let codePoint = first;
+    let codeUnitLength = 1;
+    if (first >= 55296 && first <= 56319 && i2 + 1 < len) {
+      const second = str.charCodeAt(i2 + 1);
+      if (second >= 56320 && second <= 57343) {
+        codePoint = (first - 55296 << 10) + (second - 56320) + 65536;
+        codeUnitLength = 2;
+      }
+    }
+    const t3 = classifyCodePoint(codePoint);
+    if (t3 === "R" || t3 === "AL" || t3 === "AN")
+      sawBidi = true;
+    for (let j2 = 0; j2 < codeUnitLength; j2++) {
+      types3[i2 + j2] = t3;
+    }
+    i2 += codeUnitLength;
+  }
+  if (!sawBidi)
+    return null;
+  let startLevel = 0;
+  for (let i2 = 0; i2 < len; i2++) {
+    const t3 = types3[i2];
+    if (t3 === "L") {
+      startLevel = 0;
+      break;
+    }
+    if (t3 === "R" || t3 === "AL") {
+      startLevel = 1;
+      break;
+    }
+  }
+  const levels = new Int8Array(len);
+  for (let i2 = 0; i2 < len; i2++)
+    levels[i2] = startLevel;
+  const e2 = startLevel & 1 ? "R" : "L";
+  const sor = e2;
+  let lastType = sor;
+  for (let i2 = 0; i2 < len; i2++) {
+    if (types3[i2] === "NSM")
+      types3[i2] = lastType;
+    else
+      lastType = types3[i2];
+  }
+  lastType = sor;
+  for (let i2 = 0; i2 < len; i2++) {
+    const t3 = types3[i2];
+    if (t3 === "EN")
+      types3[i2] = lastType === "AL" ? "AN" : "EN";
+    else if (t3 === "R" || t3 === "L" || t3 === "AL")
+      lastType = t3;
+  }
+  for (let i2 = 0; i2 < len; i2++) {
+    if (types3[i2] === "AL")
+      types3[i2] = "R";
+  }
+  for (let i2 = 1; i2 < len - 1; i2++) {
+    if (types3[i2] === "ES" && types3[i2 - 1] === "EN" && types3[i2 + 1] === "EN") {
+      types3[i2] = "EN";
+    }
+    if (types3[i2] === "CS" && (types3[i2 - 1] === "EN" || types3[i2 - 1] === "AN") && types3[i2 + 1] === types3[i2 - 1]) {
+      types3[i2] = types3[i2 - 1];
+    }
+  }
+  for (let i2 = 0; i2 < len; i2++) {
+    if (types3[i2] !== "EN")
+      continue;
+    let j2;
+    for (j2 = i2 - 1; j2 >= 0 && types3[j2] === "ET"; j2--)
+      types3[j2] = "EN";
+    for (j2 = i2 + 1; j2 < len && types3[j2] === "ET"; j2++)
+      types3[j2] = "EN";
+  }
+  for (let i2 = 0; i2 < len; i2++) {
+    const t3 = types3[i2];
+    if (t3 === "WS" || t3 === "ES" || t3 === "ET" || t3 === "CS")
+      types3[i2] = "ON";
+  }
+  lastType = sor;
+  for (let i2 = 0; i2 < len; i2++) {
+    const t3 = types3[i2];
+    if (t3 === "EN")
+      types3[i2] = lastType === "L" ? "L" : "EN";
+    else if (t3 === "R" || t3 === "L")
+      lastType = t3;
+  }
+  for (let i2 = 0; i2 < len; i2++) {
+    if (types3[i2] !== "ON")
+      continue;
+    let end = i2 + 1;
+    while (end < len && types3[end] === "ON")
+      end++;
+    const before2 = i2 > 0 ? types3[i2 - 1] : sor;
+    const after2 = end < len ? types3[end] : sor;
+    const bDir = before2 !== "L" ? "R" : "L";
+    const aDir = after2 !== "L" ? "R" : "L";
+    if (bDir === aDir) {
+      for (let j2 = i2; j2 < end; j2++)
+        types3[j2] = bDir;
+    }
+    i2 = end - 1;
+  }
+  for (let i2 = 0; i2 < len; i2++) {
+    if (types3[i2] === "ON")
+      types3[i2] = e2;
+  }
+  for (let i2 = 0; i2 < len; i2++) {
+    const t3 = types3[i2];
+    if ((levels[i2] & 1) === 0) {
+      if (t3 === "R")
+        levels[i2]++;
+      else if (t3 === "AN" || t3 === "EN")
+        levels[i2] += 2;
+    } else if (t3 === "L" || t3 === "AN" || t3 === "EN") {
+      levels[i2]++;
+    }
+  }
+  return levels;
+}
+function computeSegmentLevels(normalized, segStarts) {
+  const bidiLevels = computeBidiLevels(normalized);
+  if (bidiLevels === null)
+    return null;
+  const segLevels = new Int8Array(segStarts.length);
+  for (let i2 = 0; i2 < segStarts.length; i2++) {
+    segLevels[i2] = bidiLevels[segStarts[i2]];
+  }
+  return segLevels;
+}
 var init_bidi = __esm({
   "../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/bidi.js"() {
     "use strict";
@@ -4856,27 +7105,1583 @@ var init_bidi = __esm({
 });
 // ../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/analysis.js
-var arabicScriptRe, combiningMarkRe, decimalDigitRe;
+function getWhiteSpaceProfile(whiteSpace) {
+  const mode = whiteSpace ?? "normal";
+  return mode === "pre-wrap" ? { mode, preserveOrdinarySpaces: true, preserveHardBreaks: true } : { mode, preserveOrdinarySpaces: false, preserveHardBreaks: false };
+}
+function normalizeWhitespaceNormal(text) {
+  if (!needsWhitespaceNormalizationRe.test(text))
+    return text;
+  let normalized = text.replace(collapsibleWhitespaceRunRe, " ");
+  if (normalized.charCodeAt(0) === 32) {
+    normalized = normalized.slice(1);
+  }
+  if (normalized.length > 0 && normalized.charCodeAt(normalized.length - 1) === 32) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function normalizeWhitespacePreWrap(text) {
+  if (!/[\r\f]/.test(text))
+    return text.replace(/\r\n/g, "\n");
+  return text.replace(/\r\n/g, "\n").replace(/[\r\f]/g, "\n");
+}
+function getSharedWordSegmenter() {
+  if (sharedWordSegmenter === null) {
+    sharedWordSegmenter = new Intl.Segmenter(segmenterLocale, { granularity: "word" });
+  }
+  return sharedWordSegmenter;
+}
+function containsArabicScript(text) {
+  return arabicScriptRe.test(text);
+}
+function isCJKCodePoint(codePoint) {
+  return codePoint >= 19968 && codePoint <= 40959 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 131072 && codePoint <= 173791 || codePoint >= 173824 && codePoint <= 177983 || codePoint >= 177984 && codePoint <= 178207 || codePoint >= 178208 && codePoint <= 183983 || codePoint >= 183984 && codePoint <= 191471 || codePoint >= 191472 && codePoint <= 192093 || codePoint >= 194560 && codePoint <= 195103 || codePoint >= 196608 && codePoint <= 201551 || codePoint >= 201552 && codePoint <= 205743 || codePoint >= 205744 && codePoint <= 210041 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 12288 && codePoint <= 12351 || codePoint >= 12352 && codePoint <= 12447 || codePoint >= 12448 && codePoint <= 12543 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 65280 && codePoint <= 65519;
+}
+function isCJK(s2) {
+  for (let i2 = 0; i2 < s2.length; i2++) {
+    const first = s2.charCodeAt(i2);
+    if (first < 12288)
+      continue;
+    if (first >= 55296 && first <= 56319 && i2 + 1 < s2.length) {
+      const second = s2.charCodeAt(i2 + 1);
+      if (second >= 56320 && second <= 57343) {
+        const codePoint = (first - 55296 << 10) + (second - 56320) + 65536;
+        if (isCJKCodePoint(codePoint))
+          return true;
+        i2++;
+        continue;
+      }
+    }
+    if (isCJKCodePoint(first))
+      return true;
+  }
+  return false;
+}
+function endsWithLineStartProhibitedText(text) {
+  const last = getLastCodePoint(text);
+  return last !== null && (kinsokuStart.has(last) || leftStickyPunctuation.has(last));
+}
+function containsCJKText(text) {
+  return isCJK(text);
+}
+function endsWithKeepAllGlueText(text) {
+  const last = getLastCodePoint(text);
+  return last !== null && keepAllGlueChars.has(last);
+}
+function canContinueKeepAllTextRun(previousText) {
+  return !endsWithLineStartProhibitedText(previousText) && !endsWithKeepAllGlueText(previousText);
+}
+function isLeftStickyPunctuationSegment(segment) {
+  if (isEscapedQuoteClusterSegment(segment))
+    return true;
+  let sawPunctuation = false;
+  for (const ch of segment) {
+    if (leftStickyPunctuation.has(ch)) {
+      sawPunctuation = true;
+      continue;
+    }
+    if (sawPunctuation && combiningMarkRe.test(ch))
+      continue;
+    return false;
+  }
+  return sawPunctuation;
+}
+function isCJKLineStartProhibitedSegment(segment) {
+  for (const ch of segment) {
+    if (!kinsokuStart.has(ch) && !leftStickyPunctuation.has(ch))
+      return false;
+  }
+  return segment.length > 0;
+}
+function isForwardStickyClusterSegment(segment) {
+  if (isEscapedQuoteClusterSegment(segment))
+    return true;
+  for (const ch of segment) {
+    if (!kinsokuEnd.has(ch) && !forwardStickyGlue.has(ch) && !combiningMarkRe.test(ch))
+      return false;
+  }
+  return segment.length > 0;
+}
+function isEscapedQuoteClusterSegment(segment) {
+  let sawQuote = false;
+  for (const ch of segment) {
+    if (ch === "\\" || combiningMarkRe.test(ch))
+      continue;
+    if (kinsokuEnd.has(ch) || leftStickyPunctuation.has(ch) || forwardStickyGlue.has(ch)) {
+      sawQuote = true;
+      continue;
+    }
+    return false;
+  }
+  return sawQuote;
+}
+function previousCodePointStart(text, end) {
+  const last = end - 1;
+  if (last <= 0)
+    return Math.max(last, 0);
+  const lastCodeUnit = text.charCodeAt(last);
+  if (lastCodeUnit < 56320 || lastCodeUnit > 57343)
+    return last;
+  const maybeHigh = last - 1;
+  if (maybeHigh < 0)
+    return last;
+  const highCodeUnit = text.charCodeAt(maybeHigh);
+  return highCodeUnit >= 55296 && highCodeUnit <= 56319 ? maybeHigh : last;
+}
+function getLastCodePoint(text) {
+  if (text.length === 0)
+    return null;
+  const start = previousCodePointStart(text, text.length);
+  return text.slice(start);
+}
+function splitTrailingForwardStickyCluster(text) {
+  const chars = Array.from(text);
+  let splitIndex = chars.length;
+  while (splitIndex > 0) {
+    const ch = chars[splitIndex - 1];
+    if (combiningMarkRe.test(ch)) {
+      splitIndex--;
+      continue;
+    }
+    if (kinsokuEnd.has(ch) || forwardStickyGlue.has(ch)) {
+      splitIndex--;
+      continue;
+    }
+    break;
+  }
+  if (splitIndex <= 0 || splitIndex === chars.length)
+    return null;
+  return {
+    head: chars.slice(0, splitIndex).join(""),
+    tail: chars.slice(splitIndex).join("")
+  };
+}
+function getRepeatableSingleCharRunChar(text, isWordLike, kind) {
+  return kind === "text" && !isWordLike && text.length === 1 && text !== "-" && text !== "\u2014" ? text : null;
+}
+function materializeDeferredSingleCharRun(texts, chars, lengths, index) {
+  const ch = chars[index];
+  const text = texts[index];
+  if (ch == null)
+    return text;
+  const length = lengths[index];
+  if (text.length === length)
+    return text;
+  const materialized = ch.repeat(length);
+  texts[index] = materialized;
+  return materialized;
+}
+function hasArabicNoSpacePunctuation(containsArabic, lastCodePoint) {
+  return containsArabic && lastCodePoint !== null && arabicNoSpaceTrailingPunctuation.has(lastCodePoint);
+}
+function endsWithMyanmarMedialGlue(segment) {
+  const lastCodePoint = getLastCodePoint(segment);
+  return lastCodePoint !== null && myanmarMedialGlue.has(lastCodePoint);
+}
+function splitLeadingSpaceAndMarks(segment) {
+  if (segment.length < 2 || segment[0] !== " ")
+    return null;
+  const marks = segment.slice(1);
+  if (new RegExp("^\\p{M}+$", "u").test(marks)) {
+    return { space: " ", marks };
+  }
+  return null;
+}
+function endsWithClosingQuote(text) {
+  let end = text.length;
+  while (end > 0) {
+    const start = previousCodePointStart(text, end);
+    const ch = text.slice(start, end);
+    if (closingQuoteChars.has(ch))
+      return true;
+    if (!leftStickyPunctuation.has(ch))
+      return false;
+    end = start;
+  }
+  return false;
+}
+function classifySegmentBreakChar(ch, whiteSpaceProfile) {
+  if (whiteSpaceProfile.preserveOrdinarySpaces || whiteSpaceProfile.preserveHardBreaks) {
+    if (ch === " ")
+      return "preserved-space";
+    if (ch === "	")
+      return "tab";
+    if (whiteSpaceProfile.preserveHardBreaks && ch === "\n")
+      return "hard-break";
+  }
+  if (ch === " ")
+    return "space";
+  if (ch === "\xA0" || ch === "\u202F" || ch === "\u2060" || ch === "\uFEFF") {
+    return "glue";
+  }
+  if (ch === "\u200B")
+    return "zero-width-break";
+  if (ch === "\xAD")
+    return "soft-hyphen";
+  return "text";
+}
+function joinTextParts(parts) {
+  return parts.length === 1 ? parts[0] : parts.join("");
+}
+function joinReversedPrefixParts(prefixParts, tail) {
+  const parts = [];
+  for (let i2 = prefixParts.length - 1; i2 >= 0; i2--) {
+    parts.push(prefixParts[i2]);
+  }
+  parts.push(tail);
+  return joinTextParts(parts);
+}
+function splitSegmentByBreakKind(segment, isWordLike, start, whiteSpaceProfile) {
+  if (!breakCharRe.test(segment)) {
+    return [{ text: segment, isWordLike, kind: "text", start }];
+  }
+  const pieces = [];
+  let currentKind = null;
+  let currentTextParts = [];
+  let currentStart = start;
+  let currentWordLike = false;
+  let offset = 0;
+  for (const ch of segment) {
+    const kind = classifySegmentBreakChar(ch, whiteSpaceProfile);
+    const wordLike = kind === "text" && isWordLike;
+    if (currentKind !== null && kind === currentKind && wordLike === currentWordLike) {
+      currentTextParts.push(ch);
+      offset += ch.length;
+      continue;
+    }
+    if (currentKind !== null) {
+      pieces.push({
+        text: joinTextParts(currentTextParts),
+        isWordLike: currentWordLike,
+        kind: currentKind,
+        start: currentStart
+      });
+    }
+    currentKind = kind;
+    currentTextParts = [ch];
+    currentStart = start + offset;
+    currentWordLike = wordLike;
+    offset += ch.length;
+  }
+  if (currentKind !== null) {
+    pieces.push({
+      text: joinTextParts(currentTextParts),
+      isWordLike: currentWordLike,
+      kind: currentKind,
+      start: currentStart
+    });
+  }
+  return pieces;
+}
+function isTextRunBoundary(kind) {
+  return kind === "space" || kind === "preserved-space" || kind === "zero-width-break" || kind === "hard-break";
+}
+function isUrlLikeRunStart(segmentation, index) {
+  const text = segmentation.texts[index];
+  if (text.startsWith("www."))
+    return true;
+  return urlSchemeSegmentRe.test(text) && index + 1 < segmentation.len && segmentation.kinds[index + 1] === "text" && segmentation.texts[index + 1] === "//";
+}
+function isUrlQueryBoundarySegment(text) {
+  return text.includes("?") && (text.includes("://") || text.startsWith("www."));
+}
+function mergeUrlLikeRuns(segmentation) {
+  const texts = segmentation.texts.slice();
+  const isWordLike = segmentation.isWordLike.slice();
+  const kinds = segmentation.kinds.slice();
+  const starts = segmentation.starts.slice();
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    if (kinds[i2] !== "text" || !isUrlLikeRunStart(segmentation, i2))
+      continue;
+    const mergedParts = [texts[i2]];
+    let j2 = i2 + 1;
+    while (j2 < segmentation.len && !isTextRunBoundary(kinds[j2])) {
+      mergedParts.push(texts[j2]);
+      isWordLike[i2] = true;
+      const endsQueryPrefix = texts[j2].includes("?");
+      kinds[j2] = "text";
+      texts[j2] = "";
+      j2++;
+      if (endsQueryPrefix)
+        break;
+    }
+    texts[i2] = joinTextParts(mergedParts);
+  }
+  let compactLen = 0;
+  for (let read = 0; read < texts.length; read++) {
+    const text = texts[read];
+    if (text.length === 0)
+      continue;
+    if (compactLen !== read) {
+      texts[compactLen] = text;
+      isWordLike[compactLen] = isWordLike[read];
+      kinds[compactLen] = kinds[read];
+      starts[compactLen] = starts[read];
+    }
+    compactLen++;
+  }
+  texts.length = compactLen;
+  isWordLike.length = compactLen;
+  kinds.length = compactLen;
+  starts.length = compactLen;
+  return {
+    len: compactLen,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeUrlQueryRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    const text = segmentation.texts[i2];
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i2]);
+    kinds.push(segmentation.kinds[i2]);
+    starts.push(segmentation.starts[i2]);
+    if (!isUrlQueryBoundarySegment(text))
+      continue;
+    const nextIndex = i2 + 1;
+    if (nextIndex >= segmentation.len || isTextRunBoundary(segmentation.kinds[nextIndex])) {
+      continue;
+    }
+    const queryParts = [];
+    const queryStart = segmentation.starts[nextIndex];
+    let j2 = nextIndex;
+    while (j2 < segmentation.len && !isTextRunBoundary(segmentation.kinds[j2])) {
+      queryParts.push(segmentation.texts[j2]);
+      j2++;
+    }
+    if (queryParts.length > 0) {
+      texts.push(joinTextParts(queryParts));
+      isWordLike.push(true);
+      kinds.push("text");
+      starts.push(queryStart);
+      i2 = j2 - 1;
+    }
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function segmentContainsDecimalDigit(text) {
+  for (const ch of text) {
+    if (decimalDigitRe.test(ch))
+      return true;
+  }
+  return false;
+}
+function isNumericRunSegment(text) {
+  if (text.length === 0)
+    return false;
+  for (const ch of text) {
+    if (decimalDigitRe.test(ch) || numericJoinerChars.has(ch))
+      continue;
+    return false;
+  }
+  return true;
+}
+function mergeNumericRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    const text = segmentation.texts[i2];
+    const kind = segmentation.kinds[i2];
+    if (kind === "text" && isNumericRunSegment(text) && segmentContainsDecimalDigit(text)) {
+      const mergedParts = [text];
+      let j2 = i2 + 1;
+      while (j2 < segmentation.len && segmentation.kinds[j2] === "text" && isNumericRunSegment(segmentation.texts[j2])) {
+        mergedParts.push(segmentation.texts[j2]);
+        j2++;
+      }
+      texts.push(joinTextParts(mergedParts));
+      isWordLike.push(true);
+      kinds.push("text");
+      starts.push(segmentation.starts[i2]);
+      i2 = j2 - 1;
+      continue;
+    }
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i2]);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i2]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeAsciiPunctuationChains(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    const text = segmentation.texts[i2];
+    const kind = segmentation.kinds[i2];
+    const wordLike = segmentation.isWordLike[i2];
+    if (kind === "text" && wordLike && asciiPunctuationChainSegmentRe.test(text)) {
+      const mergedParts = [text];
+      let endsWithJoiners = asciiPunctuationChainTrailingJoinersRe.test(text);
+      let j2 = i2 + 1;
+      while (endsWithJoiners && j2 < segmentation.len && segmentation.kinds[j2] === "text" && segmentation.isWordLike[j2] && asciiPunctuationChainSegmentRe.test(segmentation.texts[j2])) {
+        const nextText = segmentation.texts[j2];
+        mergedParts.push(nextText);
+        endsWithJoiners = asciiPunctuationChainTrailingJoinersRe.test(nextText);
+        j2++;
+      }
+      texts.push(joinTextParts(mergedParts));
+      isWordLike.push(true);
+      kinds.push("text");
+      starts.push(segmentation.starts[i2]);
+      i2 = j2 - 1;
+      continue;
+    }
+    texts.push(text);
+    isWordLike.push(wordLike);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i2]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function splitHyphenatedNumericRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    const text = segmentation.texts[i2];
+    if (segmentation.kinds[i2] === "text" && text.includes("-")) {
+      const parts = text.split("-");
+      let shouldSplit = parts.length > 1;
+      for (let j2 = 0; j2 < parts.length; j2++) {
+        const part = parts[j2];
+        if (!shouldSplit)
+          break;
+        if (part.length === 0 || !segmentContainsDecimalDigit(part) || !isNumericRunSegment(part)) {
+          shouldSplit = false;
+        }
+      }
+      if (shouldSplit) {
+        let offset = 0;
+        for (let j2 = 0; j2 < parts.length; j2++) {
+          const part = parts[j2];
+          const splitText = j2 < parts.length - 1 ? `${part}-` : part;
+          texts.push(splitText);
+          isWordLike.push(true);
+          kinds.push("text");
+          starts.push(segmentation.starts[i2] + offset);
+          offset += splitText.length;
+        }
+        continue;
+      }
+    }
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i2]);
+    kinds.push(segmentation.kinds[i2]);
+    starts.push(segmentation.starts[i2]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeGlueConnectedTextRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  let read = 0;
+  while (read < segmentation.len) {
+    const textParts = [segmentation.texts[read]];
+    let wordLike = segmentation.isWordLike[read];
+    let kind = segmentation.kinds[read];
+    let start = segmentation.starts[read];
+    if (kind === "glue") {
+      const glueParts = [textParts[0]];
+      const glueStart = start;
+      read++;
+      while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+        glueParts.push(segmentation.texts[read]);
+        read++;
+      }
+      const glueText = joinTextParts(glueParts);
+      if (read < segmentation.len && segmentation.kinds[read] === "text") {
+        textParts[0] = glueText;
+        textParts.push(segmentation.texts[read]);
+        wordLike = segmentation.isWordLike[read];
+        kind = "text";
+        start = glueStart;
+        read++;
+      } else {
+        texts.push(glueText);
+        isWordLike.push(false);
+        kinds.push("glue");
+        starts.push(glueStart);
+        continue;
+      }
+    } else {
+      read++;
+    }
+    if (kind === "text") {
+      while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+        const glueParts = [];
+        while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+          glueParts.push(segmentation.texts[read]);
+          read++;
+        }
+        const glueText = joinTextParts(glueParts);
+        if (read < segmentation.len && segmentation.kinds[read] === "text") {
+          textParts.push(glueText, segmentation.texts[read]);
+          wordLike = wordLike || segmentation.isWordLike[read];
+          read++;
+          continue;
+        }
+        textParts.push(glueText);
+      }
+    }
+    texts.push(joinTextParts(textParts));
+    isWordLike.push(wordLike);
+    kinds.push(kind);
+    starts.push(start);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function carryTrailingForwardStickyAcrossCJKBoundary(segmentation) {
+  const texts = segmentation.texts.slice();
+  const isWordLike = segmentation.isWordLike.slice();
+  const kinds = segmentation.kinds.slice();
+  const starts = segmentation.starts.slice();
+  for (let i2 = 0; i2 < texts.length - 1; i2++) {
+    if (kinds[i2] !== "text" || kinds[i2 + 1] !== "text")
+      continue;
+    if (!isCJK(texts[i2]) || !isCJK(texts[i2 + 1]))
+      continue;
+    const split = splitTrailingForwardStickyCluster(texts[i2]);
+    if (split === null)
+      continue;
+    texts[i2] = split.head;
+    texts[i2 + 1] = split.tail + texts[i2 + 1];
+    starts[i2 + 1] = starts[i2] + split.head.length;
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function buildMergedSegmentation(normalized, profile, whiteSpaceProfile) {
+  const wordSegmenter = getSharedWordSegmenter();
+  let mergedLen = 0;
+  const mergedTexts = [];
+  const mergedTextParts = [];
+  const mergedWordLike = [];
+  const mergedKinds = [];
+  const mergedStarts = [];
+  const mergedSingleCharRunChars = [];
+  const mergedSingleCharRunLengths = [];
+  const mergedContainsCJK = [];
+  const mergedContainsArabicScript = [];
+  const mergedEndsWithClosingQuote = [];
+  const mergedEndsWithMyanmarMedialGlue = [];
+  const mergedHasArabicNoSpacePunctuation = [];
+  for (const s2 of wordSegmenter.segment(normalized)) {
+    for (const piece of splitSegmentByBreakKind(s2.segment, s2.isWordLike ?? false, s2.index, whiteSpaceProfile)) {
+      let appendPieceToPrevious2 = function() {
+        if (mergedSingleCharRunChars[prevIndex] !== null) {
+          mergedTextParts[prevIndex] = [
+            materializeDeferredSingleCharRun(mergedTexts, mergedSingleCharRunChars, mergedSingleCharRunLengths, prevIndex)
+          ];
+          mergedSingleCharRunChars[prevIndex] = null;
+        }
+        mergedTextParts[prevIndex].push(piece.text);
+        mergedWordLike[prevIndex] = mergedWordLike[prevIndex] || piece.isWordLike;
+        mergedContainsCJK[prevIndex] = mergedContainsCJK[prevIndex] || pieceContainsCJK;
+        mergedContainsArabicScript[prevIndex] = mergedContainsArabicScript[prevIndex] || pieceContainsArabicScript;
+        mergedEndsWithClosingQuote[prevIndex] = pieceEndsWithClosingQuote;
+        mergedEndsWithMyanmarMedialGlue[prevIndex] = pieceEndsWithMyanmarMedialGlue;
+        mergedHasArabicNoSpacePunctuation[prevIndex] = hasArabicNoSpacePunctuation(mergedContainsArabicScript[prevIndex], pieceLastCodePoint);
+      };
+      var appendPieceToPrevious = appendPieceToPrevious2;
+      const isText2 = piece.kind === "text";
+      const repeatableSingleCharRunChar = getRepeatableSingleCharRunChar(piece.text, piece.isWordLike, piece.kind);
+      const pieceContainsCJK = isCJK(piece.text);
+      const pieceContainsArabicScript = containsArabicScript(piece.text);
+      const pieceLastCodePoint = getLastCodePoint(piece.text);
+      const pieceEndsWithClosingQuote = endsWithClosingQuote(piece.text);
+      const pieceEndsWithMyanmarMedialGlue = endsWithMyanmarMedialGlue(piece.text);
+      const prevIndex = mergedLen - 1;
+      if (profile.carryCJKAfterClosingQuote && isText2 && mergedLen > 0 && mergedKinds[prevIndex] === "text" && pieceContainsCJK && mergedContainsCJK[prevIndex] && mergedEndsWithClosingQuote[prevIndex]) {
+        appendPieceToPrevious2();
+      } else if (isText2 && mergedLen > 0 && mergedKinds[prevIndex] === "text" && isCJKLineStartProhibitedSegment(piece.text) && mergedContainsCJK[prevIndex]) {
+        appendPieceToPrevious2();
+      } else if (isText2 && mergedLen > 0 && mergedKinds[prevIndex] === "text" && mergedEndsWithMyanmarMedialGlue[prevIndex]) {
+        appendPieceToPrevious2();
+      } else if (isText2 && mergedLen > 0 && mergedKinds[prevIndex] === "text" && piece.isWordLike && pieceContainsArabicScript && mergedHasArabicNoSpacePunctuation[prevIndex]) {
+        appendPieceToPrevious2();
+        mergedWordLike[prevIndex] = true;
+      } else if (repeatableSingleCharRunChar !== null && mergedLen > 0 && mergedKinds[prevIndex] === "text" && mergedSingleCharRunChars[prevIndex] === repeatableSingleCharRunChar) {
+        mergedSingleCharRunLengths[prevIndex] = (mergedSingleCharRunLengths[prevIndex] ?? 1) + 1;
+      } else if (isText2 && !piece.isWordLike && mergedLen > 0 && mergedKinds[prevIndex] === "text" && (isLeftStickyPunctuationSegment(piece.text) || piece.text === "-" && mergedWordLike[prevIndex])) {
+        appendPieceToPrevious2();
+      } else {
+        mergedTexts[mergedLen] = piece.text;
+        mergedTextParts[mergedLen] = [piece.text];
+        mergedWordLike[mergedLen] = piece.isWordLike;
+        mergedKinds[mergedLen] = piece.kind;
+        mergedStarts[mergedLen] = piece.start;
+        mergedSingleCharRunChars[mergedLen] = repeatableSingleCharRunChar;
+        mergedSingleCharRunLengths[mergedLen] = repeatableSingleCharRunChar === null ? 0 : 1;
+        mergedContainsCJK[mergedLen] = pieceContainsCJK;
+        mergedContainsArabicScript[mergedLen] = pieceContainsArabicScript;
+        mergedEndsWithClosingQuote[mergedLen] = pieceEndsWithClosingQuote;
+        mergedEndsWithMyanmarMedialGlue[mergedLen] = pieceEndsWithMyanmarMedialGlue;
+        mergedHasArabicNoSpacePunctuation[mergedLen] = hasArabicNoSpacePunctuation(pieceContainsArabicScript, pieceLastCodePoint);
+        mergedLen++;
+      }
+    }
+  }
+  for (let i2 = 0; i2 < mergedLen; i2++) {
+    if (mergedSingleCharRunChars[i2] !== null) {
+      mergedTexts[i2] = materializeDeferredSingleCharRun(mergedTexts, mergedSingleCharRunChars, mergedSingleCharRunLengths, i2);
+      continue;
+    }
+    mergedTexts[i2] = joinTextParts(mergedTextParts[i2]);
+  }
+  for (let i2 = 1; i2 < mergedLen; i2++) {
+    if (mergedKinds[i2] === "text" && !mergedWordLike[i2] && isEscapedQuoteClusterSegment(mergedTexts[i2]) && mergedKinds[i2 - 1] === "text") {
+      mergedTexts[i2 - 1] += mergedTexts[i2];
+      mergedWordLike[i2 - 1] = mergedWordLike[i2 - 1] || mergedWordLike[i2];
+      mergedTexts[i2] = "";
+    }
+  }
+  const forwardStickyPrefixParts = Array.from({ length: mergedLen }, () => null);
+  let nextLiveIndex = -1;
+  for (let i2 = mergedLen - 1; i2 >= 0; i2--) {
+    const text = mergedTexts[i2];
+    if (text.length === 0)
+      continue;
+    if (mergedKinds[i2] === "text" && !mergedWordLike[i2] && isForwardStickyClusterSegment(text) && nextLiveIndex >= 0 && mergedKinds[nextLiveIndex] === "text") {
+      const prefixParts = forwardStickyPrefixParts[nextLiveIndex] ?? [];
+      prefixParts.push(text);
+      forwardStickyPrefixParts[nextLiveIndex] = prefixParts;
+      mergedStarts[nextLiveIndex] = mergedStarts[i2];
+      mergedTexts[i2] = "";
+      continue;
+    }
+    nextLiveIndex = i2;
+  }
+  for (let i2 = 0; i2 < mergedLen; i2++) {
+    const prefixParts = forwardStickyPrefixParts[i2];
+    if (prefixParts == null)
+      continue;
+    mergedTexts[i2] = joinReversedPrefixParts(prefixParts, mergedTexts[i2]);
+  }
+  let compactLen = 0;
+  for (let read = 0; read < mergedLen; read++) {
+    const text = mergedTexts[read];
+    if (text.length === 0)
+      continue;
+    if (compactLen !== read) {
+      mergedTexts[compactLen] = text;
+      mergedWordLike[compactLen] = mergedWordLike[read];
+      mergedKinds[compactLen] = mergedKinds[read];
+      mergedStarts[compactLen] = mergedStarts[read];
+    }
+    compactLen++;
+  }
+  mergedTexts.length = compactLen;
+  mergedWordLike.length = compactLen;
+  mergedKinds.length = compactLen;
+  mergedStarts.length = compactLen;
+  const compacted = mergeGlueConnectedTextRuns({
+    len: compactLen,
+    texts: mergedTexts,
+    isWordLike: mergedWordLike,
+    kinds: mergedKinds,
+    starts: mergedStarts
+  });
+  const withMergedUrls = carryTrailingForwardStickyAcrossCJKBoundary(mergeAsciiPunctuationChains(splitHyphenatedNumericRuns(mergeNumericRuns(mergeUrlQueryRuns(mergeUrlLikeRuns(compacted))))));
+  for (let i2 = 0; i2 < withMergedUrls.len - 1; i2++) {
+    const split = splitLeadingSpaceAndMarks(withMergedUrls.texts[i2]);
+    if (split === null)
+      continue;
+    if (withMergedUrls.kinds[i2] !== "space" && withMergedUrls.kinds[i2] !== "preserved-space" || withMergedUrls.kinds[i2 + 1] !== "text" || !containsArabicScript(withMergedUrls.texts[i2 + 1])) {
+      continue;
+    }
+    withMergedUrls.texts[i2] = split.space;
+    withMergedUrls.isWordLike[i2] = false;
+    withMergedUrls.kinds[i2] = withMergedUrls.kinds[i2] === "preserved-space" ? "preserved-space" : "space";
+    withMergedUrls.texts[i2 + 1] = split.marks + withMergedUrls.texts[i2 + 1];
+    withMergedUrls.starts[i2 + 1] = withMergedUrls.starts[i2] + split.space.length;
+  }
+  return withMergedUrls;
+}
+function compileAnalysisChunks(segmentation, whiteSpaceProfile) {
+  if (segmentation.len === 0)
+    return [];
+  if (!whiteSpaceProfile.preserveHardBreaks) {
+    return [{
+      startSegmentIndex: 0,
+      endSegmentIndex: segmentation.len,
+      consumedEndSegmentIndex: segmentation.len
+    }];
+  }
+  const chunks = [];
+  let startSegmentIndex = 0;
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    if (segmentation.kinds[i2] !== "hard-break")
+      continue;
+    chunks.push({
+      startSegmentIndex,
+      endSegmentIndex: i2,
+      consumedEndSegmentIndex: i2 + 1
+    });
+    startSegmentIndex = i2 + 1;
+  }
+  if (startSegmentIndex < segmentation.len) {
+    chunks.push({
+      startSegmentIndex,
+      endSegmentIndex: segmentation.len,
+      consumedEndSegmentIndex: segmentation.len
+    });
+  }
+  return chunks;
+}
+function mergeKeepAllTextSegments(segmentation) {
+  if (segmentation.len <= 1)
+    return segmentation;
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  let pendingTextParts = null;
+  let pendingWordLike = false;
+  let pendingStart = 0;
+  let pendingContainsCJK = false;
+  let pendingCanContinue = false;
+  function flushPendingText() {
+    if (pendingTextParts === null)
+      return;
+    texts.push(joinTextParts(pendingTextParts));
+    isWordLike.push(pendingWordLike);
+    kinds.push("text");
+    starts.push(pendingStart);
+    pendingTextParts = null;
+  }
+  for (let i2 = 0; i2 < segmentation.len; i2++) {
+    const text = segmentation.texts[i2];
+    const kind = segmentation.kinds[i2];
+    const wordLike = segmentation.isWordLike[i2];
+    const start = segmentation.starts[i2];
+    if (kind === "text") {
+      const textContainsCJK = containsCJKText(text);
+      const textCanContinue = canContinueKeepAllTextRun(text);
+      if (pendingTextParts !== null && pendingContainsCJK && pendingCanContinue) {
+        pendingTextParts.push(text);
+        pendingWordLike = pendingWordLike || wordLike;
+        pendingContainsCJK = pendingContainsCJK || textContainsCJK;
+        pendingCanContinue = textCanContinue;
+        continue;
+      }
+      flushPendingText();
+      pendingTextParts = [text];
+      pendingWordLike = wordLike;
+      pendingStart = start;
+      pendingContainsCJK = textContainsCJK;
+      pendingCanContinue = textCanContinue;
+      continue;
+    }
+    flushPendingText();
+    texts.push(text);
+    isWordLike.push(wordLike);
+    kinds.push(kind);
+    starts.push(start);
+  }
+  flushPendingText();
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function analyzeText(text, profile, whiteSpace = "normal", wordBreak = "normal") {
+  const whiteSpaceProfile = getWhiteSpaceProfile(whiteSpace);
+  const normalized = whiteSpaceProfile.mode === "pre-wrap" ? normalizeWhitespacePreWrap(text) : normalizeWhitespaceNormal(text);
+  if (normalized.length === 0) {
+    return {
+      normalized,
+      chunks: [],
+      len: 0,
+      texts: [],
+      isWordLike: [],
+      kinds: [],
+      starts: []
+    };
+  }
+  const segmentation = wordBreak === "keep-all" ? mergeKeepAllTextSegments(buildMergedSegmentation(normalized, profile, whiteSpaceProfile)) : buildMergedSegmentation(normalized, profile, whiteSpaceProfile);
+  return {
+    normalized,
+    chunks: compileAnalysisChunks(segmentation, whiteSpaceProfile),
+    ...segmentation
+  };
+}
+var collapsibleWhitespaceRunRe, needsWhitespaceNormalizationRe, sharedWordSegmenter, segmenterLocale, arabicScriptRe, combiningMarkRe, decimalDigitRe, keepAllGlueChars, kinsokuStart, kinsokuEnd, forwardStickyGlue, leftStickyPunctuation, arabicNoSpaceTrailingPunctuation, myanmarMedialGlue, closingQuoteChars, breakCharRe, urlSchemeSegmentRe, numericJoinerChars, asciiPunctuationChainSegmentRe, asciiPunctuationChainTrailingJoinersRe;
 var init_analysis = __esm({
   "../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/analysis.js"() {
     "use strict";
+    collapsibleWhitespaceRunRe = /[ \t\n\r\f]+/g;
+    needsWhitespaceNormalizationRe = /[\t\n\r\f]| {2,}|^ | $/;
+    sharedWordSegmenter = null;
     arabicScriptRe = new RegExp("\\p{Script=Arabic}", "u");
     combiningMarkRe = new RegExp("\\p{M}", "u");
     decimalDigitRe = new RegExp("\\p{Nd}", "u");
+    keepAllGlueChars = /* @__PURE__ */ new Set([
+      "\xA0",
+      "\u202F",
+      "\u2060",
+      "\uFEFF"
+    ]);
+    kinsokuStart = /* @__PURE__ */ new Set([
+      "\uFF0C",
+      "\uFF0E",
+      "\uFF01",
+      "\uFF1A",
+      "\uFF1B",
+      "\uFF1F",
+      "\u3001",
+      "\u3002",
+      "\u30FB",
+      "\uFF09",
+      "\u3015",
+      "\u3009",
+      "\u300B",
+      "\u300D",
+      "\u300F",
+      "\u3011",
+      "\u3017",
+      "\u3019",
+      "\u301B",
+      "\u30FC",
+      "\u3005",
+      "\u303B",
+      "\u309D",
+      "\u309E",
+      "\u30FD",
+      "\u30FE"
+    ]);
+    kinsokuEnd = /* @__PURE__ */ new Set([
+      '"',
+      "(",
+      "[",
+      "{",
+      "\u201C",
+      "\u2018",
+      "\xAB",
+      "\u2039",
+      "\uFF08",
+      "\u3014",
+      "\u3008",
+      "\u300A",
+      "\u300C",
+      "\u300E",
+      "\u3010",
+      "\u3016",
+      "\u3018",
+      "\u301A"
+    ]);
+    forwardStickyGlue = /* @__PURE__ */ new Set([
+      "'",
+      "\u2019"
+    ]);
+    leftStickyPunctuation = /* @__PURE__ */ new Set([
+      ".",
+      ",",
+      "!",
+      "?",
+      ":",
+      ";",
+      "\u060C",
+      "\u061B",
+      "\u061F",
+      "\u0964",
+      "\u0965",
+      "\u104A",
+      "\u104B",
+      "\u104C",
+      "\u104D",
+      "\u104F",
+      ")",
+      "]",
+      "}",
+      "%",
+      '"',
+      "\u201D",
+      "\u2019",
+      "\xBB",
+      "\u203A",
+      "\u2026"
+    ]);
+    arabicNoSpaceTrailingPunctuation = /* @__PURE__ */ new Set([
+      ":",
+      ".",
+      "\u060C",
+      "\u061B"
+    ]);
+    myanmarMedialGlue = /* @__PURE__ */ new Set([
+      "\u104F"
+    ]);
+    closingQuoteChars = /* @__PURE__ */ new Set([
+      "\u201D",
+      "\u2019",
+      "\xBB",
+      "\u203A",
+      "\u300D",
+      "\u300F",
+      "\u3011",
+      "\u300B",
+      "\u3009",
+      "\u3015",
+      "\uFF09"
+    ]);
+    breakCharRe = /[\x20\t\n\xA0\xAD\u200B\u202F\u2060\uFEFF]/;
+    urlSchemeSegmentRe = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+    numericJoinerChars = /* @__PURE__ */ new Set([
+      ":",
+      "-",
+      "/",
+      "\xD7",
+      ",",
+      ".",
+      "+",
+      "\u2013",
+      "\u2014"
+    ]);
+    asciiPunctuationChainSegmentRe = /^[A-Za-z0-9_]+[,:;]*$/;
+    asciiPunctuationChainTrailingJoinersRe = /[,:;]+$/;
   }
 });
 // ../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/measurement.js
-var emojiPresentationRe;
+function getMeasureContext() {
+  if (measureContext !== null)
+    return measureContext;
+  if (typeof OffscreenCanvas !== "undefined") {
+    measureContext = new OffscreenCanvas(1, 1).getContext("2d");
+    return measureContext;
+  }
+  if (typeof document !== "undefined") {
+    measureContext = document.createElement("canvas").getContext("2d");
+    return measureContext;
+  }
+  throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+function getSegmentMetricCache(font) {
+  let cache = segmentMetricCaches.get(font);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    segmentMetricCaches.set(font, cache);
+  }
+  return cache;
+}
+function getSegmentMetrics(seg, cache) {
+  let metrics = cache.get(seg);
+  if (metrics === void 0) {
+    const ctx = getMeasureContext();
+    metrics = {
+      width: ctx.measureText(seg).width,
+      containsCJK: isCJK(seg)
+    };
+    cache.set(seg, metrics);
+  }
+  return metrics;
+}
+function getEngineProfile() {
+  if (cachedEngineProfile !== null)
+    return cachedEngineProfile;
+  if (typeof navigator === "undefined") {
+    cachedEngineProfile = {
+      lineFitEpsilon: 5e-3,
+      carryCJKAfterClosingQuote: false,
+      preferPrefixWidthsForBreakableRuns: false,
+      preferEarlySoftHyphenBreak: false
+    };
+    return cachedEngineProfile;
+  }
+  const ua = navigator.userAgent;
+  const vendor = navigator.vendor;
+  const isSafari = vendor === "Apple Computer, Inc." && ua.includes("Safari/") && !ua.includes("Chrome/") && !ua.includes("Chromium/") && !ua.includes("CriOS/") && !ua.includes("FxiOS/") && !ua.includes("EdgiOS/");
+  const isChromium = ua.includes("Chrome/") || ua.includes("Chromium/") || ua.includes("CriOS/") || ua.includes("Edg/");
+  cachedEngineProfile = {
+    lineFitEpsilon: isSafari ? 1 / 64 : 5e-3,
+    carryCJKAfterClosingQuote: isChromium,
+    preferPrefixWidthsForBreakableRuns: isSafari,
+    preferEarlySoftHyphenBreak: isSafari
+  };
+  return cachedEngineProfile;
+}
+function parseFontSize(font) {
+  const m2 = font.match(/(\d+(?:\.\d+)?)\s*px/);
+  return m2 ? parseFloat(m2[1]) : 16;
+}
+function getSharedGraphemeSegmenter() {
+  if (sharedGraphemeSegmenter === null) {
+    sharedGraphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter;
+}
+function isEmojiGrapheme(g) {
+  return emojiPresentationRe.test(g) || g.includes("\uFE0F");
+}
+function textMayContainEmoji(text) {
+  return maybeEmojiRe.test(text);
+}
+function getEmojiCorrection(font, fontSize) {
+  let correction = emojiCorrectionCache.get(font);
+  if (correction !== void 0)
+    return correction;
+  const ctx = getMeasureContext();
+  ctx.font = font;
+  const canvasW = ctx.measureText("\u{1F600}").width;
+  correction = 0;
+  if (canvasW > fontSize + 0.5 && typeof document !== "undefined" && document.body !== null) {
+    const span = document.createElement("span");
+    span.style.font = font;
+    span.style.display = "inline-block";
+    span.style.visibility = "hidden";
+    span.style.position = "absolute";
+    span.textContent = "\u{1F600}";
+    document.body.appendChild(span);
+    const domW = span.getBoundingClientRect().width;
+    document.body.removeChild(span);
+    if (canvasW - domW > 0.5) {
+      correction = canvasW - domW;
+    }
+  }
+  emojiCorrectionCache.set(font, correction);
+  return correction;
+}
+function countEmojiGraphemes(text) {
+  let count = 0;
+  const graphemeSegmenter = getSharedGraphemeSegmenter();
+  for (const g of graphemeSegmenter.segment(text)) {
+    if (isEmojiGrapheme(g.segment))
+      count++;
+  }
+  return count;
+}
+function getEmojiCount(seg, metrics) {
+  if (metrics.emojiCount === void 0) {
+    metrics.emojiCount = countEmojiGraphemes(seg);
+  }
+  return metrics.emojiCount;
+}
+function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
+  if (emojiCorrection === 0)
+    return metrics.width;
+  return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
+}
+function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mode) {
+  if (metrics.breakableFitAdvances !== void 0)
+    return metrics.breakableFitAdvances;
+  const graphemeSegmenter = getSharedGraphemeSegmenter();
+  const graphemes = [];
+  for (const gs of graphemeSegmenter.segment(seg)) {
+    graphemes.push(gs.segment);
+  }
+  if (graphemes.length <= 1) {
+    metrics.breakableFitAdvances = null;
+    return metrics.breakableFitAdvances;
+  }
+  if (mode === "sum-graphemes") {
+    const advances2 = [];
+    for (const grapheme of graphemes) {
+      const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+      advances2.push(getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection));
+    }
+    metrics.breakableFitAdvances = advances2;
+    return metrics.breakableFitAdvances;
+  }
+  if (mode === "pair-context" || graphemes.length > MAX_PREFIX_FIT_GRAPHEMES) {
+    const advances2 = [];
+    let previousGrapheme = null;
+    let previousWidth = 0;
+    for (const grapheme of graphemes) {
+      const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+      const currentWidth = getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection);
+      if (previousGrapheme === null) {
+        advances2.push(currentWidth);
+      } else {
+        const pair = previousGrapheme + grapheme;
+        const pairMetrics = getSegmentMetrics(pair, cache);
+        advances2.push(getCorrectedSegmentWidth(pair, pairMetrics, emojiCorrection) - previousWidth);
+      }
+      previousGrapheme = grapheme;
+      previousWidth = currentWidth;
+    }
+    metrics.breakableFitAdvances = advances2;
+    return metrics.breakableFitAdvances;
+  }
+  const advances = [];
+  let prefix = "";
+  let prefixWidth = 0;
+  for (const grapheme of graphemes) {
+    prefix += grapheme;
+    const prefixMetrics = getSegmentMetrics(prefix, cache);
+    const nextPrefixWidth = getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection);
+    advances.push(nextPrefixWidth - prefixWidth);
+    prefixWidth = nextPrefixWidth;
+  }
+  metrics.breakableFitAdvances = advances;
+  return metrics.breakableFitAdvances;
+}
+function getFontMeasurementState(font, needsEmojiCorrection) {
+  const ctx = getMeasureContext();
+  ctx.font = font;
+  const cache = getSegmentMetricCache(font);
+  const fontSize = parseFontSize(font);
+  const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize) : 0;
+  return { cache, fontSize, emojiCorrection };
+}
+var measureContext, segmentMetricCaches, cachedEngineProfile, MAX_PREFIX_FIT_GRAPHEMES, emojiPresentationRe, maybeEmojiRe, sharedGraphemeSegmenter, emojiCorrectionCache;
 var init_measurement = __esm({
   "../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/measurement.js"() {
     "use strict";
     init_analysis();
+    measureContext = null;
+    segmentMetricCaches = /* @__PURE__ */ new Map();
+    cachedEngineProfile = null;
+    MAX_PREFIX_FIT_GRAPHEMES = 96;
     emojiPresentationRe = new RegExp("\\p{Emoji_Presentation}", "u");
+    maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+    sharedGraphemeSegmenter = null;
+    emojiCorrectionCache = /* @__PURE__ */ new Map();
   }
 });
 // ../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/line-break.js
+function normalizeSimpleLineStartSegmentIndex(prepared, segmentIndex) {
+  while (segmentIndex < prepared.widths.length) {
+    const kind = prepared.kinds[segmentIndex];
+    if (kind !== "space" && kind !== "zero-width-break" && kind !== "soft-hyphen")
+      break;
+    segmentIndex++;
+  }
+  return segmentIndex;
+}
+function getTabAdvance(lineWidth, tabStopAdvance) {
+  if (tabStopAdvance <= 0)
+    return 0;
+  const remainder = lineWidth % tabStopAdvance;
+  if (Math.abs(remainder) <= 1e-6)
+    return tabStopAdvance;
+  return tabStopAdvance - remainder;
+}
+function fitSoftHyphenBreak(graphemeFitAdvances, initialWidth, maxWidth, lineFitEpsilon, discretionaryHyphenWidth) {
+  let fitCount = 0;
+  let fittedWidth = initialWidth;
+  while (fitCount < graphemeFitAdvances.length) {
+    const nextWidth = fittedWidth + graphemeFitAdvances[fitCount];
+    const nextLineWidth = fitCount + 1 < graphemeFitAdvances.length ? nextWidth + discretionaryHyphenWidth : nextWidth;
+    if (nextLineWidth > maxWidth + lineFitEpsilon)
+      break;
+    fittedWidth = nextWidth;
+    fitCount++;
+  }
+  return { fitCount, fittedWidth };
+}
+function countPreparedLines(prepared, maxWidth) {
+  if (prepared.simpleLineWalkFastPath) {
+    return walkPreparedLinesSimple(prepared, maxWidth);
+  }
+  return walkPreparedLines(prepared, maxWidth);
+}
+function walkPreparedLinesSimple(prepared, maxWidth, onLine) {
+  const { widths, kinds, breakableFitAdvances } = prepared;
+  if (widths.length === 0)
+    return 0;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  const fitLimit = maxWidth + lineFitEpsilon;
+  let lineCount = 0;
+  let lineW = 0;
+  let hasContent = false;
+  let lineStartSegmentIndex = 0;
+  let lineStartGraphemeIndex = 0;
+  let lineEndSegmentIndex = 0;
+  let lineEndGraphemeIndex = 0;
+  let pendingBreakSegmentIndex = -1;
+  let pendingBreakPaintWidth = 0;
+  function clearPendingBreak() {
+    pendingBreakSegmentIndex = -1;
+    pendingBreakPaintWidth = 0;
+  }
+  function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    lineCount++;
+    onLine?.({
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+      width
+    });
+    lineW = 0;
+    hasContent = false;
+    clearPendingBreak();
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = graphemeIndex;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const fitAdvances = breakableFitAdvances[segmentIndex];
+    for (let g = startGraphemeIndex; g < fitAdvances.length; g++) {
+      const gw = fitAdvances[g];
+      if (!hasContent) {
+        startLineAtGrapheme(segmentIndex, g, gw);
+      } else if (lineW + gw > fitLimit) {
+        emitCurrentLine();
+        startLineAtGrapheme(segmentIndex, g, gw);
+      } else {
+        lineW += gw;
+        lineEndSegmentIndex = segmentIndex;
+        lineEndGraphemeIndex = g + 1;
+      }
+    }
+    if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+  }
+  let i2 = 0;
+  while (i2 < widths.length) {
+    if (!hasContent) {
+      i2 = normalizeSimpleLineStartSegmentIndex(prepared, i2);
+      if (i2 >= widths.length)
+        break;
+    }
+    const w = widths[i2];
+    const kind = kinds[i2];
+    const breakAfter = kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+    if (!hasContent) {
+      if (w > maxWidth && breakableFitAdvances[i2] !== null) {
+        appendBreakableSegmentFrom(i2, 0);
+      } else {
+        startLineAtSegment(i2, w);
+      }
+      if (breakAfter) {
+        pendingBreakSegmentIndex = i2 + 1;
+        pendingBreakPaintWidth = lineW - w;
+      }
+      i2++;
+      continue;
+    }
+    const newW = lineW + w;
+    if (newW > fitLimit) {
+      if (breakAfter) {
+        appendWholeSegment(i2, w);
+        emitCurrentLine(i2 + 1, 0, lineW - w);
+        i2++;
+        continue;
+      }
+      if (pendingBreakSegmentIndex >= 0) {
+        if (lineEndSegmentIndex > pendingBreakSegmentIndex || lineEndSegmentIndex === pendingBreakSegmentIndex && lineEndGraphemeIndex > 0) {
+          emitCurrentLine();
+          continue;
+        }
+        emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+        continue;
+      }
+      if (w > maxWidth && breakableFitAdvances[i2] !== null) {
+        emitCurrentLine();
+        appendBreakableSegmentFrom(i2, 0);
+        i2++;
+        continue;
+      }
+      emitCurrentLine();
+      continue;
+    }
+    appendWholeSegment(i2, w);
+    if (breakAfter) {
+      pendingBreakSegmentIndex = i2 + 1;
+      pendingBreakPaintWidth = lineW - w;
+    }
+    i2++;
+  }
+  if (hasContent)
+    emitCurrentLine();
+  return lineCount;
+}
+function walkPreparedLines(prepared, maxWidth, onLine) {
+  if (prepared.simpleLineWalkFastPath) {
+    return walkPreparedLinesSimple(prepared, maxWidth, onLine);
+  }
+  const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableFitAdvances, discretionaryHyphenWidth, tabStopAdvance, chunks } = prepared;
+  if (widths.length === 0 || chunks.length === 0)
+    return 0;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  const fitLimit = maxWidth + lineFitEpsilon;
+  let lineCount = 0;
+  let lineW = 0;
+  let hasContent = false;
+  let lineStartSegmentIndex = 0;
+  let lineStartGraphemeIndex = 0;
+  let lineEndSegmentIndex = 0;
+  let lineEndGraphemeIndex = 0;
+  let pendingBreakSegmentIndex = -1;
+  let pendingBreakFitWidth = 0;
+  let pendingBreakPaintWidth = 0;
+  let pendingBreakKind = null;
+  function clearPendingBreak() {
+    pendingBreakSegmentIndex = -1;
+    pendingBreakFitWidth = 0;
+    pendingBreakPaintWidth = 0;
+    pendingBreakKind = null;
+  }
+  function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    lineCount++;
+    onLine?.({
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+      width
+    });
+    lineW = 0;
+    hasContent = false;
+    clearPendingBreak();
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = graphemeIndex;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreakForWholeSegment(kind, breakAfter, segmentIndex, segmentWidth) {
+    if (!breakAfter)
+      return;
+    const fitAdvance = kind === "tab" ? 0 : lineEndFitAdvances[segmentIndex];
+    const paintAdvance = kind === "tab" ? segmentWidth : lineEndPaintAdvances[segmentIndex];
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;
+    pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;
+    pendingBreakKind = kind;
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const fitAdvances = breakableFitAdvances[segmentIndex];
+    for (let g = startGraphemeIndex; g < fitAdvances.length; g++) {
+      const gw = fitAdvances[g];
+      if (!hasContent) {
+        startLineAtGrapheme(segmentIndex, g, gw);
+      } else if (lineW + gw > fitLimit) {
+        emitCurrentLine();
+        startLineAtGrapheme(segmentIndex, g, gw);
+      } else {
+        lineW += gw;
+        lineEndSegmentIndex = segmentIndex;
+        lineEndGraphemeIndex = g + 1;
+      }
+    }
+    if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+  }
+  function continueSoftHyphenBreakableSegment(segmentIndex) {
+    if (pendingBreakKind !== "soft-hyphen")
+      return false;
+    const fitWidths = breakableFitAdvances[segmentIndex];
+    if (fitWidths == null)
+      return false;
+    const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth);
+    if (fitCount === 0)
+      return false;
+    lineW = fittedWidth;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = fitCount;
+    clearPendingBreak();
+    if (fitCount === fitWidths.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+      return true;
+    }
+    emitCurrentLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);
+    appendBreakableSegmentFrom(segmentIndex, fitCount);
+    return true;
+  }
+  function emitEmptyChunk(chunk) {
+    lineCount++;
+    onLine?.({
+      startSegmentIndex: chunk.startSegmentIndex,
+      startGraphemeIndex: 0,
+      endSegmentIndex: chunk.consumedEndSegmentIndex,
+      endGraphemeIndex: 0,
+      width: 0
+    });
+    clearPendingBreak();
+  }
+  for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+    const chunk = chunks[chunkIndex];
+    if (chunk.startSegmentIndex === chunk.endSegmentIndex) {
+      emitEmptyChunk(chunk);
+      continue;
+    }
+    hasContent = false;
+    lineW = 0;
+    lineStartSegmentIndex = chunk.startSegmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = chunk.startSegmentIndex;
+    lineEndGraphemeIndex = 0;
+    clearPendingBreak();
+    let i2 = chunk.startSegmentIndex;
+    while (i2 < chunk.endSegmentIndex) {
+      const kind = kinds[i2];
+      const breakAfter = kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+      const w = kind === "tab" ? getTabAdvance(lineW, tabStopAdvance) : widths[i2];
+      if (kind === "soft-hyphen") {
+        if (hasContent) {
+          lineEndSegmentIndex = i2 + 1;
+          lineEndGraphemeIndex = 0;
+          pendingBreakSegmentIndex = i2 + 1;
+          pendingBreakFitWidth = lineW + discretionaryHyphenWidth;
+          pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;
+          pendingBreakKind = kind;
+        }
+        i2++;
+        continue;
+      }
+      if (!hasContent) {
+        if (w > maxWidth && breakableFitAdvances[i2] !== null) {
+          appendBreakableSegmentFrom(i2, 0);
+        } else {
+          startLineAtSegment(i2, w);
+        }
+        updatePendingBreakForWholeSegment(kind, breakAfter, i2, w);
+        i2++;
+        continue;
+      }
+      const newW = lineW + w;
+      if (newW > fitLimit) {
+        const currentBreakFitWidth = lineW + (kind === "tab" ? 0 : lineEndFitAdvances[i2]);
+        const currentBreakPaintWidth = lineW + (kind === "tab" ? w : lineEndPaintAdvances[i2]);
+        if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= fitLimit) {
+          emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+          continue;
+        }
+        if (pendingBreakKind === "soft-hyphen" && continueSoftHyphenBreakableSegment(i2)) {
+          i2++;
+          continue;
+        }
+        if (breakAfter && currentBreakFitWidth <= fitLimit) {
+          appendWholeSegment(i2, w);
+          emitCurrentLine(i2 + 1, 0, currentBreakPaintWidth);
+          i2++;
+          continue;
+        }
+        if (pendingBreakSegmentIndex >= 0 && pendingBreakFitWidth <= fitLimit) {
+          if (lineEndSegmentIndex > pendingBreakSegmentIndex || lineEndSegmentIndex === pendingBreakSegmentIndex && lineEndGraphemeIndex > 0) {
+            emitCurrentLine();
+            continue;
+          }
+          const nextSegmentIndex = pendingBreakSegmentIndex;
+          emitCurrentLine(nextSegmentIndex, 0, pendingBreakPaintWidth);
+          i2 = nextSegmentIndex;
+          continue;
+        }
+        if (w > maxWidth && breakableFitAdvances[i2] !== null) {
+          emitCurrentLine();
+          appendBreakableSegmentFrom(i2, 0);
+          i2++;
+          continue;
+        }
+        emitCurrentLine();
+        continue;
+      }
+      appendWholeSegment(i2, w);
+      updatePendingBreakForWholeSegment(kind, breakAfter, i2, w);
+      i2++;
+    }
+    if (hasContent) {
+      const finalPaintWidth = pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex ? pendingBreakPaintWidth : lineW;
+      emitCurrentLine(chunk.consumedEndSegmentIndex, 0, finalPaintWidth);
+    }
+  }
+  return lineCount;
+}
 var init_line_break = __esm({
   "../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/line-break.js"() {
     "use strict";
@@ -4885,6 +8690,271 @@ var init_line_break = __esm({
 });
 // ../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/layout.js
+function getSharedGraphemeSegmenter2() {
+  if (sharedGraphemeSegmenter2 === null) {
+    sharedGraphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter2;
+}
+function createEmptyPrepared(includeSegments) {
+  if (includeSegments) {
+    return {
+      widths: [],
+      lineEndFitAdvances: [],
+      lineEndPaintAdvances: [],
+      kinds: [],
+      simpleLineWalkFastPath: true,
+      segLevels: null,
+      breakableFitAdvances: [],
+      discretionaryHyphenWidth: 0,
+      tabStopAdvance: 0,
+      chunks: [],
+      segments: []
+    };
+  }
+  return {
+    widths: [],
+    lineEndFitAdvances: [],
+    lineEndPaintAdvances: [],
+    kinds: [],
+    simpleLineWalkFastPath: true,
+    segLevels: null,
+    breakableFitAdvances: [],
+    discretionaryHyphenWidth: 0,
+    tabStopAdvance: 0,
+    chunks: []
+  };
+}
+function buildBaseCjkUnits(segText, engineProfile) {
+  const units = [];
+  let unitParts = [];
+  let unitStart = 0;
+  let unitContainsCJK = false;
+  let unitEndsWithClosingQuote = false;
+  let unitIsSingleKinsokuEnd = false;
+  function pushUnit() {
+    if (unitParts.length === 0)
+      return;
+    units.push({
+      text: unitParts.length === 1 ? unitParts[0] : unitParts.join(""),
+      start: unitStart
+    });
+    unitParts = [];
+    unitContainsCJK = false;
+    unitEndsWithClosingQuote = false;
+    unitIsSingleKinsokuEnd = false;
+  }
+  function startUnit(grapheme, start, graphemeContainsCJK) {
+    unitParts = [grapheme];
+    unitStart = start;
+    unitContainsCJK = graphemeContainsCJK;
+    unitEndsWithClosingQuote = endsWithClosingQuote(grapheme);
+    unitIsSingleKinsokuEnd = kinsokuEnd.has(grapheme);
+  }
+  function appendToUnit(grapheme, graphemeContainsCJK) {
+    unitParts.push(grapheme);
+    unitContainsCJK = unitContainsCJK || graphemeContainsCJK;
+    const graphemeEndsWithClosingQuote = endsWithClosingQuote(grapheme);
+    if (grapheme.length === 1 && leftStickyPunctuation.has(grapheme)) {
+      unitEndsWithClosingQuote = unitEndsWithClosingQuote || graphemeEndsWithClosingQuote;
+    } else {
+      unitEndsWithClosingQuote = graphemeEndsWithClosingQuote;
+    }
+    unitIsSingleKinsokuEnd = false;
+  }
+  for (const gs of getSharedGraphemeSegmenter2().segment(segText)) {
+    const grapheme = gs.segment;
+    const graphemeContainsCJK = isCJK(grapheme);
+    if (unitParts.length === 0) {
+      startUnit(grapheme, gs.index, graphemeContainsCJK);
+      continue;
+    }
+    if (unitIsSingleKinsokuEnd || kinsokuStart.has(grapheme) || leftStickyPunctuation.has(grapheme) || engineProfile.carryCJKAfterClosingQuote && graphemeContainsCJK && unitEndsWithClosingQuote) {
+      appendToUnit(grapheme, graphemeContainsCJK);
+      continue;
+    }
+    if (!unitContainsCJK && !graphemeContainsCJK) {
+      appendToUnit(grapheme, graphemeContainsCJK);
+      continue;
+    }
+    pushUnit();
+    startUnit(grapheme, gs.index, graphemeContainsCJK);
+  }
+  pushUnit();
+  return units;
+}
+function mergeKeepAllTextUnits(units) {
+  if (units.length <= 1)
+    return units;
+  const merged = [];
+  let currentTextParts = [units[0].text];
+  let currentStart = units[0].start;
+  let currentContainsCJK = isCJK(units[0].text);
+  let currentCanContinue = canContinueKeepAllTextRun(units[0].text);
+  function flushCurrent() {
+    merged.push({
+      text: currentTextParts.length === 1 ? currentTextParts[0] : currentTextParts.join(""),
+      start: currentStart
+    });
+  }
+  for (let i2 = 1; i2 < units.length; i2++) {
+    const next = units[i2];
+    const nextContainsCJK = isCJK(next.text);
+    const nextCanContinue = canContinueKeepAllTextRun(next.text);
+    if (currentContainsCJK && currentCanContinue) {
+      currentTextParts.push(next.text);
+      currentContainsCJK = currentContainsCJK || nextContainsCJK;
+      currentCanContinue = nextCanContinue;
+      continue;
+    }
+    flushCurrent();
+    currentTextParts = [next.text];
+    currentStart = next.start;
+    currentContainsCJK = nextContainsCJK;
+    currentCanContinue = nextCanContinue;
+  }
+  flushCurrent();
+  return merged;
+}
+function measureAnalysis(analysis, font, includeSegments, wordBreak) {
+  const engineProfile = getEngineProfile();
+  const { cache, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
+  const discretionaryHyphenWidth = getCorrectedSegmentWidth("-", getSegmentMetrics("-", cache), emojiCorrection);
+  const spaceWidth = getCorrectedSegmentWidth(" ", getSegmentMetrics(" ", cache), emojiCorrection);
+  const tabStopAdvance = spaceWidth * 8;
+  if (analysis.len === 0)
+    return createEmptyPrepared(includeSegments);
+  const widths = [];
+  const lineEndFitAdvances = [];
+  const lineEndPaintAdvances = [];
+  const kinds = [];
+  let simpleLineWalkFastPath = analysis.chunks.length <= 1;
+  const segStarts = includeSegments ? [] : null;
+  const breakableFitAdvances = [];
+  const segments = includeSegments ? [] : null;
+  const preparedStartByAnalysisIndex = Array.from({ length: analysis.len });
+  function pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, breakableFitAdvance) {
+    if (kind !== "text" && kind !== "space" && kind !== "zero-width-break") {
+      simpleLineWalkFastPath = false;
+    }
+    widths.push(width);
+    lineEndFitAdvances.push(lineEndFitAdvance);
+    lineEndPaintAdvances.push(lineEndPaintAdvance);
+    kinds.push(kind);
+    segStarts?.push(start);
+    breakableFitAdvances.push(breakableFitAdvance);
+    if (segments !== null)
+      segments.push(text);
+  }
+  function pushMeasuredTextSegment(text, kind, start, wordLike, allowOverflowBreaks) {
+    const textMetrics = getSegmentMetrics(text, cache);
+    const width = getCorrectedSegmentWidth(text, textMetrics, emojiCorrection);
+    const lineEndFitAdvance = kind === "space" || kind === "preserved-space" || kind === "zero-width-break" ? 0 : width;
+    const lineEndPaintAdvance = kind === "space" || kind === "zero-width-break" ? 0 : width;
+    if (allowOverflowBreaks && wordLike && text.length > 1) {
+      let fitMode = "sum-graphemes";
+      if (isNumericRunSegment(text)) {
+        fitMode = "pair-context";
+      } else if (engineProfile.preferPrefixWidthsForBreakableRuns) {
+        fitMode = "segment-prefixes";
+      }
+      const fitAdvances = getSegmentBreakableFitAdvances(text, textMetrics, cache, emojiCorrection, fitMode);
+      pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, fitAdvances);
+      return;
+    }
+    pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, null);
+  }
+  for (let mi = 0; mi < analysis.len; mi++) {
+    preparedStartByAnalysisIndex[mi] = widths.length;
+    const segText = analysis.texts[mi];
+    const segWordLike = analysis.isWordLike[mi];
+    const segKind = analysis.kinds[mi];
+    const segStart = analysis.starts[mi];
+    if (segKind === "soft-hyphen") {
+      pushMeasuredSegment(segText, 0, discretionaryHyphenWidth, discretionaryHyphenWidth, segKind, segStart, null);
+      continue;
+    }
+    if (segKind === "hard-break") {
+      pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null);
+      continue;
+    }
+    if (segKind === "tab") {
+      pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null);
+      continue;
+    }
+    const segMetrics = getSegmentMetrics(segText, cache);
+    if (segKind === "text" && segMetrics.containsCJK) {
+      const baseUnits = buildBaseCjkUnits(segText, engineProfile);
+      const measuredUnits = wordBreak === "keep-all" ? mergeKeepAllTextUnits(baseUnits) : baseUnits;
+      for (let i2 = 0; i2 < measuredUnits.length; i2++) {
+        const unit = measuredUnits[i2];
+        pushMeasuredTextSegment(unit.text, "text", segStart + unit.start, segWordLike, wordBreak === "keep-all" || !isCJK(unit.text));
+      }
+      continue;
+    }
+    pushMeasuredTextSegment(segText, segKind, segStart, segWordLike, true);
+  }
+  const chunks = mapAnalysisChunksToPreparedChunks(analysis.chunks, preparedStartByAnalysisIndex, widths.length);
+  const segLevels = segStarts === null ? null : computeSegmentLevels(analysis.normalized, segStarts);
+  if (segments !== null) {
+    return {
+      widths,
+      lineEndFitAdvances,
+      lineEndPaintAdvances,
+      kinds,
+      simpleLineWalkFastPath,
+      segLevels,
+      breakableFitAdvances,
+      discretionaryHyphenWidth,
+      tabStopAdvance,
+      chunks,
+      segments
+    };
+  }
+  return {
+    widths,
+    lineEndFitAdvances,
+    lineEndPaintAdvances,
+    kinds,
+    simpleLineWalkFastPath,
+    segLevels,
+    breakableFitAdvances,
+    discretionaryHyphenWidth,
+    tabStopAdvance,
+    chunks
+  };
+}
+function mapAnalysisChunksToPreparedChunks(chunks, preparedStartByAnalysisIndex, preparedEndSegmentIndex) {
+  const preparedChunks = [];
+  for (let i2 = 0; i2 < chunks.length; i2++) {
+    const chunk = chunks[i2];
+    const startSegmentIndex = chunk.startSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.startSegmentIndex] : preparedEndSegmentIndex;
+    const endSegmentIndex = chunk.endSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.endSegmentIndex] : preparedEndSegmentIndex;
+    const consumedEndSegmentIndex = chunk.consumedEndSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.consumedEndSegmentIndex] : preparedEndSegmentIndex;
+    preparedChunks.push({
+      startSegmentIndex,
+      endSegmentIndex,
+      consumedEndSegmentIndex
+    });
+  }
+  return preparedChunks;
+}
+function prepareInternal(text, font, includeSegments, options) {
+  const wordBreak = options?.wordBreak ?? "normal";
+  const analysis = analyzeText(text, getEngineProfile(), options?.whiteSpace, wordBreak);
+  return measureAnalysis(analysis, font, includeSegments, wordBreak);
+}
+function prepare(text, font, options) {
+  return prepareInternal(text, font, false, options);
+}
+function getInternalPrepared(prepared) {
+  return prepared;
+}
+function layout(prepared, maxWidth, lineHeight) {
+  const lineCount = countPreparedLines(getInternalPrepared(prepared), maxWidth);
+  return { lineCount, height: lineCount * lineHeight };
+}
+var sharedGraphemeSegmenter2;
 var init_layout = __esm({
   "../../node_modules/.bun/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/layout.js"() {
     "use strict";
@@ -4892,14 +8962,37 @@ var init_layout = __esm({
     init_analysis();
     init_measurement();
     init_line_break();
+    sharedGraphemeSegmenter2 = null;
   }
 });
 // ../core/src/text/fitTextFontSize.ts
+function fitTextFontSize(text, options) {
+  const opts = { ...DEFAULTS, ...options };
+  const lineHeightRatio = 1.2;
+  for (let size = opts.baseFontSize; size >= opts.minFontSize; size -= opts.step) {
+    const font = `${opts.fontWeight} ${size}px ${opts.fontFamily}`;
+    const prepared = prepare(text, font);
+    const { lineCount } = layout(prepared, opts.maxWidth, size * lineHeightRatio);
+    if (lineCount <= 1) {
+      return { fontSize: size, fits: true };
+    }
+  }
+  return { fontSize: opts.minFontSize, fits: false };
+}
+var DEFAULTS;
 var init_fitTextFontSize = __esm({
   "../core/src/text/fitTextFontSize.ts"() {
     "use strict";
     init_layout();
+    DEFAULTS = {
+      maxWidth: 1600,
+      baseFontSize: 78,
+      minFontSize: 42,
+      fontWeight: 900,
+      fontFamily: "Outfit",
+      step: 2
+    };
   }
 });
@@ -4912,10 +9005,31 @@ var init_text = __esm({
 });
 // ../core/src/registry/types.ts
-var ITEM_TYPE_DIRS;
+function isExampleItem(item) {
+  return item.type === "hyperframes:example";
+}
+function isBlockItem(item) {
+  return item.type === "hyperframes:block";
+}
+function isComponentItem(item) {
+  return item.type === "hyperframes:component";
+}
+var ITEM_TYPES, FILE_TYPES, ITEM_TYPE_DIRS;
 var init_types = __esm({
   "../core/src/registry/types.ts"() {
     "use strict";
+    ITEM_TYPES = [
+      "hyperframes:example",
+      "hyperframes:block",
+      "hyperframes:component"
+    ];
+    FILE_TYPES = [
+      "hyperframes:composition",
+      "hyperframes:asset",
+      "hyperframes:snippet",
+      "hyperframes:style",
+      "hyperframes:timeline"
+    ];
     ITEM_TYPE_DIRS = {
       "hyperframes:example": "examples",
       "hyperframes:block": "blocks",
@@ -4933,6 +9047,75 @@ var init_registry = __esm({
 });
 // ../core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BASE_STYLES: () => BASE_STYLES,
+  CANVAS_DIMENSIONS: () => CANVAS_DIMENSIONS,
+  DEFAULT_DURATIONS: () => DEFAULT_DURATIONS,
+  ELEMENT_BASE_STYLES: () => ELEMENT_BASE_STYLES,
+  FILE_TYPES: () => FILE_TYPES,
+  GSAP_CDN: () => GSAP_CDN,
+  HYPERFRAME_BRIDGE_SOURCES: () => HYPERFRAME_BRIDGE_SOURCES,
+  HYPERFRAME_CONTROL_ACTIONS: () => HYPERFRAME_CONTROL_ACTIONS,
+  HYPERFRAME_RUNTIME_ARTIFACTS: () => HYPERFRAME_RUNTIME_ARTIFACTS,
+  HYPERFRAME_RUNTIME_CONTRACT: () => HYPERFRAME_RUNTIME_CONTRACT,
+  HYPERFRAME_RUNTIME_GLOBALS: () => HYPERFRAME_RUNTIME_GLOBALS,
+  ITEM_TYPES: () => ITEM_TYPES,
+  ITEM_TYPE_DIRS: () => ITEM_TYPE_DIRS,
+  MEDIA_STYLES: () => MEDIA_STYLES,
+  MEDIA_VISUAL_STYLE_PROPERTIES: () => MEDIA_VISUAL_STYLE_PROPERTIES,
+  SUPPORTED_EASES: () => SUPPORTED_EASES,
+  SUPPORTED_PROPS: () => SUPPORTED_PROPS,
+  TEXT_STYLES: () => TEXT_STYLES,
+  TIMELINE_COLORS: () => TIMELINE_COLORS,
+  ZOOM_CONTAINER_STYLES: () => ZOOM_CONTAINER_STYLES,
+  addAnimationToScript: () => addAnimationToScript,
+  addElementToHtml: () => addElementToHtml,
+  buildHyperframesRuntimeScript: () => buildHyperframesRuntimeScript,
+  clampDurations: () => clampDurations,
+  compileTimingAttrs: () => compileTimingAttrs,
+  copyMediaVisualStyles: () => copyMediaVisualStyles,
+  createGSAPFrameAdapter: () => createGSAPFrameAdapter,
+  extractCompositionMetadata: () => extractCompositionMetadata,
+  extractResolvedMedia: () => extractResolvedMedia,
+  fitTextFontSize: () => fitTextFontSize,
+  generateBaseHtml: () => generateBaseHtml,
+  generateGsapTimelineScript: () => generateGsapTimelineScript,
+  generateHyperframesHtml: () => generateHyperframesHtml,
+  generateHyperframesStyles: () => generateHyperframesStyles,
+  getAnimationsForElement: () => getAnimationsForElement,
+  getDefaultStageZoom: () => getDefaultStageZoom,
+  getStageStyles: () => getStageStyles,
+  gsapAnimationsToKeyframes: () => gsapAnimationsToKeyframes,
+  injectDurations: () => injectDurations,
+  isBlockItem: () => isBlockItem,
+  isBooleanVariable: () => isBooleanVariable,
+  isColorVariable: () => isColorVariable,
+  isComponentItem: () => isComponentItem,
+  isCompositionElement: () => isCompositionElement,
+  isEnumVariable: () => isEnumVariable,
+  isExampleItem: () => isExampleItem,
+  isMediaElement: () => isMediaElement,
+  isNumberVariable: () => isNumberVariable,
+  isStringVariable: () => isStringVariable,
+  isTextElement: () => isTextElement,
+  keyframesToGsapAnimations: () => keyframesToGsapAnimations,
+  lintHyperframeHtml: () => lintHyperframeHtml,
+  loadHyperframeRuntimeSource: () => loadHyperframeRuntimeSource,
+  parseGsapScript: () => parseGsapScript,
+  parseHtml: () => parseHtml,
+  quantizeTimeToFrame: () => quantizeTimeToFrame,
+  removeAnimationFromScript: () => removeAnimationFromScript,
+  removeElementFromHtml: () => removeElementFromHtml,
+  rewriteAssetPath: () => rewriteAssetPath,
+  rewriteAssetPaths: () => rewriteAssetPaths,
+  rewriteCssAssetUrls: () => rewriteCssAssetUrls,
+  serializeGsapAnimations: () => serializeGsapAnimations,
+  updateAnimationInScript: () => updateAnimationInScript,
+  updateElementInHtml: () => updateElementInHtml,
+  validateCompositionGsap: () => validateCompositionGsap,
+  validateCompositionHtml: () => validateCompositionHtml
+});
 var init_src = __esm({
   "../core/src/index.ts"() {
     "use strict";
@@ -6843,6 +11026,24 @@ var init_fileWatcher = __esm({
   }
 });
+// src/server/runtimeSource.ts
+async function loadRuntimeSourceFallback() {
+  try {
+    const mod = await Promise.resolve().then(() => (init_src(), src_exports));
+    if (typeof mod.loadHyperframeRuntimeSource === "function") {
+      return mod.loadHyperframeRuntimeSource();
+    }
+  } catch (err) {
+    console.warn("[studio] Failed to load runtime source fallback:", err);
+  }
+  return null;
+}
+var init_runtimeSource = __esm({
+  "src/server/runtimeSource.ts"() {
+    "use strict";
+  }
+});
 // ../core/src/studio-api/helpers/safePath.ts
 import { resolve as resolve7, sep, join as join10 } from "path";
 import { readdirSync as readdirSync3 } from "fs";
@@ -20185,6 +24386,7 @@ function registerThumbnailRoutes(api, adapter2) {
     const seekTime = parseFloat(url.searchParams.get("t") || "0.5") || 0.5;
     const vpWidth = parseInt(url.searchParams.get("w") || "0") || 0;
     const vpHeight = parseInt(url.searchParams.get("h") || "0") || 0;
+    const selector = url.searchParams.get("selector") || void 0;
     let compW = vpWidth || 1920;
     let compH = vpHeight || 1080;
     if (!vpWidth) {
@@ -20199,7 +24401,8 @@ function registerThumbnailRoutes(api, adapter2) {
     }
     const previewUrl = compPath === "index.html" ? `http://${c2.req.header("host")}/api/projects/${project.id}/preview` : `http://${c2.req.header("host")}/api/projects/${project.id}/preview/comp/${compPath}`;
     const cacheDir = join15(project.dir, ".thumbnails");
-    const cacheKey = `${compPath.replace(/\//g, "_")}_${seekTime.toFixed(2)}.jpg`;
+    const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}` : "";
+    const cacheKey = `${THUMBNAIL_CACHE_VERSION}_${compPath.replace(/\//g, "_")}_${seekTime.toFixed(2)}${selectorKey}.jpg`;
     const cachePath2 = join15(cacheDir, cacheKey);
     if (existsSync11(cachePath2)) {
       return new Response(new Uint8Array(readFileSync13(cachePath2)), {
@@ -20213,7 +24416,8 @@ function registerThumbnailRoutes(api, adapter2) {
         seekTime,
         width: compW,
         height: compH,
-        previewUrl
+        previewUrl,
+        selector
       });
       if (!buffer) {
         return c2.json({ error: "Thumbnail generation returned null" }, 500);
@@ -20229,9 +24433,11 @@ function registerThumbnailRoutes(api, adapter2) {
     }
   });
 }
+var THUMBNAIL_CACHE_VERSION;
 var init_thumbnail = __esm({
   "../core/src/studio-api/routes/thumbnail.ts"() {
     "use strict";
+    THUMBNAIL_CACHE_VERSION = "v2";
   }
 });
@@ -25360,8 +29566,8 @@ var init_hdrCapture = __esm({
 });
 // ../engine/src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var src_exports2 = {};
+__export(src_exports2, {
   DEFAULT_CONFIG: () => DEFAULT_CONFIG2,
   DEFAULT_HDR10_MASTERING: () => DEFAULT_HDR10_MASTERING,
   DOM_LAYER_MASK_STYLE_ID: () => DOM_LAYER_MASK_STYLE_ID,
@@ -30207,8 +34413,8 @@ var init_parityContract2 = __esm({
 });
 // ../producer/src/index.ts
-var src_exports2 = {};
-__export(src_exports2, {
+var src_exports3 = {};
+__export(src_exports3, {
   DEFAULT_CONFIG: () => DEFAULT_CONFIG2,
   RenderCancelledError: () => RenderCancelledError,
   captureFrame: () => captureFrame,
@@ -30287,7 +34493,7 @@ async function getThumbnailBrowser() {
   _thumbnailBrowserInitializing = (async () => {
     try {
       const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
-      const { acquireBrowser: acquireBrowser2, buildChromeArgs: buildChromeArgs2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+      const { acquireBrowser: acquireBrowser2, buildChromeArgs: buildChromeArgs2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
       try {
         const b = await ensureBrowser2();
         if (b.executablePath && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
@@ -30350,7 +34556,7 @@ function createStudioServer(options) {
       };
       (async () => {
         try {
-          const { createRenderJob: createRenderJob2, executeRenderJob: executeRenderJob2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
+          const { createRenderJob: createRenderJob2, executeRenderJob: executeRenderJob2 } = await Promise.resolve().then(() => (init_src3(), src_exports3));
           const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
           try {
             const browser = await ensureBrowser2();
@@ -30410,7 +34616,31 @@ function createStudioServer(options) {
           }
         }, opts.seekTime);
         await new Promise((r2) => setTimeout(r2, 200));
-        const screenshot = await page.screenshot({ type: "jpeg", quality: 80 });
+        let clip;
+        if (opts.selector) {
+          clip = await page.evaluate((selector) => {
+            const el = document.querySelector(selector);
+            if (!(el instanceof HTMLElement)) return void 0;
+            const rect = el.getBoundingClientRect();
+            if (rect.width < 4 || rect.height < 4) return void 0;
+            const pad = 8;
+            const x4 = Math.max(0, rect.left - pad);
+            const y2 = Math.max(0, rect.top - pad);
+            const maxWidth = window.innerWidth - x4;
+            const maxHeight = window.innerHeight - y2;
+            return {
+              x: x4,
+              y: y2,
+              width: Math.max(1, Math.min(rect.width + pad * 2, maxWidth)),
+              height: Math.max(1, Math.min(rect.height + pad * 2, maxHeight))
+            };
+          }, opts.selector);
+        }
+        const screenshot = await page.screenshot({
+          type: "jpeg",
+          quality: 80,
+          ...clip ? { clip } : {}
+        });
         return screenshot;
       } catch {
         return null;
@@ -30430,11 +34660,15 @@ function createStudioServer(options) {
     });
   });
   app.get("/api/runtime.js", (c2) => {
-    if (!existsSync31(runtimePath)) return c2.text("runtime not built", 404);
-    return c2.body(readFileSync23(runtimePath, "utf-8"), 200, {
-      "Content-Type": "text/javascript",
-      "Cache-Control": "no-store"
-    });
+    const serve4 = async () => {
+      const runtimeSource = existsSync31(runtimePath) ? readFileSync23(runtimePath, "utf-8") : await loadRuntimeSourceFallback();
+      if (!runtimeSource) return c2.text("runtime not available", 404);
+      return c2.body(runtimeSource, 200, {
+        "Content-Type": "text/javascript",
+        "Cache-Control": "no-store"
+      });
+    };
+    return serve4();
   });
   app.get("/api/events", (c2) => {
     return streamSSE3(c2, async (stream) => {
@@ -30491,6 +34725,7 @@ var init_studioServer = __esm({
   "src/server/studioServer.ts"() {
     "use strict";
     init_fileWatcher();
+    init_runtimeSource();
     init_version();
     init_studio_api();
     _thumbnailBrowser = null;
@@ -32061,7 +36296,7 @@ var init_play = __esm({
 // src/utils/producer.ts
 async function loadProducer() {
-  return await Promise.resolve().then(() => (init_src3(), src_exports2));
+  return await Promise.resolve().then(() => (init_src3(), src_exports3));
 }
 var init_producer = __esm({
   "src/utils/producer.ts"() {
@@ -35032,7 +39267,7 @@ async function captureSnapshots(projectDir, opts) {
       let injectVideoFramesBatch2 = null;
       let syncVideoFrameVisibility2 = null;
       try {
-        const engine = await Promise.resolve().then(() => (init_src2(), src_exports));
+        const engine = await Promise.resolve().then(() => (init_src2(), src_exports2));
         injectVideoFramesBatch2 = engine.injectVideoFramesBatch;
         syncVideoFrameVisibility2 = engine.syncVideoFrameVisibility;
       } catch {
@@ -44747,8 +48982,8 @@ var init_abort_error = __esm({
 });
 // ../../node_modules/.bun/node-fetch@3.3.2/node_modules/node-fetch/src/index.js
-var src_exports3 = {};
-__export(src_exports3, {
+var src_exports4 = {};
+__export(src_exports4, {
   AbortError: () => AbortError,
   Blob: () => fetch_blob_default,
   FetchError: () => FetchError,
@@ -45489,7 +49724,7 @@ Content-Type: ${partContentType}\r
       }
       static async #getFetch() {
         const hasWindow = typeof window !== "undefined" && !!window;
-        this.#fetch ||= hasWindow ? window.fetch : (await Promise.resolve().then(() => (init_src4(), src_exports3))).default;
+        this.#fetch ||= hasWindow ? window.fetch : (await Promise.resolve().then(() => (init_src4(), src_exports4))).default;
         return this.#fetch;
       }
       /**