@hyperframes/lint 0.7.15 → 0.7.17

package/dist/browser.js

@@ -0,0 +1,3276 @@
+// src/utils.ts
+var TAG_PATTERN = /<([a-z][\w:-]*)(\s[^<>]*?)?>/gi;
+var STYLE_BLOCK_PATTERN = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+var SCRIPT_BLOCK_PATTERN = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+var COMPOSITION_ID_IN_CSS_PATTERN = /\[data-composition-id=["']([^"']+)["']\]/g;
+var TIMELINE_REGISTRY_INIT_PATTERN = /window\.__timelines\s*=\s*window\.__timelines\s*\|\|\s*\{\}|window\.__timelines\s*=\s*\{\}|window\.__timelines\s*\?\?=\s*\{\}/i;
+var TIMELINE_REGISTRY_ASSIGN_PATTERN = /window\.__timelines(?:\[[^\]]+\]|\.[A-Za-z_$][\w$]*)\s*=/i;
+var WINDOW_TIMELINE_ASSIGN_PATTERN = /window\.__timelines(?:\[\s*["']([^"']+)["']\s*\]|\.\s*([A-Za-z_$][\w$]*))\s*=\s*([A-Za-z_$][\w$]*)/i;
+var INVALID_SCRIPT_CLOSE_PATTERN = /<script[^>]*>[\s\S]*?<\s*\/\s*script(?!>)/i;
+var TIMELINE_REGISTRY_KEY_PATTERN = /window\.__timelines(?:\[\s*["']([^"']+)["']\s*\]|\.\s*([A-Za-z_$][\w$]*))\s*=/g;
+function extractOpenTags(source) {
+  const tags = [];
+  let match;
+  const pattern = new RegExp(TAG_PATTERN.source, TAG_PATTERN.flags);
+  while ((match = pattern.exec(source)) !== null) {
+    const raw = match[0];
+    if (raw.startsWith("</") || raw.startsWith("<!")) continue;
+    tags.push({
+      raw,
+      name: (match[1] || "").toLowerCase(),
+      attrs: match[2] || "",
+      index: match.index
+    });
+  }
+  return tags;
+}
+function extractBlocks(source, pattern) {
+  const blocks = [];
+  let match;
+  const p = new RegExp(pattern.source, pattern.flags);
+  while ((match = p.exec(source)) !== null) {
+    blocks.push({
+      attrs: match[1] || "",
+      content: match[2] || "",
+      raw: match[0],
+      index: match.index
+    });
+  }
+  return blocks;
+}
+function findHtmlTag(source) {
+  const match = /<html\b([^<>]*)>/i.exec(source);
+  if (!match) return null;
+  return {
+    raw: match[0],
+    name: "html",
+    attrs: match[1] ?? "",
+    index: match.index
+  };
+}
+function findRootTag(source) {
+  const bodyOpenMatch = /<body\b([^>]*)>/i.exec(source);
+  const bodyCloseMatch = /<\/body>/i.exec(source);
+  if (bodyOpenMatch && (readAttr(bodyOpenMatch[0], "data-composition-id") || readAttr(bodyOpenMatch[0], "data-width") || readAttr(bodyOpenMatch[0], "data-height"))) {
+    return {
+      raw: bodyOpenMatch[0],
+      name: "body",
+      attrs: bodyOpenMatch[1] ?? "",
+      index: bodyOpenMatch.index
+    };
+  }
+  const bodyStart = bodyOpenMatch ? bodyOpenMatch.index + bodyOpenMatch[0].length : 0;
+  const bodyEnd = bodyOpenMatch && bodyCloseMatch && bodyCloseMatch.index > bodyStart ? bodyCloseMatch.index : source.length;
+  const bodyContent = bodyOpenMatch ? source.slice(bodyStart, bodyEnd) : source;
+  const bodyTags = extractOpenTags(bodyContent);
+  for (const tag of bodyTags) {
+    if (["script", "style", "meta", "link", "title"].includes(tag.name)) continue;
+    return { ...tag, index: tag.index + bodyStart };
+  }
+  return null;
+}
+function readAttr(tagSource, attr) {
+  if (!tagSource) return null;
+  const escaped = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = tagSource.match(new RegExp(`\\b${escaped}\\s*=\\s*["']([^"']+)["']`, "i"));
+  return match?.[1] || null;
+}
+function readJsonAttr(tagSource, attr) {
+  if (!tagSource) return null;
+  const escaped = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = tagSource.match(new RegExp(`\\b${escaped}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, "i"));
+  if (!match) return null;
+  return match[1] ?? match[2] ?? null;
+}
+function collectCompositionIds(tags) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const tag of tags) {
+    const compId = readAttr(tag.raw, "data-composition-id");
+    if (compId) ids.add(compId);
+  }
+  return ids;
+}
+function extractCompositionIdsFromCss(css) {
+  const ids = /* @__PURE__ */ new Set();
+  let match;
+  const pattern = new RegExp(
+    COMPOSITION_ID_IN_CSS_PATTERN.source,
+    COMPOSITION_ID_IN_CSS_PATTERN.flags
+  );
+  while ((match = pattern.exec(css)) !== null) {
+    if (match[1]) ids.add(match[1]);
+  }
+  return [...ids];
+}
+function extractTimelineRegistryKeys(source) {
+  const keys = /* @__PURE__ */ new Set();
+  let match;
+  const pattern = new RegExp(
+    TIMELINE_REGISTRY_KEY_PATTERN.source,
+    TIMELINE_REGISTRY_KEY_PATTERN.flags
+  );
+  while ((match = pattern.exec(source)) !== null) {
+    const key = match[1] ?? match[2];
+    if (key) keys.add(key);
+  }
+  return [...keys];
+}
+function getInlineScriptSyntaxError(source) {
+  if (!source.trim()) return null;
+  try {
+    new Function(source);
+    return null;
+  } catch (error) {
+    if (error instanceof Error) return error.message;
+    return String(error);
+  }
+}
+function stripJsComments(source) {
+  let out = "";
+  let i = 0;
+  let quote = null;
+  let escaped = false;
+  while (i < source.length) {
+    const ch = source[i] ?? "";
+    const next = source[i + 1] ?? "";
+    if (quote) {
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = null;
+      }
+      i += 1;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      out += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      out += "  ";
+      i += 2;
+      while (i < source.length && source[i] !== "\n" && source[i] !== "\r") {
+        out += " ";
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      out += "  ";
+      i += 2;
+      while (i < source.length) {
+        const blockCh = source[i] ?? "";
+        const blockNext = source[i + 1] ?? "";
+        if (blockCh === "*" && blockNext === "/") {
+          out += "  ";
+          i += 2;
+          break;
+        }
+        out += blockCh === "\n" || blockCh === "\r" ? blockCh : " ";
+        i += 1;
+      }
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+function stripHtmlCommentsOnce(source) {
+  let out = "";
+  let i = 0;
+  for (; ; ) {
+    const start = source.indexOf("<!--", i);
+    if (start < 0) return out + source.slice(i);
+    const end = source.indexOf("-->", start + 4);
+    if (end < 0) return out + source.slice(i);
+    out += source.slice(i, start);
+    i = end + 3;
+  }
+}
+function stripHtmlComments(source) {
+  let out = source;
+  for (let prev = ""; prev !== out; ) {
+    prev = out;
+    out = stripHtmlCommentsOnce(out);
+  }
+  return out;
+}
+function extractScriptTextsAndSrcs(scripts) {
+  const texts = scripts.filter((s) => !/\bsrc\s*=/.test(s.attrs)).map((s) => s.content);
+  const srcs = scripts.map((s) => readAttr(`<script ${s.attrs}>`, "src") || "").filter(Boolean);
+  return { texts, srcs };
+}
+function isMediaTag(tagName) {
+  return tagName === "video" || tagName === "audio" || tagName === "img";
+}
+function truncateSnippet(value, maxLength = 220) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) return void 0;
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 3)}...`;
+}
+
+// src/context.ts
+function buildLintContext(html, options = {}) {
+  const rawSource = html || "";
+  let source = stripHtmlComments(rawSource);
+  const templateMatch = source.match(/<template[^>]*>([\s\S]*)<\/template>/i);
+  if (templateMatch?.[1]) source = templateMatch[1];
+  const tags = extractOpenTags(source);
+  const styles = [
+    ...extractBlocks(source, STYLE_BLOCK_PATTERN),
+    ...(options.externalStyles ?? []).map((style) => ({
+      attrs: `href="${style.href}"`,
+      content: style.content,
+      raw: style.content,
+      index: -1
+    }))
+  ];
+  const scripts = extractBlocks(source, SCRIPT_BLOCK_PATTERN);
+  const compositionIds = collectCompositionIds(tags);
+  const rootTag = findRootTag(source);
+  const rootCompositionId = readAttr(rootTag?.raw || "", "data-composition-id");
+  return {
+    source,
+    rawSource,
+    tags,
+    styles,
+    scripts,
+    compositionIds,
+    rootTag,
+    rootCompositionId,
+    options
+  };
+}
+
+// src/rules/core.ts
+import postcss from "postcss";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function selectorTargetsCompositionId(selector, compositionId) {
+  const escaped = escapeRegExp(compositionId);
+  return new RegExp(
+    String.raw`\[\s*data-composition-id\s*=\s*(?:"${escaped}"|'${escaped}')\s*\]`
+  ).test(selector);
+}
+function isStudioTimelineElement(tag) {
+  if (["script", "style", "link", "meta", "template", "noscript"].includes(tag.name)) {
+    return false;
+  }
+  return Boolean(
+    readAttr(tag.raw, "data-start") || readAttr(tag.raw, "data-track-index") || readAttr(tag.raw, "data-track") || readAttr(tag.raw, "data-composition-src") || readAttr(tag.raw, "data-composition-file")
+  );
+}
+function describeStudioElement(tag) {
+  const parts = [`<${tag.name}`];
+  const className = readAttr(tag.raw, "class");
+  const compositionId = readAttr(tag.raw, "data-composition-id");
+  const dataStart = readAttr(tag.raw, "data-start");
+  const dataTrack = readAttr(tag.raw, "data-track-index") ?? readAttr(tag.raw, "data-track");
+  if (className) {
+    const primaryClass = className.split(/\s+/).map((value) => value.trim()).find((value) => value && value !== "clip");
+    if (primaryClass) parts.push(` class="${primaryClass}"`);
+  }
+  if (compositionId) parts.push(` data-composition-id="${compositionId}"`);
+  if (dataStart) parts.push(` data-start="${dataStart}"`);
+  if (dataTrack) parts.push(` data-track-index="${dataTrack}"`);
+  parts.push(">");
+  return parts.join("");
+}
+var HEAD_BLOCKS_TO_IGNORE_PATTERN = /<(?:style|script|template|title|noscript)\b[^>]*>[\s\S]*?<\/(?:style|script|template|title|noscript)(?:\s[^>]*)?>/gi;
+var HTML_TAG_PATTERN = /<[^>]+>/g;
+var HEAD_CONTENT_PATTERN = /<head\b[^>]*>([\s\S]*?)(?:<\/head>|<body\b|$)/gi;
+var AFTER_HEAD_BEFORE_BODY_PATTERN = /<\/head(?:\s[^>]*)?>([\s\S]*?)(?=<body\b|$)/gi;
+var STRAY_HEAD_CLOSE_PATTERN = /<\/(?:style|script)(?:\s[^>]*)?>/i;
+var MARKDOWN_CODE_FENCE_PATTERN = /```[^\r\n`]*(?:\r?\n|$)[\s\S]*?```/i;
+var ORPHAN_CSS_AT_RULE_PATTERN = /(?:^|\s)@(?:container|font-face|keyframes|layer|media|page|property|scope|supports)[^{<]*\{[\s\S]*?:[\s\S]*?\}/i;
+var ORPHAN_CSS_RULE_PATTERN = /(?:^|\s)(?:\/\*[\s\S]*?\*\/\s*)?(?:@[a-z-]+[^{}<]*|[.#][\w-]+[^{}<]*|[a-z][\w-]*(?:\s+[.#:[\w-][^{}<]*)?)\s*\{[^{}]*:[^{}]*\}/i;
+function findCodeFenceLeak(headWithoutValidBlocks) {
+  return MARKDOWN_CODE_FENCE_PATTERN.exec(headWithoutValidBlocks)?.[0] ?? null;
+}
+function findOrphanCssLeak(headContent) {
+  const residualText = headContent.replace(HEAD_BLOCKS_TO_IGNORE_PATTERN, " ").replace(HTML_TAG_PATTERN, " ");
+  return ORPHAN_CSS_AT_RULE_PATTERN.exec(residualText)?.[0] ?? ORPHAN_CSS_RULE_PATTERN.exec(residualText)?.[0] ?? null;
+}
+function findStrayCloseLeak(headWithoutValidBlocks) {
+  return STRAY_HEAD_CLOSE_PATTERN.exec(headWithoutValidBlocks)?.[0] ?? null;
+}
+function findLeakedTextInHeadContent(headContent) {
+  const withoutValidBlocks = headContent.replace(HEAD_BLOCKS_TO_IGNORE_PATTERN, " ");
+  return findCodeFenceLeak(withoutValidBlocks) ?? findOrphanCssLeak(headContent) ?? findStrayCloseLeak(withoutValidBlocks);
+}
+function findLeakedTextInHead(rawSource) {
+  const headMatches = [...rawSource.matchAll(HEAD_CONTENT_PATTERN)];
+  for (const match of headMatches) {
+    const leakedText = findLeakedTextInHeadContent(match[1] ?? "");
+    if (leakedText) return leakedText;
+  }
+  return null;
+}
+function findLeakedTextBetweenHeadAndBody(rawSource) {
+  const boundaryMatches = [...rawSource.matchAll(AFTER_HEAD_BEFORE_BODY_PATTERN)];
+  for (const match of boundaryMatches) {
+    const leakedText = findLeakedTextInHeadContent(match[1] ?? "");
+    if (leakedText) return leakedText;
+  }
+  return null;
+}
+function findLeakedTextBeforeCompositionRoot(source, rootTag) {
+  if (!rootTag || rootTag.name === "body") return null;
+  const bodyOpenMatch = /<body\b[^>]*>/i.exec(source);
+  const prefixStart = bodyOpenMatch ? bodyOpenMatch.index + bodyOpenMatch[0].length : 0;
+  const prefixEnd = rootTag.index;
+  if (prefixEnd <= prefixStart) return null;
+  return findLeakedTextInHeadContent(source.slice(prefixStart, prefixEnd));
+}
+var coreRules = [
+  // root_missing_composition_id + root_missing_dimensions
+  ({ rootTag }) => {
+    const findings = [];
+    if (!rootTag || !readAttr(rootTag.raw, "data-composition-id")) {
+      findings.push({
+        code: "root_missing_composition_id",
+        severity: "error",
+        message: "Root composition is missing `data-composition-id`.",
+        elementId: rootTag ? readAttr(rootTag.raw, "id") || void 0 : void 0,
+        fixHint: "Add a stable `data-composition-id` to the entry composition wrapper.",
+        snippet: truncateSnippet(rootTag?.raw || "")
+      });
+    }
+    if (!rootTag || !readAttr(rootTag.raw, "data-width") || !readAttr(rootTag.raw, "data-height")) {
+      findings.push({
+        code: "root_missing_dimensions",
+        severity: "error",
+        message: "Root composition is missing `data-width` or `data-height`.",
+        elementId: rootTag ? readAttr(rootTag.raw, "id") || void 0 : void 0,
+        fixHint: "Set numeric `data-width` and `data-height` on the entry composition root.",
+        snippet: truncateSnippet(rootTag?.raw || "")
+      });
+    }
+    return findings;
+  },
+  // head_leaked_text
+  ({ source, rootTag }) => {
+    const snippet = findLeakedTextInHead(source) ?? findLeakedTextBetweenHeadAndBody(source) ?? findLeakedTextBeforeCompositionRoot(source, rootTag);
+    if (!snippet) return [];
+    return [
+      {
+        code: "head_leaked_text",
+        severity: "error",
+        message: "Detected leaked code or CSS text around the document `<head>` or before the composition root. Browsers render this as visible text in the video.",
+        fixHint: "Move CSS into a single `<style>...</style>` block and remove stray close tags, markdown fences, or code text from `<head>`, the `</head>`/`<body>` boundary, or the pre-root body prefix.",
+        snippet: truncateSnippet(snippet)
+      }
+    ];
+  },
+  // missing_timeline_registry + timeline_registry_missing_init
+  ({ source, rawSource, options }) => {
+    if (options.isSubComposition || rawSource.trimStart().toLowerCase().startsWith("<template")) {
+      return [];
+    }
+    const findings = [];
+    if (!TIMELINE_REGISTRY_INIT_PATTERN.test(source) && !TIMELINE_REGISTRY_ASSIGN_PATTERN.test(source)) {
+      findings.push({
+        code: "missing_timeline_registry",
+        severity: "error",
+        message: "Missing `window.__timelines` registration.",
+        fixHint: "Register each composition timeline on `window.__timelines[compositionId]`."
+      });
+    }
+    if (TIMELINE_REGISTRY_ASSIGN_PATTERN.test(source) && !TIMELINE_REGISTRY_INIT_PATTERN.test(source)) {
+      findings.push({
+        code: "timeline_registry_missing_init",
+        severity: "error",
+        message: "`window.__timelines[\u2026] = \u2026` is used without initializing `window.__timelines` first.",
+        fixHint: "Add `window.__timelines = window.__timelines || {};` before any timeline assignment."
+      });
+    }
+    return findings;
+  },
+  // timeline_id_mismatch
+  ({ source }) => {
+    const findings = [];
+    const htmlCompIds = /* @__PURE__ */ new Set();
+    const timelineRegKeys = /* @__PURE__ */ new Set();
+    const compIdRe = /data-composition-id\s*=\s*["']([^"']+)["']/gi;
+    let m;
+    while ((m = compIdRe.exec(source)) !== null) {
+      if (m[1]) htmlCompIds.add(m[1]);
+    }
+    for (const key of extractTimelineRegistryKeys(source)) {
+      timelineRegKeys.add(key);
+    }
+    for (const key of timelineRegKeys) {
+      if (!htmlCompIds.has(key)) {
+        findings.push({
+          code: "timeline_id_mismatch",
+          severity: "error",
+          message: `Timeline registered as "${key}" but no element has data-composition-id="${key}". The runtime cannot auto-nest this timeline.`,
+          fixHint: `Change window.__timelines["${key}"] to match the data-composition-id attribute, or vice versa.`
+        });
+      }
+    }
+    return findings;
+  },
+  // invalid_inline_script_syntax (malformed close tag)
+  ({ source }) => {
+    if (!INVALID_SCRIPT_CLOSE_PATTERN.test(source)) return [];
+    return [
+      {
+        code: "invalid_inline_script_syntax",
+        severity: "error",
+        message: "Detected malformed inline `<script>` closing syntax.",
+        fixHint: "Close inline scripts with a valid `<\/script>` tag."
+      }
+    ];
+  },
+  // invalid_inline_script_syntax (JS parse error)
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const attrs = script.attrs || "";
+      if (/\bsrc\s*=/.test(attrs) || /\btype\s*=\s*["'](?:application\/json|application\/hyperframes-slideshow\+json|importmap|module)["']/.test(
+        attrs
+      ))
+        continue;
+      const syntaxError = getInlineScriptSyntaxError(script.content);
+      if (!syntaxError) continue;
+      findings.push({
+        code: "invalid_inline_script_syntax",
+        severity: "error",
+        message: `Inline script has invalid syntax: ${syntaxError}`,
+        fixHint: "Fix the inline script syntax before render verification.",
+        snippet: truncateSnippet(script.content)
+      });
+    }
+    return findings;
+  },
+  // host_missing_composition_id
+  ({ tags }) => {
+    const findings = [];
+    for (const tag of tags) {
+      const src = readAttr(tag.raw, "data-composition-src");
+      if (!src) continue;
+      if (readAttr(tag.raw, "data-composition-id")) continue;
+      findings.push({
+        code: "host_missing_composition_id",
+        severity: "error",
+        message: `Composition host for "${src}" is missing \`data-composition-id\`.`,
+        elementId: readAttr(tag.raw, "id") || void 0,
+        fixHint: "Set `data-composition-id` on every `data-composition-src` host element.",
+        snippet: truncateSnippet(tag.raw)
+      });
+    }
+    return findings;
+  },
+  // scoped_css_missing_wrapper
+  ({ styles, compositionIds }) => {
+    const findings = [];
+    const scopedCssCompositionIds = /* @__PURE__ */ new Set();
+    for (const style of styles) {
+      for (const compId of extractCompositionIdsFromCss(style.content)) {
+        scopedCssCompositionIds.add(compId);
+      }
+    }
+    for (const compId of scopedCssCompositionIds) {
+      if (compositionIds.has(compId)) continue;
+      findings.push({
+        code: "scoped_css_missing_wrapper",
+        severity: "warning",
+        message: `Scoped CSS targets composition "${compId}" but no matching wrapper exists in this HTML.`,
+        selector: `[data-composition-id="${compId}"]`,
+        fixHint: "Preserve the matching composition wrapper or align the CSS scope to an existing wrapper."
+      });
+    }
+    return findings;
+  },
+  // composition_self_attribute_selector
+  ({ styles, rootCompositionId, rootTag }) => {
+    const findings = [];
+    if (!rootCompositionId) return findings;
+    const seenSelectors = /* @__PURE__ */ new Set();
+    const rootId = readAttr(rootTag?.raw || "", "id");
+    for (const style of styles) {
+      let root;
+      try {
+        root = postcss.parse(style.content);
+      } catch {
+        continue;
+      }
+      root.walkRules((rule) => {
+        for (const selector of rule.selectors) {
+          if (!selectorTargetsCompositionId(selector, rootCompositionId)) continue;
+          if (seenSelectors.has(selector)) continue;
+          seenSelectors.add(selector);
+          findings.push({
+            code: "composition_self_attribute_selector",
+            severity: "warning",
+            message: "Selector matches the block's own id; will leak to sibling instances when the block is embedded twice.",
+            selector,
+            fixHint: rootId ? `Use #${rootId} for clearer authoring intent and instance-isolated styling.` : "Add a stable id to the composition root and use that id selector for clearer authoring intent and instance-isolated styling."
+          });
+        }
+      });
+    }
+    return findings;
+  },
+  // studio_missing_editable_id
+  ({ tags, rootTag }) => {
+    const findings = [];
+    for (const tag of tags) {
+      if (rootTag && tag.index === rootTag.index) continue;
+      if (!isStudioTimelineElement(tag)) continue;
+      if (readAttr(tag.raw, "id")) continue;
+      const descriptor = describeStudioElement(tag);
+      findings.push({
+        code: "studio_missing_editable_id",
+        severity: "warning",
+        message: `${descriptor} has no id, so Studio cannot use a stable edit target for its timeline and canvas controls.`,
+        selector: readAttr(tag.raw, "data-composition-id") ? `[data-composition-id="${readAttr(tag.raw, "data-composition-id")}"]` : void 0,
+        fixHint: 'Add a stable, human-readable id such as id="hero-title" or id="scene-1-card" to every timeline-visible element you want agents or Studio to edit.',
+        snippet: truncateSnippet(tag.raw)
+      });
+    }
+    return findings;
+  },
+  // non_deterministic_code
+  ({ scripts }) => {
+    const findings = [];
+    const patterns = [
+      {
+        pattern: /Math\.random\s*\(/,
+        label: "Math.random()",
+        hint: "Use a seeded PRNG (e.g. a simple mulberry32) so renders are deterministic across frames."
+      },
+      {
+        pattern: /Date\.now\s*\(/,
+        label: "Date.now()",
+        hint: "Remove time-dependent code. Use GSAP timeline position instead of wall-clock time."
+      },
+      {
+        pattern: /new\s+Date\s*\(/,
+        label: "new Date()",
+        hint: "Remove time-dependent code. Use GSAP timeline position instead of wall-clock time."
+      },
+      {
+        pattern: /performance\.now\s*\(/,
+        label: "performance.now()",
+        hint: "Remove time-dependent code. Use GSAP timeline position instead of wall-clock time."
+      },
+      {
+        pattern: /crypto\.getRandomValues\s*\(/,
+        label: "crypto.getRandomValues()",
+        hint: "Remove time-dependent code. Use a seeded PRNG for deterministic renders."
+      }
+    ];
+    for (const script of scripts) {
+      const stripped = stripJsComments(script.content);
+      for (const { pattern, label, hint } of patterns) {
+        if (pattern.test(stripped)) {
+          findings.push({
+            code: "non_deterministic_code",
+            severity: "error",
+            message: `Script contains \`${label}\` which produces non-deterministic output. Renders may differ between frames or runs.`,
+            fixHint: hint,
+            snippet: truncateSnippet(script.content)
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // pointer_events_none
+  // fallow-ignore-next-line complexity
+  ({ tags, styles }) => {
+    const findings = [];
+    const reported = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      if (["script", "style", "link", "meta", "template", "noscript"].includes(tag.name)) continue;
+      const inlineStyle = readAttr(tag.raw, "style") ?? "";
+      if (!/pointer-events\s*:\s*none/i.test(inlineStyle)) continue;
+      const id = readAttr(tag.raw, "id");
+      const key = id ?? tag.raw;
+      if (reported.has(key)) continue;
+      reported.add(key);
+      findings.push({
+        code: "pointer_events_none",
+        severity: "info",
+        message: `<${tag.name}${id ? ` id="${id}"` : ""}> has \`pointer-events: none\` in its inline style. Elements with this property are harder to select in the Studio preview.`,
+        elementId: id || void 0,
+        fixHint: "If this element should be selectable in the Studio, remove `pointer-events: none` or move it to a wrapper that doesn't contain editable content.",
+        snippet: truncateSnippet(tag.raw)
+      });
+    }
+    for (const style of styles) {
+      let root;
+      try {
+        root = postcss.parse(style.content);
+      } catch {
+        continue;
+      }
+      root.walkDecls("pointer-events", (decl) => {
+        if (decl.value.trim().toLowerCase() !== "none") return;
+        const rule = decl.parent;
+        if (!rule || rule.type !== "rule") return;
+        const selector = rule.selector;
+        if (reported.has(selector)) return;
+        reported.add(selector);
+        findings.push({
+          code: "pointer_events_none",
+          severity: "info",
+          message: `\`${selector}\` sets \`pointer-events: none\`. Elements matching this selector are harder to select in the Studio preview.`,
+          selector,
+          fixHint: "If these elements should be selectable in the Studio, remove `pointer-events: none` or move it to a wrapper that doesn't contain editable content."
+        });
+      });
+    }
+    return findings;
+  }
+];
+
+// src/rules/media.ts
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasAttrName(tagSource, attr) {
+  const escaped = escapeRegExp2(attr);
+  const attrs = tagSource.replace(/^<\s*[a-z][\w:-]*/i, "");
+  return new RegExp(`(?:^|\\s)${escaped}(?:\\s*=|\\s|/?>)`, "i").test(attrs);
+}
+function classNamesFromAttr(classAttr) {
+  if (!classAttr) return [];
+  return classAttr.split(/\s+/).filter(Boolean);
+}
+function selectorTargetsManagedMedia(selector, mediaIndex) {
+  const normalized = selector.trim();
+  if (!normalized) return false;
+  if (mediaIndex.hasVideo && /\bvideo\b/i.test(normalized)) return true;
+  if (mediaIndex.hasAudio && /\baudio\b/i.test(normalized)) return true;
+  for (const mediaId of mediaIndex.ids) {
+    const escapedId = escapeRegExp2(mediaId);
+    if (new RegExp(`#${escapedId}(?![\\w-])`).test(normalized) || normalized.includes(`[id="${mediaId}"]`) || normalized.includes(`[id='${mediaId}']`)) {
+      return true;
+    }
+  }
+  for (const className of mediaIndex.classes) {
+    if (new RegExp(`\\.${escapeRegExp2(className)}(?![\\w-])`).test(normalized)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findImperativeMediaControlFindings(ctx) {
+  const findings = [];
+  const mediaTags = ctx.tags.filter((tag) => tag.name === "video" || tag.name === "audio");
+  const mediaIndex = {
+    ids: new Set(
+      mediaTags.map((tag) => readAttr(tag.raw, "id")).filter((id) => Boolean(id))
+    ),
+    classes: new Set(mediaTags.flatMap((tag) => classNamesFromAttr(readAttr(tag.raw, "class")))),
+    hasVideo: mediaTags.some((tag) => tag.name === "video"),
+    hasAudio: mediaTags.some((tag) => tag.name === "audio")
+  };
+  if (mediaTags.length === 0 || ctx.scripts.length === 0) return findings;
+  for (const script of ctx.scripts) {
+    const mediaVars = /* @__PURE__ */ new Map();
+    const assignmentPatterns = [
+      {
+        pattern: /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:document|window\.document)\.getElementById\(\s*["']([^"']+)["']\s*\)/g,
+        variableIndex: 1,
+        targetIndex: 2
+      },
+      {
+        pattern: /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:document|window\.document)\.querySelector\(\s*(["'])([\s\S]*?)\2\s*\)/g,
+        variableIndex: 1,
+        targetIndex: 3
+      }
+    ];
+    for (const { pattern, variableIndex, targetIndex } of assignmentPatterns) {
+      let match;
+      while ((match = pattern.exec(script.content)) !== null) {
+        const variableName = match[variableIndex];
+        const target = match[targetIndex];
+        if (!variableName || !target) continue;
+        if (mediaIndex.ids.has(target) || selectorTargetsManagedMedia(target, mediaIndex)) {
+          mediaVars.set(variableName, mediaIndex.ids.has(target) ? target : void 0);
+        }
+      }
+    }
+    const directIdPatterns = [
+      {
+        pattern: /\b(?:document|window\.document)\.getElementById\(\s*["']([^"']+)["']\s*\)\.play\s*\(/g,
+        kind: "play()",
+        targetIndex: 1
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.getElementById\(\s*["']([^"']+)["']\s*\)\.pause\s*\(/g,
+        kind: "pause()",
+        targetIndex: 1
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.getElementById\(\s*["']([^"']+)["']\s*\)\.currentTime\s*=/g,
+        kind: "currentTime",
+        targetIndex: 1
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.getElementById\(\s*["']([^"']+)["']\s*\)\.muted\s*=/g,
+        kind: "muted assignment",
+        targetIndex: 1
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.querySelector\(\s*(["'])([\s\S]*?)\1\s*\)\.play\s*\(/g,
+        kind: "play()",
+        targetIndex: 2
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.querySelector\(\s*(["'])([\s\S]*?)\1\s*\)\.pause\s*\(/g,
+        kind: "pause()",
+        targetIndex: 2
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.querySelector\(\s*(["'])([\s\S]*?)\1\s*\)\.currentTime\s*=/g,
+        kind: "currentTime",
+        targetIndex: 2
+      },
+      {
+        pattern: /\b(?:document|window\.document)\.querySelector\(\s*(["'])([\s\S]*?)\1\s*\)\.muted\s*=/g,
+        kind: "muted assignment",
+        targetIndex: 2
+      }
+    ];
+    for (const { pattern, kind, targetIndex } of directIdPatterns) {
+      let match;
+      while ((match = pattern.exec(script.content)) !== null) {
+        const target = match[targetIndex];
+        if (!target) continue;
+        const elementId = mediaIndex.ids.has(target) ? target : selectorTargetsManagedMedia(target, mediaIndex) ? void 0 : null;
+        if (elementId === null) continue;
+        findings.push({
+          code: "imperative_media_control",
+          severity: "error",
+          message: `Inline <script> imperatively controls managed media via ${kind}. HyperFrames must own media play/pause/seek to keep preview, timeline, and renders deterministic.`,
+          elementId: elementId || void 0,
+          fixHint: "Remove imperative media play/pause/currentTime/muted control. Express timing with data-start/data-duration and media offsets like data-media-start or data-playback-start instead.",
+          snippet: truncateSnippet(match[0])
+        });
+      }
+    }
+    for (const [variableName, elementId] of mediaVars) {
+      const escapedVar = escapeRegExp2(variableName);
+      const variablePatterns = [
+        { pattern: new RegExp(`\\b${escapedVar}\\.play\\s*\\(`, "g"), kind: "play()" },
+        { pattern: new RegExp(`\\b${escapedVar}\\.pause\\s*\\(`, "g"), kind: "pause()" },
+        { pattern: new RegExp(`\\b${escapedVar}\\.currentTime\\s*=`, "g"), kind: "currentTime" },
+        {
+          pattern: new RegExp(`\\b${escapedVar}\\.muted\\s*=`, "g"),
+          kind: "muted assignment"
+        }
+      ];
+      for (const { pattern, kind } of variablePatterns) {
+        let match;
+        while ((match = pattern.exec(script.content)) !== null) {
+          findings.push({
+            code: "imperative_media_control",
+            severity: "error",
+            message: `Inline <script> imperatively controls managed media via ${kind}. HyperFrames must own media play/pause/seek to keep preview, timeline, and renders deterministic.`,
+            elementId,
+            fixHint: "Remove imperative media play/pause/currentTime/muted control. Express timing with data-start/data-duration and media offsets like data-media-start or data-playback-start instead.",
+            snippet: truncateSnippet(match[0])
+          });
+        }
+      }
+    }
+  }
+  return findings;
+}
+var mediaRules = [
+  // duplicate_media_id + duplicate_media_discovery_risk
+  ({ tags }) => {
+    const findings = [];
+    const mediaById = /* @__PURE__ */ new Map();
+    const mediaFingerprintCounts = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      if (!isMediaTag(tag.name)) continue;
+      const elementId = readAttr(tag.raw, "id");
+      if (elementId) {
+        const existing = mediaById.get(elementId) || [];
+        existing.push(tag);
+        mediaById.set(elementId, existing);
+      }
+      const fingerprint = [
+        tag.name,
+        readAttr(tag.raw, "src") || "",
+        readAttr(tag.raw, "data-start") || "",
+        readAttr(tag.raw, "data-duration") || ""
+      ].join("|");
+      mediaFingerprintCounts.set(fingerprint, (mediaFingerprintCounts.get(fingerprint) || 0) + 1);
+    }
+    for (const [elementId, mediaTags] of mediaById) {
+      if (mediaTags.length < 2) continue;
+      findings.push({
+        code: "duplicate_media_id",
+        severity: "error",
+        message: `Media id "${elementId}" is defined multiple times.`,
+        elementId,
+        fixHint: "Give each media element a unique id so preview and producer discover the same media graph.",
+        snippet: truncateSnippet(mediaTags[0]?.raw || "")
+      });
+    }
+    for (const [fingerprint, count] of mediaFingerprintCounts) {
+      if (count < 2) continue;
+      const [tagName, src, dataStart, dataDuration] = fingerprint.split("|");
+      findings.push({
+        code: "duplicate_media_discovery_risk",
+        severity: "warning",
+        message: `Detected ${count} matching ${tagName} entries with the same source/start/duration.`,
+        fixHint: "Avoid duplicated media nodes that can be discovered twice during compilation.",
+        snippet: truncateSnippet(
+          `${tagName} src=${src} data-start=${dataStart} data-duration=${dataDuration}`
+        )
+      });
+    }
+    return findings;
+  },
+  // video_missing_muted
+  ({ tags }) => {
+    const findings = [];
+    for (const tag of tags) {
+      if (tag.name !== "video") continue;
+      const hasMuted = hasAttrName(tag.raw, "muted");
+      const hasDeclaredAudio = readAttr(tag.raw, "data-has-audio") === "true";
+      if (!hasMuted && !hasDeclaredAudio && readAttr(tag.raw, "data-start")) {
+        const elementId = readAttr(tag.raw, "id") || void 0;
+        findings.push({
+          code: "video_missing_muted",
+          severity: "error",
+          message: `<video${elementId ? ` id="${elementId}"` : ""}> has data-start but is not muted. Mark audible videos with data-has-audio="true"; otherwise keep video muted and use a separate <audio> element for sound.`,
+          elementId,
+          fixHint: 'Add the `muted` attribute for silent video, or add data-has-audio="true" when the video track should contribute audio.',
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (hasMuted && hasDeclaredAudio) {
+        const elementId = readAttr(tag.raw, "id") || void 0;
+        findings.push({
+          code: "video_muted_with_declared_audio",
+          severity: "error",
+          message: `<video${elementId ? ` id="${elementId}"` : ""}> declares data-has-audio="true" but also has muted. Studio preview will silence the video audio.`,
+          elementId,
+          fixHint: 'Remove the `muted` attribute if this video should be audible, or remove data-has-audio="true" and use data-volume="0" for silent visual video.',
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // video_nested_in_timed_element
+  ({ source, tags }) => {
+    const findings = [];
+    const voidElements = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    const timedTagPositions = [];
+    for (const tag of tags) {
+      if (tag.name === "video" || tag.name === "audio") continue;
+      if (voidElements.has(tag.name)) continue;
+      if (readAttr(tag.raw, "data-composition-id")) continue;
+      if (readAttr(tag.raw, "data-start")) {
+        timedTagPositions.push({
+          name: tag.name,
+          start: tag.index,
+          id: readAttr(tag.raw, "id") || void 0
+        });
+      }
+    }
+    for (const tag of tags) {
+      if (tag.name !== "video") continue;
+      if (!readAttr(tag.raw, "data-start")) continue;
+      for (const parent of timedTagPositions) {
+        if (parent.start < tag.index) {
+          const parentClosePattern = new RegExp(`</${parent.name}>`, "gi");
+          const between = source.substring(parent.start, tag.index);
+          if (!parentClosePattern.test(between)) {
+            findings.push({
+              code: "video_nested_in_timed_element",
+              severity: "error",
+              message: `<video> with data-start is nested inside <${parent.name}${parent.id ? ` id="${parent.id}"` : ""}> which also has data-start. The framework cannot manage playback of nested media \u2014 video will be FROZEN in renders.`,
+              elementId: readAttr(tag.raw, "id") || void 0,
+              fixHint: "Move the <video> to be a direct child of the stage, or remove data-start from the wrapper div (use it as a non-timed visual container).",
+              snippet: truncateSnippet(tag.raw)
+            });
+            break;
+          }
+        }
+      }
+    }
+    return findings;
+  },
+  // media_in_subcomposition — <video>/<audio> only render as a DIRECT child of the host
+  // root (index.html). Inside a sub-composition <template> the runtime never seeks/decodes
+  // them, so they render BLANK/black in preview and renders — and the other lint/validate
+  // passes otherwise miss it (only a per-frame snapshot reveals the blank panel).
+  ({ tags, options }) => {
+    const findings = [];
+    if (!options.isSubComposition) return findings;
+    for (const tag of tags) {
+      if (tag.name !== "video" && tag.name !== "audio") continue;
+      const elementId = readAttr(tag.raw, "id") || void 0;
+      findings.push({
+        code: "media_in_subcomposition",
+        severity: "error",
+        message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> is inside a sub-composition. The runtime only drives media that is a DIRECT child of the host root (index.html); media inside a sub-comp <template> is never seeked/decoded and renders BLANK/black in preview and renders.`,
+        elementId,
+        fixHint: "Move the media OUT of the sub-composition: place the <video>/<audio> as a direct child of #root in index.html, positioned over the scene, and drive any per-scene motion on the MAIN timeline at global time (a sub-comp timeline cannot reach host elements). See composition-patterns.md archetype B.",
+        snippet: truncateSnippet(tag.raw)
+      });
+    }
+    return findings;
+  },
+  // self_closing_media_tag
+  ({ source }) => {
+    const findings = [];
+    const selfClosingMediaRe = /<(audio|video)\b[^>]*\/>/gi;
+    let scMatch;
+    while ((scMatch = selfClosingMediaRe.exec(source)) !== null) {
+      const tagName = scMatch[1] || "audio";
+      const elementId = readAttr(scMatch[0], "id") || void 0;
+      findings.push({
+        code: "self_closing_media_tag",
+        severity: "error",
+        message: `Self-closing <${tagName}/> is invalid HTML. The browser will leave the tag open, swallowing all subsequent elements as invisible fallback content. This makes compositions INVISIBLE.`,
+        elementId,
+        fixHint: `Change <${tagName} .../> to <${tagName} ...></${tagName}> \u2014 media elements MUST have explicit closing tags.`,
+        snippet: truncateSnippet(scMatch[0])
+      });
+    }
+    return findings;
+  },
+  // placeholder_media_url
+  ({ tags }) => {
+    const findings = [];
+    const PLACEHOLDER_DOMAINS = /\b(placehold\.co|placeholder\.com|placekitten\.com|picsum\.photos|example\.com|via\.placeholder\.com|dummyimage\.com)\b/i;
+    for (const tag of tags) {
+      if (!isMediaTag(tag.name)) continue;
+      const src = readAttr(tag.raw, "src");
+      if (!src) continue;
+      if (PLACEHOLDER_DOMAINS.test(src)) {
+        const elementId = readAttr(tag.raw, "id") || void 0;
+        findings.push({
+          code: "placeholder_media_url",
+          severity: "error",
+          message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> uses a placeholder URL that will 404 at render time: ${src.slice(0, 80)}`,
+          elementId,
+          fixHint: "Replace with a real media URL. Placeholder domains will 404 at render time.",
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // base64_media_prohibited
+  ({ source }) => {
+    const findings = [];
+    const base64MediaRe = /src\s*=\s*["'](data:(?:audio|video)\/[^;]+;base64,([A-Za-z0-9+/=]{20,}))["']/gi;
+    let b64Match;
+    while ((b64Match = base64MediaRe.exec(source)) !== null) {
+      const sample = (b64Match[2] || "").slice(0, 200);
+      const uniqueChars = new Set(sample.replace(/[A-Za-z0-9+/=]/g, (c) => c)).size;
+      const dataSize = Math.round((b64Match[2] || "").length * 3 / 4);
+      const isSuspicious = uniqueChars < 15 || dataSize > 1e3 && dataSize < 5e4;
+      findings.push({
+        code: "base64_media_prohibited",
+        severity: "error",
+        message: `Inline base64 audio/video detected (${(dataSize / 1024).toFixed(0)} KB)${isSuspicious ? " \u2014 likely fabricated data" : ""}. Base64 media is prohibited \u2014 it bloats file size and breaks rendering.`,
+        fixHint: "Use a relative path (assets/music.mp3) or HTTPS URL for the audio/video src. Never embed media as base64.",
+        snippet: truncateSnippet((b64Match[1] ?? "").slice(0, 80) + "...")
+      });
+    }
+    return findings;
+  },
+  // media_missing_data_start + media_missing_id + media_missing_src + media_preload_none
+  ({ tags }) => {
+    const findings = [];
+    for (const tag of tags) {
+      if (tag.name !== "video" && tag.name !== "audio") continue;
+      const hasDataStart = readAttr(tag.raw, "data-start");
+      const hasId = readAttr(tag.raw, "id");
+      const hasSrc = readAttr(tag.raw, "src");
+      if (hasSrc && !hasDataStart) {
+        findings.push({
+          code: "media_missing_data_start",
+          severity: "error",
+          message: `<${tag.name}${hasId ? ` id="${hasId}"` : ""}> has src but no data-start. HyperFrames cannot own playback for untimed media, so preview and render behavior can diverge.`,
+          elementId: hasId || void 0,
+          fixHint: `Add data-start="0" (or the intended start time) and data-duration if the clip should stop before the source ends.`,
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (hasDataStart && !hasId) {
+        findings.push({
+          code: "media_missing_id",
+          severity: "error",
+          message: `<${tag.name}> has data-start but no id attribute. The renderer requires id to discover media elements \u2014 this ${tag.name === "audio" ? "audio will be SILENT" : "video will be FROZEN"} in renders.`,
+          fixHint: `Add a unique id attribute: <${tag.name} id="my-${tag.name}" ...>`,
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (hasDataStart && hasId && !hasSrc) {
+        findings.push({
+          code: "media_missing_src",
+          severity: "error",
+          message: `<${tag.name} id="${hasId}"> has data-start but no src attribute. The renderer cannot load this media.`,
+          elementId: hasId,
+          fixHint: `Add a src attribute to the <${tag.name}> element directly. If using <source> children, the renderer still requires src on the parent element.`,
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (readAttr(tag.raw, "preload") === "none") {
+        findings.push({
+          code: "media_preload_none",
+          severity: "warning",
+          message: `<${tag.name}${hasId ? ` id="${hasId}"` : ""}> has preload="none" which prevents the renderer from loading this media. The compiler strips it for renders, but preview may also have issues.`,
+          elementId: hasId || void 0,
+          fixHint: `Remove preload="none" or change to preload="auto". The framework manages media loading.`,
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // video_audio_double_source — catches audible <video> paired with a separate
+  // <audio> pointing to the same file, which causes double playback at runtime
+  ({ tags }) => {
+    const findings = [];
+    const videoSources = /* @__PURE__ */ new Map();
+    const audioSources = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      if (!readAttr(tag.raw, "data-start")) continue;
+      const src = readAttr(tag.raw, "src");
+      if (!src) continue;
+      const elementId = readAttr(tag.raw, "id") || void 0;
+      if (tag.name === "video") {
+        const isMuted = hasAttrName(tag.raw, "muted");
+        if (!isMuted) {
+          videoSources.set(src, { id: elementId, raw: tag.raw });
+        }
+      } else if (tag.name === "audio") {
+        audioSources.set(src, { id: elementId, raw: tag.raw });
+      }
+    }
+    for (const [src, audioInfo] of audioSources) {
+      const videoInfo = videoSources.get(src);
+      if (!videoInfo) continue;
+      findings.push({
+        code: "video_audio_double_source",
+        severity: "error",
+        message: `<audio${audioInfo.id ? ` id="${audioInfo.id}"` : ""}> and <video${videoInfo.id ? ` id="${videoInfo.id}"` : ""}> both point to the same source. The unmuted video already provides audio \u2014 the duplicate <audio> will cause double playback and echo.`,
+        elementId: audioInfo.id,
+        fixHint: "Either mute the video (add `muted` attribute) and keep the separate <audio>, or remove the <audio> element and let the video provide its own audio track.",
+        snippet: truncateSnippet(audioInfo.raw)
+      });
+    }
+    return findings;
+  },
+  // imperative_media_control
+  findImperativeMediaControlFindings
+];
+
+// src/rules/gsap.ts
+async function loadParseGsapScript() {
+  const mod = await import("@hyperframes/parsers/gsap-parser-acorn");
+  return mod.parseGsapScriptAcorn;
+}
+var SCENE_BOUNDARY_EPSILON_SECONDS = 0.05;
+function countClassUsage(tags) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const classAttr = readAttr(tag.raw, "class");
+    if (!classAttr) continue;
+    for (const className of classAttr.split(/\s+/).filter(Boolean)) {
+      counts.set(className, (counts.get(className) || 0) + 1);
+    }
+  }
+  return counts;
+}
+function readRegisteredTimelineCompositionId(script) {
+  const match = script.match(WINDOW_TIMELINE_ASSIGN_PATTERN);
+  return match?.[1] || match?.[2] || null;
+}
+function unwrapRaw(value) {
+  if (typeof value === "number") return value;
+  if (typeof value !== "string") return void 0;
+  const code = value.startsWith("__raw:") ? value.slice(6) : value;
+  return code.replace(/^\s*["']|["']\s*$/g, "");
+}
+function extrasNumber(value) {
+  const unwrapped = unwrapRaw(value);
+  const numeric = typeof unwrapped === "number" ? unwrapped : Number(unwrapped);
+  return Number.isFinite(numeric) ? numeric : 0;
+}
+function synthesizeWindowRaw(timelineVar, anim) {
+  const entries = Object.entries(anim.properties).map(([k, v]) => {
+    if (typeof v === "string" && v.startsWith("__raw:")) return `${k}: ${v.slice(6)}`;
+    return `${k}: ${typeof v === "string" ? JSON.stringify(v) : v}`;
+  });
+  if (anim.duration !== void 0) entries.push(`duration: ${anim.duration}`);
+  if (anim.ease) entries.push(`ease: ${JSON.stringify(anim.ease)}`);
+  const pos = typeof anim.position === "number" ? anim.position : JSON.stringify(anim.position);
+  return `${timelineVar}.${anim.method}("${anim.targetSelector}", { ${entries.join(", ")} }, ${pos})`;
+}
+var gsapWindowsCache = /* @__PURE__ */ new Map();
+async function cachedExtractGsapWindows(scriptContent) {
+  const cached = gsapWindowsCache.get(scriptContent);
+  if (cached) return cached;
+  const windows = await extractGsapWindows(scriptContent);
+  gsapWindowsCache.set(scriptContent, windows);
+  return windows;
+}
+async function extractGsapWindows(script) {
+  if (!/gsap\.timeline/.test(script)) return [];
+  const parseGsapScript = await loadParseGsapScript();
+  const parsed = parseGsapScript(script);
+  if (parsed.animations.length === 0) return [];
+  const windows = [];
+  for (const animation of parsed.animations) {
+    if (typeof animation.position !== "number") continue;
+    const repeat = extrasNumber(animation.extras?.repeat);
+    const cycleCount = repeat > 0 ? repeat + 1 : 1;
+    const effectiveDuration = animation.method === "set" ? 0 : (animation.duration ?? 0) * cycleCount;
+    windows.push({
+      targetSelector: animation.targetSelector,
+      position: animation.position,
+      end: animation.position + effectiveDuration,
+      properties: Object.keys(animation.properties),
+      propertyValues: animation.properties,
+      overwriteAuto: unwrapRaw(animation.extras?.overwrite) === "auto",
+      method: animation.method,
+      raw: synthesizeWindowRaw(parsed.timelineVar, animation)
+    });
+  }
+  return windows;
+}
+function numberValue(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+  }
+  return null;
+}
+function stringValue(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  return null;
+}
+function zeroValue(value) {
+  if (typeof value === "number") return value === 0;
+  if (typeof value !== "string") return false;
+  return Number(value.trim()) === 0;
+}
+function isHiddenGsapState(values) {
+  const visibility = stringValue(values.visibility)?.toLowerCase();
+  const display = stringValue(values.display)?.toLowerCase();
+  return zeroValue(values.opacity) || zeroValue(values.autoAlpha) || visibility === "hidden" || display === "none";
+}
+function oneValue(values, keys) {
+  for (const key of keys) {
+    const value = values[key];
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function isVisibleGsapState(values) {
+  const opacity = oneValue(values, ["opacity", "autoAlpha"]);
+  if (typeof opacity === "number") return opacity > 0;
+  if (typeof opacity === "string" && opacity.trim()) {
+    const numeric = Number(opacity);
+    if (Number.isFinite(numeric)) return numeric > 0;
+  }
+  const visibility = stringValue(values.visibility)?.toLowerCase();
+  if (visibility === "visible" || visibility === "inherit") return true;
+  const display = stringValue(values.display)?.toLowerCase();
+  if (display && display !== "none") return true;
+  return false;
+}
+function makesOverlayVisible(win) {
+  if (win.method === "from" && isHiddenGsapState(win.propertyValues)) return true;
+  return isVisibleGsapState(win.propertyValues);
+}
+function isSceneBoundaryExit(win) {
+  if (win.end <= win.position) return false;
+  if (win.method !== "to" && win.method !== "fromTo") return false;
+  return isHiddenGsapState(win.propertyValues);
+}
+function isHardKillSet(win, selector, boundary) {
+  return win.method === "set" && win.targetSelector === selector && Math.abs(win.position - boundary) <= SCENE_BOUNDARY_EPSILON_SECONDS && isHiddenGsapState(win.propertyValues);
+}
+function hiddenStateLiteral(values) {
+  if (zeroValue(values.autoAlpha)) return "{ autoAlpha: 0 }";
+  if (zeroValue(values.opacity)) return "{ opacity: 0 }";
+  if (stringValue(values.visibility)?.toLowerCase() === "hidden") return '{ visibility: "hidden" }';
+  if (stringValue(values.display)?.toLowerCase() === "none") return '{ display: "none" }';
+  return "{ opacity: 0 }";
+}
+function findTagEnd(source, tag) {
+  const escapedTagName = tag.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<\\/?${escapedTagName}\\b[^>]*>`, "gi");
+  pattern.lastIndex = tag.index;
+  let depth = 0;
+  let match;
+  while ((match = pattern.exec(source)) !== null) {
+    const raw = match[0];
+    const isClosing = /^<\s*\//.test(raw);
+    const isSelfClosing = /\/\s*>$/.test(raw);
+    if (!isClosing && !isSelfClosing) depth += 1;
+    if (isClosing) depth -= 1;
+    if (depth === 0) return pattern.lastIndex;
+  }
+  return source.length;
+}
+function collectCompositionRanges(source, tags) {
+  return tags.map((tag) => {
+    const id = readAttr(tag.raw, "data-composition-id");
+    if (!id) return null;
+    return {
+      id,
+      start: tag.index,
+      end: findTagEnd(source, tag)
+    };
+  }).filter((range) => range !== null);
+}
+function findContainingCompositionId(tag, ranges) {
+  let match = null;
+  for (const range of ranges) {
+    if (tag.index < range.start || tag.index >= range.end) continue;
+    if (!match || range.start >= match.start) match = range;
+  }
+  return match?.id || null;
+}
+function collectClipStartBoundariesByComposition(source, tags) {
+  const ranges = collectCompositionRanges(source, tags);
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const classAttr = readAttr(tag.raw, "class") || "";
+    const classes = classAttr.split(/\s+/).filter(Boolean);
+    if (!classes.includes("clip")) continue;
+    const compositionId = findContainingCompositionId(tag, ranges);
+    if (!compositionId) continue;
+    const start = numberValue(readAttr(tag.raw, "data-start") ?? void 0);
+    if (start == null || start <= 0) continue;
+    const compositionBoundaries = boundaries.get(compositionId) ?? /* @__PURE__ */ new Set();
+    compositionBoundaries.add(start);
+    boundaries.set(compositionId, compositionBoundaries);
+  }
+  return new Map(
+    [...boundaries.entries()].map(([compositionId, values]) => [
+      compositionId,
+      [...values].sort((a, b) => a - b)
+    ])
+  );
+}
+function findMatchingSceneBoundary(time, boundaries) {
+  for (const boundary of boundaries) {
+    if (Math.abs(time - boundary) <= SCENE_BOUNDARY_EPSILON_SECONDS) return boundary;
+  }
+  return null;
+}
+function isSuspiciousGlobalSelector(selector) {
+  if (!selector) return false;
+  if (selector.includes("[data-composition-id=")) return false;
+  if (selector.startsWith("#")) return false;
+  return selector.startsWith(".") || /^[a-z]/i.test(selector);
+}
+function getSingleClassSelector(selector) {
+  const match = selector.trim().match(/^\.(?<name>[A-Za-z0-9_-]+)$/);
+  return match?.groups?.name || null;
+}
+function readStyleProperty(style, property) {
+  const escapedProperty = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = style.match(new RegExp(`(?:^|;)\\s*${escapedProperty}\\s*:\\s*([^;]+)`, "i"));
+  return match?.[1]?.trim() || null;
+}
+function cssZero(value) {
+  if (!value) return false;
+  return /^0(?:\.0+)?(?:px|%|vw|vh|rem|em)?$/i.test(value.trim());
+}
+function styleHasHiddenInitialState(style) {
+  const opacity = readStyleProperty(style, "opacity");
+  if (opacity && Number(opacity) === 0) return true;
+  if (readStyleProperty(style, "visibility")?.toLowerCase() === "hidden") return true;
+  if (readStyleProperty(style, "display")?.toLowerCase() === "none") return true;
+  return false;
+}
+function styleHasOpaqueBackground(style) {
+  const background = readStyleProperty(style, "background") || readStyleProperty(style, "background-color");
+  if (!background) return false;
+  const normalized = background.toLowerCase().replace(/\s+/g, "");
+  if (normalized === "transparent" || normalized === "none") return false;
+  if (/rgba?\([^)]*,0(?:\.0+)?\)$/.test(normalized)) return false;
+  if (/hsla?\([^)]*,0(?:\.0+)?\)$/.test(normalized)) return false;
+  return true;
+}
+function styleLooksFullFrameOverlay(style) {
+  const position = readStyleProperty(style, "position")?.toLowerCase();
+  if (position !== "fixed" && position !== "absolute") return false;
+  const coversFrame = cssZero(readStyleProperty(style, "inset")) || cssZero(readStyleProperty(style, "top")) && cssZero(readStyleProperty(style, "right")) && cssZero(readStyleProperty(style, "bottom")) && cssZero(readStyleProperty(style, "left"));
+  return coversFrame && styleHasOpaqueBackground(style);
+}
+function collectSimpleStyleRules(styles) {
+  const rules = /* @__PURE__ */ new Map();
+  for (const style of styles) {
+    for (const [, selectorList, body] of style.content.matchAll(/([^{}]+)\{([^}]+)\}/g)) {
+      if (!selectorList || !body) continue;
+      for (const selector of selectorList.split(",")) {
+        const token = selector.trim();
+        if (!/^[#.][A-Za-z0-9_-]+$/.test(token)) continue;
+        rules.set(token, `${rules.get(token) || ""};${body}`);
+      }
+    }
+  }
+  return rules;
+}
+function tagSimpleSelectors(tag) {
+  const selectors = [];
+  const id = readAttr(tag.raw, "id");
+  if (id) selectors.push(`#${id}`);
+  const classes = readAttr(tag.raw, "class")?.split(/\s+/).filter(Boolean) ?? [];
+  for (const className of classes) selectors.push(`.${className}`);
+  return selectors;
+}
+function combinedTagStyle(tag, styleRules) {
+  const styles = [readAttr(tag.raw, "style") || ""];
+  for (const selector of tagSimpleSelectors(tag)) {
+    const ruleStyle = styleRules.get(selector);
+    if (ruleStyle) styles.push(ruleStyle);
+  }
+  return styles.filter(Boolean).join(";");
+}
+function cssTransformToGsapProps(cssTransform) {
+  const parts = [];
+  const translateMatch = cssTransform.match(
+    /translate\(\s*(-?[\d.]+)(%|px)?\s*,\s*(-?[\d.]+)(%|px)?\s*\)/
+  );
+  if (translateMatch) {
+    const [, xVal, xUnit, yVal, yUnit] = translateMatch;
+    if (xUnit === "%") parts.push(`xPercent: ${xVal}`);
+    else parts.push(`x: ${xVal}`);
+    if (yUnit === "%") parts.push(`yPercent: ${yVal}`);
+    else parts.push(`y: ${yVal}`);
+  }
+  const txMatch = cssTransform.match(/translateX\(\s*(-?[\d.]+)(%|px)?\s*\)/);
+  if (txMatch) {
+    const [, val, unit] = txMatch;
+    parts.push(unit === "%" ? `xPercent: ${val}` : `x: ${val}`);
+  }
+  const tyMatch = cssTransform.match(/translateY\(\s*(-?[\d.]+)(%|px)?\s*\)/);
+  if (tyMatch) {
+    const [, val, unit] = tyMatch;
+    parts.push(unit === "%" ? `yPercent: ${val}` : `y: ${val}`);
+  }
+  const scaleMatch = cssTransform.match(/scale\(\s*([\d.]+)\s*\)/);
+  if (scaleMatch) {
+    parts.push(`scale: ${scaleMatch[1]}`);
+  }
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+var CONFLICTING_TRANSLATE_PROPS = ["x", "y", "xPercent", "yPercent"];
+var CONFLICTING_SCALE_PROPS = ["scale", "scaleX", "scaleY"];
+function targetedSelectorTokens(selector) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const group of selector.split(",")) {
+    const compounds = group.trim().split(/[\s>+~]+/).filter(Boolean);
+    const last = compounds[compounds.length - 1];
+    if (!last) continue;
+    const simple = last.match(/[#.][A-Za-z0-9_-]+/g);
+    if (simple) for (const token of simple) tokens.add(token);
+  }
+  return tokens;
+}
+function matchCssTransform(gsapSelector, cssMap) {
+  if (cssMap.size === 0) return void 0;
+  const direct = cssMap.get(gsapSelector);
+  if (direct) return direct;
+  const tokens = targetedSelectorTokens(gsapSelector);
+  for (const [cssSelector, value] of cssMap) {
+    if (tokens.has(cssSelector)) return value;
+  }
+  return void 0;
+}
+function extractStandaloneGsapTransformCalls(script) {
+  const calls = [];
+  const pattern = /gsap\.(set|to|from|fromTo)\s*\(\s*(["'])([^"']+)\2\s*,\s*\{([^{}]*)\}/g;
+  let match;
+  while ((match = pattern.exec(script)) !== null) {
+    const method = match[1] ?? "set";
+    const selector = match[3] ?? "";
+    const propsBody = match[4] ?? "";
+    const properties = [...propsBody.matchAll(/([A-Za-z_$][\w$]*)\s*:/g)].map((m) => m[1] ?? "");
+    calls.push({ method, selector, properties, raw: truncateSnippet(match[0]) ?? match[0] });
+  }
+  return calls;
+}
+var gsapRules = [
+  // overlapping_gsap_tweens + gsap_animates_clip_element + unscoped_gsap_selector
+  // fallow-ignore-next-line complexity
+  async ({ source, tags, scripts, styles, rootCompositionId }) => {
+    const findings = [];
+    const clipIds = /* @__PURE__ */ new Map();
+    const clipClasses = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      const classAttr = readAttr(tag.raw, "class") || "";
+      const classes = classAttr.split(/\s+/).filter(Boolean);
+      if (!classes.includes("clip")) continue;
+      const id = readAttr(tag.raw, "id");
+      const info = {
+        tag: tag.name,
+        id: id || "",
+        classes: classAttr
+      };
+      if (id) clipIds.set(`#${id}`, info);
+      for (const cls of classes) {
+        if (cls !== "clip") clipClasses.set(`.${cls}`, info);
+      }
+    }
+    const classUsage = countClassUsage(tags);
+    const clipStartBoundariesByComposition = collectClipStartBoundariesByComposition(source, tags);
+    const styleRules = collectSimpleStyleRules(styles);
+    const reportedVisibleOverlayKeys = /* @__PURE__ */ new Set();
+    for (const script of scripts) {
+      const localTimelineCompId = readRegisteredTimelineCompositionId(script.content);
+      const gsapWindows = await cachedExtractGsapWindows(script.content);
+      const clipStartBoundaries = clipStartBoundariesByComposition.get(localTimelineCompId || rootCompositionId || "") ?? [];
+      for (let i = 0; i < gsapWindows.length; i++) {
+        const left = gsapWindows[i];
+        if (!left) continue;
+        if (left.end <= left.position) continue;
+        for (let j = i + 1; j < gsapWindows.length; j++) {
+          const right = gsapWindows[j];
+          if (!right) continue;
+          if (right.end <= right.position) continue;
+          if (left.targetSelector !== right.targetSelector) continue;
+          const overlapStart = Math.max(left.position, right.position);
+          const overlapEnd = Math.min(left.end, right.end);
+          if (overlapEnd <= overlapStart) continue;
+          if (left.overwriteAuto || right.overwriteAuto) continue;
+          const sharedProperties = left.properties.filter(
+            (prop) => right.properties.includes(prop)
+          );
+          if (sharedProperties.length === 0) continue;
+          findings.push({
+            code: "overlapping_gsap_tweens",
+            severity: "warning",
+            message: `GSAP tweens overlap on "${left.targetSelector}" for ${sharedProperties.join(", ")} between ${overlapStart.toFixed(2)}s and ${overlapEnd.toFixed(2)}s.`,
+            selector: left.targetSelector,
+            fixHint: 'Shorten the earlier tween, move the later tween, or add `overwrite: "auto"`.',
+            snippet: truncateSnippet(`${left.raw}
+${right.raw}`)
+          });
+        }
+      }
+      if (clipStartBoundaries.length > 0) {
+        for (const win of gsapWindows) {
+          if (!isSceneBoundaryExit(win)) continue;
+          const boundary = findMatchingSceneBoundary(win.end, clipStartBoundaries);
+          if (boundary == null) continue;
+          const hasHardKill = gsapWindows.some(
+            (candidate) => isHardKillSet(candidate, win.targetSelector, boundary)
+          );
+          if (hasHardKill) continue;
+          findings.push({
+            code: "gsap_exit_missing_hard_kill",
+            severity: "error",
+            message: `GSAP exit on "${win.targetSelector}" ends at the ${boundary.toFixed(2)}s clip start boundary without a matching tl.set hard kill. Non-linear seeking can land after the fade and leave stale visibility state.`,
+            selector: win.targetSelector,
+            fixHint: `Add \`tl.set("${win.targetSelector}", ${hiddenStateLiteral(win.propertyValues)}, ${boundary.toFixed(2)})\` after the exit tween.`,
+            snippet: truncateSnippet(win.raw)
+          });
+        }
+      }
+      for (const tag of tags) {
+        const selectors = tagSimpleSelectors(tag);
+        if (selectors.length === 0) continue;
+        const overlayKey = readAttr(tag.raw, "id") || String(tag.index);
+        if (reportedVisibleOverlayKeys.has(overlayKey)) continue;
+        const authoredStyle = combinedTagStyle(tag, styleRules);
+        if (!authoredStyle || !styleLooksFullFrameOverlay(authoredStyle)) continue;
+        if (styleHasHiddenInitialState(authoredStyle)) continue;
+        const visibilityWindows = gsapWindows.filter((win) => {
+          const tokens = targetedSelectorTokens(win.targetSelector);
+          if (!selectors.some((selector2) => tokens.has(selector2))) return false;
+          return win.properties.some(
+            (prop) => ["opacity", "autoAlpha", "visibility", "display"].includes(prop)
+          );
+        }).sort((a, b) => a.position - b.position);
+        const startsHiddenAtZero = visibilityWindows.some(
+          (win) => win.position <= SCENE_BOUNDARY_EPSILON_SECONDS && isHiddenGsapState(win.propertyValues)
+        );
+        if (startsHiddenAtZero) continue;
+        const firstVisible = visibilityWindows.find((win) => makesOverlayVisible(win));
+        if (!firstVisible) continue;
+        const selector = selectors.find(
+          (candidate) => targetedSelectorTokens(firstVisible.targetSelector).has(candidate)
+        ) || selectors[0] || tag.name;
+        const laterHidden = visibilityWindows.some(
+          (win) => win.position >= firstVisible.position && isHiddenGsapState(win.propertyValues)
+        );
+        if (firstVisible.method !== "from" && !laterHidden) continue;
+        reportedVisibleOverlayKeys.add(overlayKey);
+        findings.push({
+          code: "gsap_fullscreen_overlay_starts_visible",
+          severity: "error",
+          message: `Full-frame overlay "${selector}" starts visible before its first GSAP opacity tween at ${firstVisible.position.toFixed(2)}s. It will cover earlier render frames, often as a blank/white video.`,
+          selector,
+          elementId: readAttr(tag.raw, "id") || void 0,
+          fixHint: `Add \`opacity: 0\` to "${selector}" in CSS/inline styles, or add \`tl.set("${selector}", { opacity: 0 }, 0)\` before the reveal tween.`,
+          snippet: truncateSnippet(firstVisible.raw)
+        });
+      }
+      for (const win of gsapWindows) {
+        const sel = win.targetSelector;
+        const clipInfo = clipIds.get(sel) || clipClasses.get(sel);
+        if (!clipInfo) continue;
+        const conflictingProps = win.properties.filter(
+          (p) => p === "visibility" || p === "display"
+        );
+        if (conflictingProps.length === 0) continue;
+        const elDesc = `<${clipInfo.tag}${clipInfo.id ? ` id="${clipInfo.id}"` : ""} class="${clipInfo.classes}">`;
+        findings.push({
+          code: "gsap_animates_clip_element",
+          severity: "error",
+          message: `GSAP animation sets ${conflictingProps.join(", ")} on a clip element. Selector "${sel}" resolves to element ${elDesc}. The framework manages clip visibility via ${conflictingProps.join("/")} \u2014 do not animate these properties on clip elements.`,
+          selector: sel,
+          elementId: clipInfo.id || void 0,
+          fixHint: "Remove the visibility/display tween, or move the content into a child <div> and target that instead.",
+          snippet: truncateSnippet(win.raw)
+        });
+      }
+      if (!localTimelineCompId || localTimelineCompId === rootCompositionId) continue;
+      for (const win of gsapWindows) {
+        if (!isSuspiciousGlobalSelector(win.targetSelector)) continue;
+        const className = getSingleClassSelector(win.targetSelector);
+        if (className && (classUsage.get(className) || 0) < 2) continue;
+        findings.push({
+          code: "unscoped_gsap_selector",
+          severity: "error",
+          message: `Timeline "${localTimelineCompId}" uses unscoped selector "${win.targetSelector}" that will target elements in ALL compositions when bundled, causing data loss (opacity, transforms, etc.).`,
+          selector: win.targetSelector,
+          fixHint: `Scope the selector: \`[data-composition-id="${localTimelineCompId}"] ${win.targetSelector}\` or use a unique id.`,
+          snippet: truncateSnippet(win.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // gsap_css_transform_conflict
+  // fallow-ignore-next-line complexity
+  async ({ styles, scripts, tags }) => {
+    const findings = [];
+    const cssTranslateSelectors = /* @__PURE__ */ new Map();
+    const cssScaleSelectors = /* @__PURE__ */ new Map();
+    for (const style of styles) {
+      for (const [, selector, body] of style.content.matchAll(
+        /([#.][a-zA-Z0-9_-]+)\s*\{([^}]+)\}/g
+      )) {
+        const tMatch = body?.match(/transform\s*:\s*([^;]+)/);
+        if (!tMatch || !tMatch[1]) continue;
+        const transformVal = tMatch[1].trim();
+        if (/translate/i.test(transformVal))
+          cssTranslateSelectors.set((selector ?? "").trim(), transformVal);
+        if (/scale/i.test(transformVal))
+          cssScaleSelectors.set((selector ?? "").trim(), transformVal);
+      }
+    }
+    for (const tag of tags) {
+      const inlineStyle = readAttr(tag.raw, "style");
+      if (!inlineStyle) continue;
+      const tMatch = inlineStyle.match(/transform\s*:\s*([^;]+)/);
+      if (!tMatch || !tMatch[1]) continue;
+      const transformVal = tMatch[1].trim();
+      const id = readAttr(tag.raw, "id");
+      const classes = readAttr(tag.raw, "class")?.split(/\s+/).filter(Boolean) ?? [];
+      const selectors = [];
+      if (id) selectors.push(`#${id}`);
+      for (const cls of classes) selectors.push(`.${cls}`);
+      if (selectors.length === 0) continue;
+      for (const sel of selectors) {
+        if (/translate/i.test(transformVal) && !cssTranslateSelectors.has(sel))
+          cssTranslateSelectors.set(sel, transformVal);
+        if (/scale/i.test(transformVal) && !cssScaleSelectors.has(sel))
+          cssScaleSelectors.set(sel, transformVal);
+      }
+    }
+    if (cssTranslateSelectors.size === 0 && cssScaleSelectors.size === 0) return findings;
+    for (const script of scripts) {
+      if (!/gsap\.timeline/.test(script.content)) continue;
+      const windows = await cachedExtractGsapWindows(script.content);
+      const calls = [
+        ...windows.map((win) => ({
+          method: win.method,
+          selector: win.targetSelector,
+          properties: win.properties,
+          raw: win.raw
+        })),
+        ...extractStandaloneGsapTransformCalls(stripJsComments(script.content))
+      ];
+      const conflicts = /* @__PURE__ */ new Map();
+      for (const call of calls) {
+        if (call.method === "fromTo" || call.method === "from") continue;
+        const sel = call.selector;
+        const translateProps = call.properties.filter(
+          (p) => CONFLICTING_TRANSLATE_PROPS.includes(p)
+        );
+        const scaleProps = call.properties.filter((p) => CONFLICTING_SCALE_PROPS.includes(p));
+        const cssFromTranslate = translateProps.length > 0 ? matchCssTransform(sel, cssTranslateSelectors) : void 0;
+        const cssFromScale = scaleProps.length > 0 ? matchCssTransform(sel, cssScaleSelectors) : void 0;
+        if (!cssFromTranslate && !cssFromScale) continue;
+        const existing = conflicts.get(sel) ?? {
+          cssTransform: [cssFromTranslate, cssFromScale].filter(Boolean).join(" "),
+          props: /* @__PURE__ */ new Set(),
+          raw: call.raw
+        };
+        for (const p of [...translateProps, ...scaleProps]) existing.props.add(p);
+        conflicts.set(sel, existing);
+      }
+      for (const [sel, { cssTransform, props, raw }] of conflicts) {
+        const propList = [...props].join("/");
+        const gsapEquivalent = cssTransformToGsapProps(cssTransform);
+        const fixHint = gsapEquivalent ? `Remove \`transform: ${cssTransform}\` from CSS and replace with GSAP properties: ${gsapEquivalent}. Example: tl.fromTo('${sel}', { ${gsapEquivalent} }, { ${gsapEquivalent}, ...yourAnimation }). tl.fromTo is exempt from this rule.` : `Remove the transform from CSS and use tl.fromTo('${sel}', { xPercent: -50, x: -1000 }, { xPercent: -50, x: 0 }) so GSAP owns the full transform state. tl.fromTo is exempt from this rule.`;
+        findings.push({
+          code: "gsap_css_transform_conflict",
+          severity: "error",
+          message: `"${sel}" has CSS \`transform: ${cssTransform}\` and a GSAP tween animates ${propList}. GSAP will overwrite the full CSS transform, discarding any translateX(-50%) centering or CSS scale value.`,
+          selector: sel,
+          fixHint,
+          snippet: truncateSnippet(raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // missing_gsap_script
+  ({ scripts, rawSource, options }) => {
+    const allScriptTexts = scripts.filter((s) => !/\bsrc\s*=/.test(s.attrs)).map((s) => s.content);
+    const allScriptSrcs = scripts.map((s) => readAttr(`<script ${s.attrs}>`, "src") || "").filter(Boolean);
+    const canInheritGsapFromHost = options.isSubComposition || rawSource.trimStart().toLowerCase().startsWith("<template");
+    const usesGsap = allScriptTexts.some(
+      (t) => /gsap\.(to|from|fromTo|timeline|set|registerPlugin)\b/.test(t)
+    );
+    const hasGsapScript = allScriptSrcs.some((src) => /gsap/i.test(src));
+    const hasInlineGsap = allScriptTexts.some(
+      (t) => /\/\*\s*inlined:.*gsap/i.test(t) || /\b_gsScope\b/.test(t) || /\bGreenSock\b/.test(t) || /\bgsap\.(config|defaults|version)\b/.test(t) || t.length > 5e3 && /\bgsap\b/i.test(t)
+    );
+    if (!usesGsap || hasGsapScript || hasInlineGsap || canInheritGsapFromHost) return [];
+    return [
+      {
+        code: "missing_gsap_script",
+        severity: "error",
+        message: "Composition uses GSAP but no GSAP script is loaded. The animation will not run.",
+        fixHint: 'Add <script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/gsap.min.js"><\/script> before your animation script.'
+      }
+    ];
+  },
+  // audio_reactive_single_tween_per_group
+  // fallow-ignore-next-line complexity
+  ({ scripts, styles }) => {
+    const findings = [];
+    const isCaptionFile = styles.some((s) => /\.caption[-_]?(?:group|word)/i.test(s.content));
+    if (!isCaptionFile) return findings;
+    for (const script of scripts) {
+      const content = script.content;
+      const hasAudioData = /AUDIO|audio[-_]?data|bands\[/.test(content);
+      if (!hasAudioData) continue;
+      const hasCaptionLoop = /forEach/.test(content) && /caption|group|cg-/.test(content);
+      if (!hasCaptionLoop) continue;
+      const hasInnerSamplingLoop = /for\s*\(\s*var\s+\w+\s*=\s*group\.start/.test(content) || /for\s*\(\s*var\s+at\s*=/.test(content) || /while\s*\(\s*\w+\s*<\s*group\.end/.test(content);
+      if (!hasInnerSamplingLoop) {
+        const hasPeakTween = /peak(?:Bass|Treble|Energy)/.test(content) && /group\.start/.test(content);
+        if (hasPeakTween) {
+          findings.push({
+            code: "audio_reactive_single_tween_per_group",
+            severity: "warning",
+            message: "Audio-reactive captions use a single tween per group based on peak values. This sets one static value at group.start \u2014 not perceptible as audio reactivity.",
+            fixHint: "Sample audio data at 100-200ms intervals throughout each group's lifetime (for loop from group.start to group.end) and create a tween at each sample point for visible pulsing."
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // gsap_infinite_repeat
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const content = stripJsComments(script.content);
+      const pattern = /repeat\s*:\s*-1(?!\d)/g;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const contextStart = Math.max(0, match.index - 60);
+        const contextEnd = Math.min(content.length, match.index + match[0].length + 60);
+        const snippet = content.slice(contextStart, contextEnd).trim();
+        findings.push({
+          code: "gsap_infinite_repeat",
+          severity: "error",
+          message: "GSAP tween uses `repeat: -1` (infinite). Infinite repeats break the deterministic capture engine which seeks to exact frame times. Use a finite repeat count calculated from the composition duration: `repeat: Math.floor(duration / cycleDuration) - 1`.",
+          fixHint: "Replace `repeat: -1` with a finite count, e.g. `repeat: Math.floor(totalDuration / singleCycleDuration) - 1`. Use Math.floor (not Math.ceil) to ensure the animation fits within the total duration.",
+          snippet: truncateSnippet(snippet)
+        });
+      }
+    }
+    return findings;
+  },
+  // gsap_repeat_ceil_overshoot
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const content = script.content;
+      const pattern = /repeat\s*:\s*Math\.ceil\s*\([^)]+\)\s*-\s*1/g;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const contextStart = Math.max(0, match.index - 40);
+        const contextEnd = Math.min(content.length, match.index + match[0].length + 40);
+        const snippet = content.slice(contextStart, contextEnd).trim();
+        findings.push({
+          code: "gsap_repeat_ceil_overshoot",
+          severity: "warning",
+          message: "GSAP repeat calculation uses `Math.ceil` which can overshoot the composition duration. For example, Math.ceil(10.5 / 2) - 1 = 5 repeats \u2192 6 cycles \xD7 2s = 12s, exceeding 10.5s.",
+          fixHint: "Use `Math.floor` instead of `Math.ceil` to ensure the animation fits within the duration: `repeat: Math.floor(totalDuration / cycleDuration) - 1`. Math.floor(10.5 / 2) - 1 = 4 repeats \u2192 5 cycles \xD7 2s = 10s \u2713",
+          snippet: truncateSnippet(snippet)
+        });
+      }
+    }
+    return findings;
+  },
+  // scene_layer_missing_visibility_kill
+  ({ scripts, tags }) => {
+    const findings = [];
+    const sceneElements = tags.filter((t) => {
+      const id = readAttr(t.raw, "id") || "";
+      return /^scene\d+$/i.test(id);
+    });
+    if (sceneElements.length < 2) return findings;
+    for (const script of scripts) {
+      const content = stripJsComments(script.content);
+      for (const tag of sceneElements) {
+        const id = readAttr(tag.raw, "id") || "";
+        const exitPattern = new RegExp(`["']#${id}["'][^)]*opacity\\s*:\\s*0`);
+        const hasExit = exitPattern.test(content);
+        if (!hasExit) continue;
+        const killPattern = new RegExp(`["']#${id}["'][^)]*visibility\\s*:\\s*["']hidden["']`);
+        const hasKill = killPattern.test(content);
+        if (!hasKill) {
+          findings.push({
+            code: "scene_layer_missing_visibility_kill",
+            severity: "error",
+            elementId: id,
+            message: `Scene layer "#${id}" exits via opacity tween but has no visibility: hidden hard kill. When scrubbing or when tweens conflict, the scene may remain partially visible and overlap the next scene.`,
+            fixHint: `Add \`tl.set("#${id}", { visibility: "hidden" }, <exit-end-time>)\` after the scene's exit tweens.`
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // gsap_timeline_not_registered
+  ({ scripts, rawSource, options }) => {
+    const findings = [];
+    const canInheritFromHost = options.isSubComposition || rawSource.trimStart().toLowerCase().startsWith("<template");
+    for (const script of scripts) {
+      const content = script.content;
+      if (!/gsap\.timeline/.test(content)) continue;
+      const hasRegistration = WINDOW_TIMELINE_ASSIGN_PATTERN.test(content);
+      if (hasRegistration || canInheritFromHost) continue;
+      findings.push({
+        code: "gsap_timeline_not_registered",
+        severity: "error",
+        message: "GSAP timeline is created but never registered in window.__timelines. The runtime discovers timelines from this registry \u2014 without registration, animations will not play during preview or render.",
+        fixHint: 'Add `window.__timelines = window.__timelines || {};` and `window.__timelines["root"] = tl;` after creating the timeline (use the composition\'s data-composition-id as the key).'
+      });
+    }
+    return findings;
+  },
+  // gsap_timeline_registered_before_async_build — registering window.__timelines[id]
+  // BEFORE the timeline is built inside document.fonts.ready (or any async callback)
+  // leaves an EMPTY timeline registered. The runtime's sub-composition readiness gate
+  // treats "key present" as "ready" and nests the child ONCE, while still empty — so the
+  // animation never renders when this composition is mounted as a sub-composition.
+  // Register only AFTER the build completes (the documented async-setup contract).
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const content = stripJsComments(script.content);
+      const regIdx = content.search(/window\s*\.\s*__timelines\s*\[/);
+      if (regIdx < 0) continue;
+      const fontsReadyIdx = content.search(/document\s*\.\s*fonts\s*\.\s*ready/);
+      if (fontsReadyIdx < 0) continue;
+      if (regIdx >= fontsReadyIdx) continue;
+      const tail = content.slice(fontsReadyIdx);
+      if (!/\.(?:to|from|fromTo)\s*\(|buildEffect\s*\(/.test(tail)) continue;
+      findings.push({
+        code: "gsap_timeline_registered_before_async_build",
+        severity: "error",
+        message: 'window.__timelines is assigned BEFORE the timeline is built inside document.fonts.ready. An empty timeline registered early gets nested empty when this composition is used as a sub-composition (the readiness gate treats "key present" as "ready" and never re-nests), so the animation renders blank.',
+        fixHint: "Move the `window.__timelines[id] = tl;` assignment to the END of the document.fonts.ready callback, after the tweens are added. Optionally call window.__hfForceTimelineRebind() right after, to re-nest the populated timeline."
+      });
+    }
+    return findings;
+  },
+  // gsap_from_opacity_noop — CSS opacity:0 + gsap.from({opacity:0}) = invisible forever
+  // fallow-ignore-next-line complexity
+  async ({ styles, scripts, tags }) => {
+    const findings = [];
+    const cssOpacityZeroSelectors = /* @__PURE__ */ new Set();
+    for (const style of styles) {
+      for (const [, selector, body] of style.content.matchAll(
+        /([#.][a-zA-Z0-9_-]+)\s*\{([^}]+)\}/g
+      )) {
+        if (body && /opacity\s*:\s*0\s*[;}]/.test(body)) {
+          cssOpacityZeroSelectors.add((selector ?? "").trim());
+        }
+      }
+    }
+    for (const tag of tags) {
+      const inlineStyle = readAttr(tag.raw, "style");
+      if (!inlineStyle || !/opacity\s*:\s*0/.test(inlineStyle)) continue;
+      const id = readAttr(tag.raw, "id");
+      const classes = readAttr(tag.raw, "class")?.split(/\s+/).filter(Boolean) ?? [];
+      if (id) cssOpacityZeroSelectors.add(`#${id}`);
+      for (const cls of classes) cssOpacityZeroSelectors.add(`.${cls}`);
+    }
+    if (cssOpacityZeroSelectors.size === 0) return findings;
+    for (const script of scripts) {
+      if (!/gsap\.timeline/.test(script.content)) continue;
+      const windows = await cachedExtractGsapWindows(script.content);
+      for (const win of windows) {
+        if (win.method !== "from") continue;
+        if (!win.properties.includes("opacity")) continue;
+        if (win.propertyValues["opacity"] !== 0) continue;
+        const sel = win.targetSelector;
+        const cssKey = sel.startsWith("#") || sel.startsWith(".") ? sel : `#${sel}`;
+        if (!cssOpacityZeroSelectors.has(cssKey)) continue;
+        findings.push({
+          code: "gsap_from_opacity_noop",
+          severity: "error",
+          message: `"${sel}" has CSS \`opacity: 0\` and a gsap.${win.method}() that also sets opacity to 0. gsap.from() animates FROM the specified value TO the current CSS value \u2014 since CSS is already 0, the element animates from 0\u21920 and never becomes visible.`,
+          selector: sel,
+          fixHint: `Remove \`opacity: 0\` from the CSS/inline style on "${sel}". Let gsap.from({opacity: 0}) handle the initial hidden state \u2014 it will animate FROM 0 TO the CSS value (1 by default).`,
+          snippet: truncateSnippet(win.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // gsap_group_selector_keyframes
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const content = stripJsComments(script.content);
+      const pattern = /\.(?:to|from|fromTo)\(\s*["']([^"']+,\s*[^"']+)["']\s*,\s*\{[^}]*keyframes/g;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const selector = match[1];
+        const count = selector.split(",").length;
+        const contextStart = Math.max(0, match.index - 20);
+        const contextEnd = Math.min(content.length, match.index + match[0].length + 40);
+        findings.push({
+          code: "gsap_group_selector_keyframes",
+          severity: "warning",
+          message: `GSAP tween targets ${count} elements with shared keyframes ("${truncateSnippet(selector, 60)}"). Editing one element's keyframes in Studio will affect all ${count} elements. Split into individual tweens for per-element keyframe control.`,
+          fixHint: `Replace the group selector with individual tl.to() calls per element, each with their own keyframes object.`,
+          snippet: truncateSnippet(content.slice(contextStart, contextEnd))
+        });
+      }
+    }
+    return findings;
+  }
+];
+
+// src/rules/captions.ts
+function extractArrayLiteral(src, varMatch) {
+  const openIdx = varMatch.index + varMatch[0].length - 1;
+  let depth = 0;
+  let inStr = false;
+  let strChar = "";
+  for (let i = openIdx; i < src.length; i++) {
+    const c = src[i];
+    if (inStr) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === strChar) inStr = false;
+    } else if (c === '"' || c === "'") {
+      inStr = true;
+      strChar = c;
+    } else if (c === "[") {
+      depth++;
+    } else if (c === "]") {
+      depth--;
+      if (depth === 0) return src.slice(openIdx, i + 1);
+    }
+  }
+  return null;
+}
+var captionRules = [
+  // caption_exit_missing_hard_kill
+  ({ scripts, styles, options, rootCompositionId }) => {
+    const findings = [];
+    const isCaptionComposition = Boolean(options.filePath && /caption/i.test(options.filePath)) || rootCompositionId === "captions" || styles.some((s) => /\.caption[-_]?(?:group|word|line|block)\b|\.cg-/.test(s.content));
+    if (!isCaptionComposition) return findings;
+    for (const script of scripts) {
+      const content = script.content;
+      const hasExitTween = /\.to\s*\([^,]+,\s*\{[^}]*opacity\s*:\s*0/.test(content);
+      const hasHardKill = /\.set\s*\([^,]+,\s*\{[^}]*(?:visibility\s*:\s*["']hidden["']|opacity\s*:\s*0)/.test(
+        content
+      );
+      const hasCaptionLoop = /forEach|\.forEach\s*\(/.test(content) && /karaoke|caption[-_]?(?:group|word|line|block)|cg-/.test(content);
+      if (hasCaptionLoop && hasExitTween && !hasHardKill) {
+        findings.push({
+          code: "caption_exit_missing_hard_kill",
+          severity: "error",
+          message: "Caption exit animations (tl.to with opacity: 0) detected without a hard tl.set kill. Exit tweens can fail when karaoke word-level tweens conflict, leaving captions stuck on screen.",
+          fixHint: 'Add `tl.set(groupEl, { opacity: 0, visibility: "hidden" }, group.end)` after every exit tl.to animation as a deterministic kill.'
+        });
+      }
+    }
+    return findings;
+  },
+  // caption_text_overflow_risk
+  ({ styles }) => {
+    const findings = [];
+    for (const style of styles) {
+      const captionBlocks = style.content.matchAll(
+        /(\.caption[-_]?(?:group|container|text|line|word)|#caption[-_]?container)\s*\{([^}]+)\}/gi
+      );
+      for (const [, selector, body] of captionBlocks) {
+        if (!body) continue;
+        const hasNowrap = /white-space\s*:\s*nowrap/i.test(body);
+        const hasMaxWidth = /max-width/i.test(body);
+        if (hasNowrap && !hasMaxWidth) {
+          findings.push({
+            code: "caption_text_overflow_risk",
+            severity: "warning",
+            selector: (selector ?? "").trim(),
+            message: `Caption selector "${(selector ?? "").trim()}" has white-space: nowrap but no max-width. Long phrases will clip off-screen.`,
+            fixHint: "Add max-width: 1600px (landscape) or max-width: 900px (portrait) and overflow: hidden."
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // caption_transcript_not_inline
+  // fallow-ignore-next-line complexity
+  ({ scripts, styles, options }) => {
+    const findings = [];
+    const isCaptionFile = options.filePath && /caption/i.test(options.filePath) || styles.some((s) => /\.caption[-_]?(?:group|word)/i.test(s.content));
+    if (!isCaptionFile) return findings;
+    const allScript = scripts.map((s) => s.content).join("\n");
+    const hasInlineTranscript = /(?:const|let|var)\s+(?:TRANSCRIPT|script)\s*=\s*\[/.test(
+      allScript
+    );
+    const hasFetchTranscript = /fetch\s*\(\s*["'][^"']*transcript/i.test(allScript);
+    if (!hasInlineTranscript && hasFetchTranscript) {
+      findings.push({
+        code: "caption_transcript_not_inline",
+        severity: "error",
+        message: "Captions composition loads transcript via fetch(). The studio caption editor requires an inline `var TRANSCRIPT = [...]` array to detect and edit captions.",
+        fixHint: 'Embed the transcript as `var TRANSCRIPT = [{ "text": "...", "start": 0, "end": 1 }, ...]` with JSON-quoted property keys. See the captions skill for details.'
+      });
+    }
+    if (hasInlineTranscript) {
+      const varStart = /(?:const|let|var)\s+(?:TRANSCRIPT|script)\s*=\s*\[/.exec(allScript);
+      const transcriptJson = varStart ? extractArrayLiteral(allScript, varStart) : null;
+      if (transcriptJson) {
+        try {
+          JSON.parse(transcriptJson);
+        } catch {
+          findings.push({
+            code: "caption_transcript_parse_error",
+            severity: "error",
+            message: "Inline TRANSCRIPT array is not valid JSON. The studio caption editor may fail to parse it. Common cause: unquoted property keys with apostrophes in text.",
+            fixHint: `Use JSON-quoted keys: { "text": "don't", "start": 0, "end": 1 } instead of { text: "don't", start: 0, end: 1 }.`
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // caption_container_relative_position
+  ({ styles }) => {
+    const findings = [];
+    for (const style of styles) {
+      const captionBlocks = style.content.matchAll(
+        /(\.caption[-_]?(?:group|container|text|line)|#caption[-_]?container)\s*\{([^}]+)\}/gi
+      );
+      for (const [, selector, body] of captionBlocks) {
+        if (!body) continue;
+        if (/position\s*:\s*relative/i.test(body)) {
+          findings.push({
+            code: "caption_container_relative_position",
+            severity: "error",
+            selector: (selector ?? "").trim(),
+            message: `Caption selector "${(selector ?? "").trim()}" uses position: relative which causes overflow and breaks caption stacking.`,
+            fixHint: "Use position: absolute for all caption elements."
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // caption_overflow_clips_scaled_words
+  ({ styles, scripts }) => {
+    const findings = [];
+    const hasScaledWords = scripts.some(
+      (s) => /scale\s*:\s*1\.[2-9]/.test(s.content) && /caption|word|cg-/.test(s.content)
+    );
+    if (!hasScaledWords) return findings;
+    for (const style of styles) {
+      const captionBlocks = style.content.matchAll(
+        /(\.caption[-_]?(?:group|container)|#caption[-_]?(?:layer|container))\s*\{([^}]+)\}/gi
+      );
+      for (const [, selector, body] of captionBlocks) {
+        if (!body) continue;
+        if (/overflow\s*:\s*hidden/i.test(body)) {
+          findings.push({
+            code: "caption_overflow_clips_scaled_words",
+            severity: "error",
+            selector: (selector ?? "").trim(),
+            message: `"${(selector ?? "").trim()}" has overflow: hidden but GSAP scales caption words above 1.0x. Scaled emphasis words and their glow effects will be clipped.`,
+            fixHint: "Use overflow: visible on caption containers. Rely on fitTextFontSize with reduced maxWidth to prevent overflow instead."
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // caption_textshadow_on_group_container
+  ({ scripts, styles }) => {
+    const findings = [];
+    const isCaptionFile = styles.some((s) => /\.caption[-_]?(?:group|word)/i.test(s.content));
+    if (!isCaptionFile) return findings;
+    for (const script of scripts) {
+      const groupShadowPattern = /\.to\s*\(\s*(?:div|groupEl|el|captionEl|document\.getElementById\s*\(\s*["']cg-)\s*[^,]*,\s*\{[^}]*textShadow/g;
+      const selectorShadowPattern = /\.to\s*\(\s*["'](?:#cg-\d+|\.caption[-_]?group)["']\s*,\s*\{[^}]*textShadow/g;
+      if (groupShadowPattern.test(script.content) || selectorShadowPattern.test(script.content)) {
+        findings.push({
+          code: "caption_textshadow_on_group_container",
+          severity: "warning",
+          message: "textShadow is tweened on a caption group container. When children have semi-transparent color (e.g., inactive karaoke words at rgba opacity), the glow renders as a visible rectangle behind the entire group.",
+          fixHint: "Apply textShadow to individual active word elements instead of the group container. Use scale on the group for bass-reactive pulsing."
+        });
+      }
+    }
+    return findings;
+  },
+  // caption_fittext_scale_mismatch
+  // fallow-ignore-next-line complexity
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const content = script.content;
+      const fitTextMatch = content.match(/fitTextFontSize\s*\([^)]*maxWidth\s*:\s*(\d+)/);
+      if (!fitTextMatch) continue;
+      const maxWidth = parseInt(fitTextMatch[1] ?? "0", 10);
+      if (!maxWidth) continue;
+      const scaleMatches = [...content.matchAll(/scale\s*:\s*(1\.\d+)/g)];
+      const captionContext = /caption|word|cg-|karaoke/i.test(content);
+      if (!captionContext || scaleMatches.length === 0) continue;
+      let maxScale = 1;
+      for (const m of scaleMatches) {
+        const val = parseFloat(m[1] ?? "1");
+        if (val > maxScale) maxScale = val;
+      }
+      const effectiveWidth = maxWidth * maxScale;
+      if (effectiveWidth > 1760) {
+        findings.push({
+          code: "caption_fittext_scale_mismatch",
+          severity: "warning",
+          message: `fitTextFontSize uses maxWidth: ${maxWidth}px but emphasis words scale up to ${maxScale}x. Effective width ${Math.round(effectiveWidth)}px may overflow the composition (1920px minus margins).`,
+          fixHint: `Reduce maxWidth to ${Math.floor(1700 / maxScale)}px to leave headroom for scaled emphasis words.`
+        });
+      }
+    }
+    return findings;
+  }
+];
+
+// src/rules/composition.ts
+import { COMPOSITION_VARIABLE_TYPES } from "@hyperframes/parsers/composition";
+var MAX_COMPOSITION_LINES = 300;
+var MAX_TIMED_ELEMENTS_PER_TRACK = 3;
+var TRACK_DENSITY_EXEMPT_TAGS = /* @__PURE__ */ new Set(["audio", "script", "style", "video"]);
+function countPhysicalLines(source) {
+  if (source.length === 0) return 0;
+  const normalized = source.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const withoutFinalNewline = normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized;
+  return withoutFinalNewline.split("\n").length;
+}
+function countStructuralLines(source) {
+  return countPhysicalLines(source.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "<style></style>"));
+}
+function isRegistrySourceFile(filePath) {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  return /(?:^|\/)registry\/blocks\/([^/]+)\/\1\.html$/i.test(normalized);
+}
+function isRegistryInstalledFile(rawSource) {
+  return /^\s*<!--\s*hyperframes-registry-item:[^>]*-->/i.test(rawSource.slice(0, 512));
+}
+function isCompositionRootOrMount(rawTag) {
+  return Boolean(
+    readAttr(rawTag, "data-composition-id") || readAttr(rawTag, "data-composition-src")
+  );
+}
+function extractCssUrlReferences(css) {
+  const out = [];
+  const noComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const urlPattern = /\burl\(\s*(["']?)([^)"']+)\1\s*\)/g;
+  let m;
+  while ((m = urlPattern.exec(noComments)) !== null) {
+    const raw = (m[2] ?? "").trim();
+    if (raw) out.push(raw);
+  }
+  return out;
+}
+function extractCssSelectors(css) {
+  const out = [];
+  const noComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const ruleHeader = /([^{}]+)\{/g;
+  let m;
+  while ((m = ruleHeader.exec(noComments)) !== null) {
+    const header = (m[1] ?? "").trim();
+    if (!header || header.startsWith("@")) continue;
+    for (const sel of header.split(",")) {
+      const s = sel.trim();
+      if (s) out.push(s);
+    }
+  }
+  return out;
+}
+function leftmostCompoundClasses(selector) {
+  const leftmost = selector.trim().split(/[\s>+~]+/)[0] ?? "";
+  return (leftmost.match(/\.([\w-]+)/g) ?? []).map((c) => c.slice(1));
+}
+function rootClassStyledSelectors(styles, rootClasses) {
+  const offenders = [];
+  for (const style of styles) {
+    for (const selector of extractCssSelectors(style.content)) {
+      const hitsRoot = leftmostCompoundClasses(selector).some((c) => rootClasses.includes(c));
+      if (hitsRoot && !offenders.includes(selector)) offenders.push(selector);
+    }
+  }
+  return offenders;
+}
+var compositionRules = [
+  // invalid_parent_traversal_in_asset_path — catches `../` traversal in src,
+  // href, inline-style url(), and <style> url() asset references on
+  // compositions. Sub-compositions live under compositions/ but are served
+  // with the project root as their base URL, so any `../`-traversing path
+  // climbs above the project root and 404s in Studio preview. Renders
+  // tolerate it because the server-side bundler rewrites `../foo` against
+  // each sub-composition's source path; the runtime now mirrors that fallback
+  // (see rewriteSubCompositionAssetPaths in runtime/compositionLoader.ts), but
+  // the authoring-time signal is still wrong — flag it at lint time so the
+  // baked path is plain root-relative and matches what the bundler emits.
+  //
+  // Mirrors the runtime fallback's surface: `[src]` / `[href]` attribute
+  // values, `[style]` inline url(), and `<style>` block url() references.
+  // Skips absolute URLs (http(s)://, //, data:, /-prefixed root-relative),
+  // hash anchors, and plain relative paths (`assets/x.mp4`) — only `../`
+  // traversal is flagged. Subsumes the older `../capture/`-specific rule.
+  // fallow-ignore-next-line complexity
+  ({ tags, styles, rawSource, options }) => {
+    if (isRegistrySourceFile(options.filePath) || isRegistryInstalledFile(rawSource)) return [];
+    const offenders = [];
+    const collect = (value) => {
+      if (!value) return;
+      const trimmed = value.trim();
+      if (!trimmed.startsWith("../") && trimmed !== "..") return;
+      offenders.push(trimmed);
+    };
+    for (const tag of tags) {
+      collect(readAttr(tag.raw, "src"));
+      collect(readAttr(tag.raw, "href"));
+      const styleAttr = readJsonAttr(tag.raw, "style");
+      if (styleAttr) {
+        for (const url of extractCssUrlReferences(styleAttr)) collect(url);
+      }
+    }
+    for (const style of styles) {
+      for (const url of extractCssUrlReferences(style.content)) collect(url);
+    }
+    if (offenders.length === 0) return [];
+    const prefixCounts = /* @__PURE__ */ new Map();
+    for (const path of offenders) {
+      const prefix = path.match(/^(?:\.\.\/)+[^/]+\//)?.[0] ?? path;
+      prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 0) + 1);
+    }
+    const prefixSummary = Array.from(prefixCounts.entries()).sort(([, a], [, b]) => b - a).map(([prefix, count]) => count > 1 ? `${prefix} (${count})` : prefix).join(", ");
+    return [
+      {
+        code: "invalid_parent_traversal_in_asset_path",
+        severity: "error",
+        message: `Found ${offenders.length} asset path(s) traversing above the project root with "../" (${prefixSummary}). Renders rewrite this against each sub-composition's source path, but Studio preview and other live consumers resolve against the project root and 404.`,
+        fixHint: 'Use plain root-relative paths (e.g. "assets/...", "capture/...", "fonts/...") \u2014 compositions are served with the project root as their base URL, so paths must be root-relative, not relative to the compositions/ directory.'
+      }
+    ];
+  },
+  // composition_file_too_large
+  ({ rawSource, options }) => {
+    if (isRegistrySourceFile(options.filePath) || isRegistryInstalledFile(rawSource)) return [];
+    const lineCount = countStructuralLines(rawSource);
+    if (lineCount <= MAX_COMPOSITION_LINES) return [];
+    const splitTarget = options.isSubComposition ? "Split this sub-composition further into smaller .html files" : "Split coherent scenes or layers into separate .html files under compositions/";
+    return [
+      {
+        code: "composition_file_too_large",
+        severity: "warning",
+        message: `This HTML composition file has ${lineCount} lines. Smaller sub-compositions are easier to read, iterate on, and diff.`,
+        fixHint: `${splitTarget}, then mount them from the parent with data-composition-src so each file stays small enough to inspect, revise, and validate independently.`
+      }
+    ];
+  },
+  // timeline_track_too_dense
+  // fallow-ignore-next-line complexity
+  ({ tags, options }) => {
+    const trackCounts = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      if (TRACK_DENSITY_EXEMPT_TAGS.has(tag.name)) continue;
+      if (isCompositionRootOrMount(tag.raw)) continue;
+      if (!readAttr(tag.raw, "data-start")) continue;
+      const track = readAttr(tag.raw, "data-track-index");
+      if (!track) continue;
+      trackCounts.set(track, (trackCounts.get(track) ?? 0) + 1);
+    }
+    const findings = [];
+    for (const [track, count] of trackCounts) {
+      if (count <= MAX_TIMED_ELEMENTS_PER_TRACK) continue;
+      const splitTarget = options.isSubComposition ? "Move coherent scene groups into smaller .html files" : "Move coherent scene groups into separate .html files under compositions/";
+      findings.push({
+        code: "timeline_track_too_dense",
+        severity: "warning",
+        message: `Track ${track} has ${count} timed elements in this HTML file. Smaller sub-compositions keep timelines easier to read, iterate on, and diff.`,
+        fixHint: `${splitTarget} and mount them from the parent with data-composition-src so the timeline stays easier to inspect, revise, and validate.`
+      });
+    }
+    return findings;
+  },
+  // timed_element_missing_visibility_hidden
+  // fallow-ignore-next-line complexity
+  ({ tags }) => {
+    const findings = [];
+    for (const tag of tags) {
+      if (tag.name === "audio" || tag.name === "script" || tag.name === "style") continue;
+      if (!readAttr(tag.raw, "data-start")) continue;
+      if (readAttr(tag.raw, "data-composition-id")) continue;
+      if (readAttr(tag.raw, "data-composition-src")) continue;
+      const classAttr = readAttr(tag.raw, "class") || "";
+      const styleAttr = readAttr(tag.raw, "style") || "";
+      const hasClip = classAttr.split(/\s+/).includes("clip");
+      const hasHiddenStyle = /visibility\s*:\s*hidden/i.test(styleAttr) || /opacity\s*:\s*0/i.test(styleAttr);
+      if (!hasClip && !hasHiddenStyle) {
+        const elementId = readAttr(tag.raw, "id") || void 0;
+        findings.push({
+          code: "timed_element_missing_visibility_hidden",
+          severity: "info",
+          message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> has data-start but no class="clip", visibility:hidden, or opacity:0. Consider adding initial hidden state if the element should not be visible before its start time.`,
+          elementId,
+          fixHint: 'Add class="clip" (with CSS: .clip { visibility: hidden; }) or style="opacity:0" if the element should start hidden.',
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // deprecated_data_layer + deprecated_data_end
+  // fallow-ignore-next-line complexity
+  ({ tags }) => {
+    const findings = [];
+    for (const tag of tags) {
+      if (readAttr(tag.raw, "data-layer") && !readAttr(tag.raw, "data-track-index")) {
+        const elementId = readAttr(tag.raw, "id") || void 0;
+        findings.push({
+          code: "deprecated_data_layer",
+          severity: "error",
+          message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> uses data-layer instead of data-track-index.`,
+          elementId,
+          fixHint: "Replace data-layer with data-track-index. The runtime reads data-track-index.",
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (readAttr(tag.raw, "data-end") && !readAttr(tag.raw, "data-duration")) {
+        const elementId = readAttr(tag.raw, "id") || void 0;
+        findings.push({
+          code: "deprecated_data_end",
+          severity: "error",
+          message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> uses data-end without data-duration. Use data-duration in source HTML.`,
+          elementId,
+          fixHint: "Replace data-end with data-duration. The compiler generates data-end from data-duration automatically.",
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // split_data_attribute_selector
+  ({ scripts, styles }) => {
+    const findings = [];
+    const splitDataAttrSelectorPattern = /\[data-composition-id=(["'])([^"'\]]+)\1\s+(data-[\w:-]+)=(["'])([^"'\]]*)\4\]/g;
+    const scan = (content) => {
+      splitDataAttrSelectorPattern.lastIndex = 0;
+      let match;
+      while ((match = splitDataAttrSelectorPattern.exec(content)) !== null) {
+        const compId = match[2] ?? "";
+        const attrName = match[3] ?? "";
+        const attrValue = match[5] ?? "";
+        findings.push({
+          code: "split_data_attribute_selector",
+          severity: "error",
+          message: `Selector "${match[0]}" combines two attributes inside one CSS attribute selector. Browsers reject it, so GSAP timelines or querySelector calls will fail before registering.`,
+          selector: match[0],
+          fixHint: `Use separate attribute selectors: [data-composition-id="${compId}"][${attrName}="${attrValue}"].`,
+          snippet: truncateSnippet(match[0])
+        });
+      }
+    };
+    for (const style of styles) scan(style.content);
+    for (const script of scripts) scan(script.content);
+    return findings;
+  },
+  // template_literal_selector
+  ({ scripts }) => {
+    const findings = [];
+    for (const script of scripts) {
+      const templateLiteralSelectorPattern = /(?:querySelector|querySelectorAll)\s*\(\s*`[^`]*\$\{[^}]+\}[^`]*`\s*\)/g;
+      let tlMatch;
+      while ((tlMatch = templateLiteralSelectorPattern.exec(script.content)) !== null) {
+        findings.push({
+          code: "template_literal_selector",
+          severity: "error",
+          message: "querySelector uses a template literal variable (e.g. `${compId}`). The HTML bundler's CSS parser crashes on these. Use a hardcoded string instead.",
+          fixHint: "Replace the template literal variable with a hardcoded string. The bundler's CSS parser cannot handle interpolated variables in script content.",
+          snippet: truncateSnippet(tlMatch[0])
+        });
+      }
+    }
+    return findings;
+  },
+  // timed_element_missing_clip_class
+  // fallow-ignore-next-line complexity
+  ({ tags }) => {
+    const findings = [];
+    const skipTags = /* @__PURE__ */ new Set(["audio", "video", "script", "style", "template"]);
+    for (const tag of tags) {
+      if (skipTags.has(tag.name)) continue;
+      if (readAttr(tag.raw, "data-composition-id")) continue;
+      if (readAttr(tag.raw, "data-composition-src")) continue;
+      const hasStart = readAttr(tag.raw, "data-start") !== null;
+      const hasDuration = readAttr(tag.raw, "data-duration") !== null;
+      if (!hasStart && !hasDuration) continue;
+      const classAttr = readAttr(tag.raw, "class") || "";
+      const hasClip = classAttr.split(/\s+/).includes("clip");
+      if (hasClip) continue;
+      const elementId = readAttr(tag.raw, "id") || void 0;
+      findings.push({
+        code: "timed_element_missing_clip_class",
+        severity: "error",
+        message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> has timing attributes but no class="clip". The element will be visible for the entire composition instead of only during its scheduled time range.`,
+        elementId,
+        fixHint: 'Add class="clip" to the element. The HyperFrames runtime uses .clip to control visibility based on data-start/data-duration.',
+        snippet: truncateSnippet(tag.raw)
+      });
+    }
+    return findings;
+  },
+  // overlapping_clips_same_track
+  // fallow-ignore-next-line complexity
+  ({ tags }) => {
+    const findings = [];
+    const trackMap = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      const startStr = readAttr(tag.raw, "data-start");
+      const durationStr = readAttr(tag.raw, "data-duration");
+      const trackStr = readAttr(tag.raw, "data-track-index");
+      if (!startStr || !durationStr || !trackStr) continue;
+      const start = Number(startStr);
+      const duration = Number(durationStr);
+      const track = trackStr;
+      if (Number.isNaN(start) || Number.isNaN(duration)) continue;
+      const clips = trackMap.get(track) || [];
+      clips.push({
+        start,
+        end: start + duration,
+        elementId: readAttr(tag.raw, "id") || void 0,
+        snippet: truncateSnippet(tag.raw) || ""
+      });
+      trackMap.set(track, clips);
+    }
+    for (const [track, clips] of trackMap) {
+      clips.sort((a, b) => a.start - b.start);
+      for (let i = 0; i < clips.length - 1; i++) {
+        const current = clips[i];
+        const next = clips[i + 1];
+        if (!current || !next) continue;
+        if (current.end > next.start) {
+          findings.push({
+            code: "overlapping_clips_same_track",
+            severity: "error",
+            message: `Track ${track}: clip ending at ${current.end}s overlaps with clip starting at ${next.start}s. Overlapping clips on the same track cause rendering conflicts.`,
+            fixHint: "Adjust data-start or data-duration so clips on the same track do not overlap, or move one clip to a different data-track-index."
+          });
+        }
+      }
+    }
+    return findings;
+  },
+  // root_composition_missing_data_start
+  ({ rootTag, options }) => {
+    const findings = [];
+    if (options.isSubComposition) return findings;
+    if (!rootTag) return findings;
+    const compId = readAttr(rootTag.raw, "data-composition-id");
+    if (!compId) return findings;
+    const hasStart = readAttr(rootTag.raw, "data-start") !== null;
+    if (!hasStart) {
+      findings.push({
+        code: "root_composition_missing_data_start",
+        severity: "error",
+        message: `Root composition "${compId}" is missing data-start. The runtime needs data-start="0" on the root element to begin playback.`,
+        fixHint: 'Add data-start="0" to the root composition element.',
+        snippet: truncateSnippet(rootTag.raw)
+      });
+    }
+    return findings;
+  },
+  // standalone_composition_wrapped_in_template
+  ({ rawSource, options }) => {
+    const findings = [];
+    if (options.isSubComposition) return findings;
+    const trimmed = rawSource.trimStart().toLowerCase();
+    if (trimmed.startsWith("<template")) {
+      findings.push({
+        code: "standalone_composition_wrapped_in_template",
+        severity: "error",
+        message: "Root index.html is wrapped in a <template> tag. Only sub-compositions loaded via data-composition-src should use <template> wrappers. The runtime cannot play a standalone composition inside a template.",
+        fixHint: "Remove the <template> wrapper. Use <!DOCTYPE html><html>...<div data-composition-id>...</div>...</html> instead."
+      });
+    }
+    return findings;
+  },
+  // root_composition_missing_html_wrapper
+  ({ rawSource, rootTag, options }) => {
+    const findings = [];
+    if (options.isSubComposition) return findings;
+    const trimmed = rawSource.trimStart().toLowerCase();
+    if (trimmed.startsWith("<template")) return findings;
+    const hasDoctype = trimmed.startsWith("<!doctype") || trimmed.startsWith("<html");
+    const hasComposition = rawSource.includes("data-composition-id");
+    if (hasComposition && !hasDoctype) {
+      findings.push({
+        code: "root_composition_missing_html_wrapper",
+        severity: "error",
+        message: "Composition starts with a bare element instead of a proper HTML document. An index.html that contains data-composition-id but no <!DOCTYPE html>, <html>, or <body> is a fragment \u2014 browsers quirks-mode it, the preview server cannot load it, and the bundler will fail to inject runtime scripts.",
+        fixHint: 'Wrap the composition in <!DOCTYPE html><html><head><meta charset="UTF-8"></head><body>...</body></html>.',
+        snippet: rootTag ? truncateSnippet(rootTag.raw) : void 0
+      });
+    }
+    return findings;
+  },
+  // requestanimationframe_in_composition
+  ({ scripts, rawSource, options }) => {
+    if (isRegistrySourceFile(options.filePath) || isRegistryInstalledFile(rawSource)) return [];
+    const findings = [];
+    for (const script of scripts) {
+      const stripped = stripJsComments(script.content);
+      if (/requestAnimationFrame\s*\(/.test(stripped)) {
+        findings.push({
+          code: "requestanimationframe_in_composition",
+          severity: "error",
+          message: "`requestAnimationFrame` runs on wall-clock time, not the GSAP timeline. It will not sync with frame capture and may cause flickering or missed frames during rendering.",
+          fixHint: "Use GSAP tweens or onUpdate callbacks instead of requestAnimationFrame for animation logic.",
+          snippet: truncateSnippet(script.content)
+        });
+      }
+    }
+    return findings;
+  },
+  // invalid_variable_values_json
+  // Host elements (`[data-composition-src]`) carry per-instance values via
+  // `data-variable-values`. The runtime swallows JSON errors silently and
+  // falls back to declared defaults, which masks typos. This rule surfaces
+  // the parse failure so authors notice before render time.
+  // fallow-ignore-next-line complexity
+  ({ tags }) => {
+    const findings = [];
+    for (const tag of tags) {
+      const raw = readJsonAttr(tag.raw, "data-variable-values");
+      if (!raw) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : "unknown";
+        findings.push({
+          code: "invalid_variable_values_json",
+          severity: "error",
+          message: `data-variable-values is not valid JSON (${reason}).`,
+          fixHint: `Wrap the attribute value in single quotes and the JSON keys/values in double quotes, e.g. data-variable-values='{"title":"Hello"}'.`,
+          elementId: readAttr(tag.raw, "id") || void 0,
+          snippet: truncateSnippet(tag.raw)
+        });
+        continue;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        findings.push({
+          code: "invalid_variable_values_json",
+          severity: "error",
+          message: 'data-variable-values must be a JSON object keyed by variable id (e.g. {"title":"Hello"}).',
+          fixHint: "Replace the value with a JSON object whose keys are variable ids declared in the sub-composition's data-composition-variables.",
+          elementId: readAttr(tag.raw, "id") || void 0,
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // invalid_composition_variables_declaration
+  // The runtime parses `data-composition-variables` and silently returns []
+  // on any structural problem. Surface JSON / shape failures so authors
+  // catch them at lint time rather than wondering why their `getVariables()`
+  // defaults aren't applied.
+  // fallow-ignore-next-line complexity
+  ({ source }) => {
+    const htmlTag = findHtmlTag(source);
+    if (!htmlTag) return [];
+    const raw = readJsonAttr(htmlTag.raw, "data-composition-variables");
+    if (!raw) return [];
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : "unknown";
+      return [
+        {
+          code: "invalid_composition_variables_declaration",
+          severity: "error",
+          message: `data-composition-variables is not valid JSON (${reason}).`,
+          fixHint: `Provide a JSON array of variable declarations: data-composition-variables='[{"id":"title","type":"string","label":"Title","default":"Hello"}]'.`,
+          snippet: truncateSnippet(htmlTag.raw)
+        }
+      ];
+    }
+    if (!Array.isArray(parsed)) {
+      return [
+        {
+          code: "invalid_composition_variables_declaration",
+          severity: "error",
+          message: "data-composition-variables must be a JSON array of variable declarations.",
+          fixHint: `Wrap declarations in [] and give each an id, type, label, and default: '[{"id":"title","type":"string","label":"Title","default":"Hello"}]'.`,
+          snippet: truncateSnippet(htmlTag.raw)
+        }
+      ];
+    }
+    const findings = [];
+    const knownTypes = new Set(COMPOSITION_VARIABLE_TYPES);
+    for (let i = 0; i < parsed.length; i += 1) {
+      const entry = parsed[i];
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        findings.push({
+          code: "invalid_composition_variables_declaration",
+          severity: "error",
+          message: `data-composition-variables entry [${i}] must be an object with id, type, label, and default.`,
+          snippet: truncateSnippet(htmlTag.raw)
+        });
+        continue;
+      }
+      const e = entry;
+      const missing = [];
+      if (typeof e.id !== "string") missing.push("id");
+      if (typeof e.type !== "string" || !knownTypes.has(e.type)) missing.push("type");
+      if (typeof e.label !== "string") missing.push("label");
+      if (!("default" in e)) missing.push("default");
+      if (missing.length > 0) {
+        findings.push({
+          code: "invalid_composition_variables_declaration",
+          severity: "error",
+          message: `data-composition-variables entry [${i}] is missing or has invalid: ${missing.join(", ")}. Type must be one of string, number, color, boolean, enum, font, image.`,
+          snippet: truncateSnippet(htmlTag.raw)
+        });
+      }
+    }
+    return findings;
+  },
+  // subcomposition_blanks_before_host
+  // Warns when a full-bleed sub-composition slot ends before the host composition
+  // does, leaving the slot blank for the remainder (issue #1540). Scoped narrowly to
+  // the high-signal shape — a sole/dominant external mount starting at ~0 — so it
+  // stays silent on intentional short clips (an intro followed by other clips that
+  // carry the timeline forward).
+  // fallow-ignore-next-line complexity
+  ({ tags, rootTag }) => {
+    if (!rootTag) return [];
+    const rootDuration = Number(readAttr(rootTag.raw, "data-duration"));
+    if (!Number.isFinite(rootDuration) || rootDuration <= 0) return [];
+    const EPSILON = 0.5;
+    const START_TOLERANCE = 0.5;
+    const round3 = (n) => Math.round(n * 1e3) / 1e3;
+    const timed = tags.filter((tag) => tag.index !== rootTag.index && readAttr(tag.raw, "data-start") !== null).map((tag) => {
+      const start = Number(readAttr(tag.raw, "data-start")) || 0;
+      const dur = Number(readAttr(tag.raw, "data-duration"));
+      const end = Number.isFinite(dur) && dur > 0 ? start + dur : Infinity;
+      return { tag, start, end };
+    });
+    const tailCovered = (exceptIndex) => timed.some((t) => t.tag.index !== exceptIndex && t.end >= rootDuration - EPSILON);
+    const findings = [];
+    for (const t of timed) {
+      if (readAttr(t.tag.raw, "data-composition-src") === null) continue;
+      if (t.start > START_TOLERANCE) continue;
+      if (!Number.isFinite(t.end)) continue;
+      if (t.end >= rootDuration - EPSILON) continue;
+      if (tailCovered(t.tag.index)) continue;
+      const elementId = readAttr(t.tag.raw, "id") || void 0;
+      const gap = round3(rootDuration - t.end);
+      findings.push({
+        code: "subcomposition_blanks_before_host",
+        severity: "warning",
+        message: `<${t.tag.name}${elementId ? ` id="${elementId}"` : ""}> sub-composition ends at ${round3(t.end)}s but the composition runs to ${round3(rootDuration)}s \u2014 its slot will be blank for ~${gap}s.`,
+        elementId,
+        fixHint: `data-duration is the slot's visible window. Set this sub-composition's data-duration to ${round3(rootDuration - t.start)} to fill the host window, or add another clip to cover the remaining ~${gap}s.`,
+        snippet: truncateSnippet(t.tag.raw)
+      });
+    }
+    return findings;
+  },
+  // subcomposition_root_styled_by_class
+  // A sub-composition's <style> is scoped at render time to
+  // `[data-composition-id="<id>"] <selector>` so scenes inlined into one document
+  // can't leak styles into each other. A rule whose LEFTMOST selector is the ROOT
+  // element's own class (e.g. `.frame { ... }` on the same element that carries
+  // data-composition-id) therefore becomes a DESCENDANT selector that can never
+  // match the root — the whole scene renders unstyled (tiny text top-left, images
+  // at natural size). lint/validate/inspect evaluate the file in isolation (no
+  // scoping) and Studio previews each scene in its own iframe (no scoping), so the
+  // break is invisible until the composited MP4 render. Style the root via `#root`
+  // (the scoper special-cases the root id) and descendants via plain selectors,
+  // like the registry blocks — the runtime already scopes each scene by id, so a
+  // class namespace on the root is redundant.
+  ({ rootTag, rootCompositionId, styles, options }) => {
+    if (!options.isSubComposition) return [];
+    if (isRegistrySourceFile(options.filePath)) return [];
+    if (!rootTag || !rootCompositionId) return [];
+    const rootClasses = (readAttr(rootTag.raw, "class") || "").split(/\s+/).filter(Boolean);
+    if (rootClasses.length === 0) return [];
+    const offenders = rootClassStyledSelectors(styles, rootClasses);
+    if (offenders.length === 0) return [];
+    const example = offenders.slice(0, 3).join(", ");
+    return [
+      {
+        code: "subcomposition_root_styled_by_class",
+        severity: "error",
+        message: `Root element has class="${rootClasses.join(" ")}" and is styled by ${offenders.length} rule(s) keyed off that class (e.g. ${example}). At render, every sub-composition rule is scoped to [data-composition-id="${rootCompositionId}"] <selector>, so a selector whose leftmost part is the ROOT's own class becomes a descendant selector that cannot match the root \u2014 the scene renders unstyled (tiny text top-left, full-size images). lint/validate/inspect and Studio's per-frame iframe preview do not scope, so this passes every static check and looks correct in preview.`,
+        selector: example,
+        fixHint: `Give the root id="root" and style it with \`#root { ... }\` plus plain descendant selectors (\`.kicker\`, \`#hero\`) \u2014 the runtime already scopes each sub-composition by data-composition-id, so a class namespace on the root is redundant and breaks under scoping.`,
+        snippet: truncateSnippet(rootTag.raw)
+      }
+    ];
+  }
+];
+
+// src/rules/adapters.ts
+var adapterRules = [
+  // missing_lottie_script
+  ({ tags, scripts }) => {
+    const { texts, srcs } = extractScriptTextsAndSrcs(scripts);
+    const hasLottieAttr = tags.some((t) => readAttr(t.raw, "data-lottie-src") !== null);
+    const usesLottieApi = texts.some(
+      (t) => /lottie\.(loadAnimation|setSpeed|play|stop|destroy)\b/.test(t)
+    );
+    const hasLottieScript = srcs.some((src) => /lottie/i.test(src));
+    if (!(hasLottieAttr || usesLottieApi) || hasLottieScript) return [];
+    return [
+      {
+        code: "missing_lottie_script",
+        severity: "error",
+        message: "Composition uses Lottie but no Lottie script is loaded. The animation will not render.",
+        fixHint: 'Add <script src="https://cdn.jsdelivr.net/npm/lottie-web@5/build/player/lottie.min.js"><\/script> before your Lottie code.'
+      }
+    ];
+  },
+  // missing_three_script
+  ({ scripts }) => {
+    const { texts, srcs } = extractScriptTextsAndSrcs(scripts);
+    const usesThree = texts.some((t) => /\bTHREE\./.test(t));
+    const hasThreeScript = srcs.some((src) => /three/i.test(src));
+    const hasThreeImportMap = texts.some(
+      (t) => /["']three["']/.test(t) && /importmap/.test(scripts.find((s) => s.content === t)?.attrs || "")
+    );
+    const hasThreeModuleImport = texts.some(
+      (t) => /\bimport\b.*['"]three['"]/.test(t) || /\bfrom\s+['"]three['"]/.test(t)
+    );
+    if (!usesThree || hasThreeScript || hasThreeImportMap || hasThreeModuleImport) return [];
+    return [
+      {
+        code: "missing_three_script",
+        severity: "error",
+        message: "Composition uses Three.js but no Three.js script is loaded. The 3D scene will not render.",
+        fixHint: 'Add <script src="https://cdn.jsdelivr.net/npm/three@0.160/build/three.min.js"><\/script> before your Three.js code.'
+      }
+    ];
+  }
+];
+
+// src/rules/textures.ts
+import postcss2 from "postcss";
+var TEXTURE_BASE_CLASS = "hf-texture-text";
+var TEXTURE_CLASS_PREFIX = "hf-texture-";
+function classNames(tag) {
+  return (readAttr(tag.raw, "class") ?? "").split(/\s+/).filter(Boolean);
+}
+function isTextureMaterialClass(className) {
+  return className.startsWith(TEXTURE_CLASS_PREFIX) && className !== TEXTURE_BASE_CLASS;
+}
+function hasInlineMaskImage(tag) {
+  const style = readAttr(tag.raw, "style") ?? "";
+  return /\b(?:-webkit-)?mask-image\s*:/i.test(style);
+}
+function hasInlineDropShadow(tag) {
+  const style = readAttr(tag.raw, "style") ?? "";
+  return /\bfilter\s*:\s*[^;]*\bdrop-shadow\s*\(/i.test(style);
+}
+function classNamesInSelector(selector) {
+  const classes = /* @__PURE__ */ new Set();
+  const pattern = /\.([A-Za-z_][\w-]*)/g;
+  let match;
+  while ((match = pattern.exec(selector)) !== null) {
+    const className = match[1];
+    if (!className) continue;
+    classes.add(className);
+  }
+  return [...classes];
+}
+function textureClassesInSelector(selector) {
+  return classNamesInSelector(selector).filter(isTextureMaterialClass);
+}
+function simpleSelectorMatchesTag(selector, tag, tagClasses) {
+  const trimmed = selector.trim();
+  const simpleSelectorPattern = /^(?:[A-Za-z][\w-]*)?(?:\.[A-Za-z_][\w-]*)+$/;
+  if (!simpleSelectorPattern.test(trimmed)) return false;
+  const typeMatch = /^([A-Za-z][\w-]*)/.exec(trimmed);
+  if (typeMatch && typeMatch[1].toLowerCase() !== tag.name) return false;
+  const selectorClasses = classNamesInSelector(trimmed);
+  return selectorClasses.length > 0 && selectorClasses.every((className) => tagClasses.includes(className));
+}
+function collectTextureCss(styles) {
+  const definedTextureClasses = /* @__PURE__ */ new Set();
+  const dropShadowRules = [];
+  const roots = [];
+  for (const style of styles) {
+    let root;
+    try {
+      root = postcss2.parse(style.content);
+    } catch {
+      continue;
+    }
+    roots.push(root);
+    root.walkRules((rule) => {
+      const selectors = rule.selectors ?? [];
+      let hasMaskImage = false;
+      for (const node of rule.nodes ?? []) {
+        if (node.type !== "decl") continue;
+        const prop = node.prop.toLowerCase();
+        if (prop === "mask-image" || prop === "-webkit-mask-image") hasMaskImage = true;
+      }
+      if (hasMaskImage) {
+        for (const selector of selectors) {
+          for (const className of textureClassesInSelector(selector)) {
+            definedTextureClasses.add(className);
+          }
+        }
+      }
+    });
+  }
+  for (const root of roots) {
+    root.walkRules((rule) => {
+      const selectors = rule.selectors ?? [];
+      let hasDropShadow = false;
+      for (const node of rule.nodes ?? []) {
+        if (node.type !== "decl") continue;
+        if (node.prop.toLowerCase() === "filter" && /\bdrop-shadow\s*\(/i.test(node.value)) {
+          hasDropShadow = true;
+        }
+      }
+      if (hasDropShadow) {
+        for (const selector of selectors) {
+          const targetsBaseClass = /\.hf-texture-text\b/.test(selector);
+          const targetsDefinedTextureClass = textureClassesInSelector(selector).some(
+            (className) => definedTextureClasses.has(className)
+          );
+          dropShadowRules.push({
+            selector,
+            directlyTargetsTexture: targetsBaseClass || targetsDefinedTextureClass
+          });
+        }
+      }
+    });
+  }
+  return { definedTextureClasses, dropShadowRules };
+}
+var textureRules = [
+  ({ tags, styles }) => {
+    const findings = [];
+    const { definedTextureClasses, dropShadowRules } = collectTextureCss(styles);
+    for (const { selector, directlyTargetsTexture } of dropShadowRules) {
+      if (!directlyTargetsTexture) continue;
+      findings.push({
+        code: "texture_drop_shadow_on_text",
+        severity: "warning",
+        message: "Drop shadow is applied directly to textured text.",
+        selector,
+        fixHint: "Wrap the textured text and apply `filter: drop-shadow(...)` to the wrapper, not the `hf-texture-text` element."
+      });
+    }
+    for (const tag of tags) {
+      if (tag.name === "style" || tag.name === "script") continue;
+      const classes = classNames(tag);
+      if (classes.length === 0) continue;
+      const hasBaseClass = classes.includes(TEXTURE_BASE_CLASS);
+      const textureClasses = classes.filter(isTextureMaterialClass);
+      if (textureClasses.length > 0 && !hasBaseClass) {
+        findings.push({
+          code: "texture_class_missing_base",
+          severity: "warning",
+          message: `Texture material class \`${textureClasses[0]}\` is used without \`${TEXTURE_BASE_CLASS}\`.`,
+          elementId: readAttr(tag.raw, "id") || void 0,
+          fixHint: `Add \`${TEXTURE_BASE_CLASS}\` alongside the material class, for example \`class="${TEXTURE_BASE_CLASS} ${textureClasses[0]}"\`.`,
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (hasBaseClass && textureClasses.length === 0 && !hasInlineMaskImage(tag)) {
+        findings.push({
+          code: "texture_text_missing_mask",
+          severity: "warning",
+          message: `\`${TEXTURE_BASE_CLASS}\` is used without a texture material class or custom mask image.`,
+          elementId: readAttr(tag.raw, "id") || void 0,
+          fixHint: "Add a material class such as `hf-texture-lava`, or set `mask-image` and `-webkit-mask-image` on the element.",
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      for (const textureClass of textureClasses) {
+        if (definedTextureClasses.has(textureClass)) continue;
+        findings.push({
+          code: "texture_class_unknown",
+          severity: "error",
+          message: `Texture material class \`${textureClass}\` is not defined by local CSS.`,
+          elementId: readAttr(tag.raw, "id") || void 0,
+          fixHint: "Paste the Texture Mask Text component `<style>...</style>` block into the composition, or fix the texture class typo.",
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+      if (hasBaseClass) {
+        for (const rule of dropShadowRules) {
+          if (rule.directlyTargetsTexture) continue;
+          if (!simpleSelectorMatchesTag(rule.selector, tag, classes)) continue;
+          findings.push({
+            code: "texture_drop_shadow_on_text",
+            severity: "warning",
+            message: "Drop shadow is applied directly to textured text.",
+            selector: rule.selector,
+            elementId: readAttr(tag.raw, "id") || void 0,
+            fixHint: "Wrap the textured text and apply `filter: drop-shadow(...)` to the wrapper, not the `hf-texture-text` element.",
+            snippet: truncateSnippet(tag.raw)
+          });
+        }
+      }
+      if (hasBaseClass && hasInlineDropShadow(tag)) {
+        findings.push({
+          code: "texture_drop_shadow_on_text",
+          severity: "warning",
+          message: "Drop shadow is applied directly to textured text.",
+          elementId: readAttr(tag.raw, "id") || void 0,
+          fixHint: "Wrap the textured text and apply `filter: drop-shadow(...)` to the wrapper, not the `hf-texture-text` element.",
+          snippet: truncateSnippet(tag.raw)
+        });
+      }
+    }
+    return findings;
+  }
+];
+
+// src/rules/fonts.ts
+import { FONT_ALIAS_KEYS, resolveAliasDisplayName } from "@hyperframes/parsers/composition";
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "math",
+  "emoji",
+  "fangsong",
+  "inherit",
+  "initial",
+  "unset",
+  "revert"
+]);
+function stripCssComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, " ");
+}
+function extractFontFaceFamilies(styles) {
+  const families = /* @__PURE__ */ new Set();
+  const fontFaceRe = /@font-face\s*\{[^}]*\}/gi;
+  const familyRe = /font-family\s*:\s*(['"]?)([^;'"]+)\1/i;
+  for (const style of styles) {
+    const content = stripCssComments(style.content);
+    let match;
+    while ((match = fontFaceRe.exec(content)) !== null) {
+      const familyMatch = match[0].match(familyRe);
+      if (familyMatch?.[2]) {
+        families.add(familyMatch[2].trim().toLowerCase());
+      }
+    }
+  }
+  return families;
+}
+function extractUsedFontFamilies(styles) {
+  const used = [];
+  const seen = /* @__PURE__ */ new Set();
+  const propRe = /font-family\s*:\s*([^;}{]+)/gi;
+  for (const style of styles) {
+    const withoutFontFace = stripCssComments(style.content).replace(/@font-face\s*\{[^}]*\}/gi, "");
+    let match;
+    while ((match = propRe.exec(withoutFontFace)) !== null) {
+      const stack = match[1];
+      for (const part of stack.split(",")) {
+        const name = part.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
+        if (name && !GENERIC_FAMILIES.has(name) && !seen.has(name)) {
+          seen.add(name);
+          used.push(name);
+        }
+      }
+    }
+  }
+  return used;
+}
+function collectAliasedFonts(used, declared) {
+  const aliased = [];
+  for (const name of used) {
+    if (declared.has(name)) continue;
+    const displayName = resolveAliasDisplayName(name);
+    if (!displayName) continue;
+    if (displayName.toLowerCase() === name) continue;
+    aliased.push(`'${name}' \u2192 ${displayName}`);
+  }
+  return aliased;
+}
+function normalizeFontFamily(name) {
+  const decoded = name.replace(/\+/g, " ").trim();
+  if (!decoded) return null;
+  try {
+    return decodeURIComponent(decoded).trim().toLowerCase() || null;
+  } catch {
+    return decoded.toLowerCase();
+  }
+}
+function extractGoogleFontFamiliesFromUrl(rawUrl) {
+  const url = rawUrl.replace(/&amp;/gi, "&");
+  let parsed;
+  try {
+    parsed = new URL(url, "https://fonts.googleapis.com");
+  } catch {
+    return [];
+  }
+  if (parsed.hostname.toLowerCase() !== "fonts.googleapis.com") return [];
+  const families = [];
+  for (const value of parsed.searchParams.getAll("family")) {
+    for (const familySpec of value.split("|")) {
+      const family = normalizeFontFamily(familySpec.split(":")[0] || "");
+      if (family) families.push(family);
+    }
+  }
+  return families;
+}
+function collectGoogleFontFamilies(source, styles) {
+  const families = /* @__PURE__ */ new Set();
+  const addUrl = (url) => {
+    for (const family of extractGoogleFontFamiliesFromUrl(url)) families.add(family);
+  };
+  const linkHrefRe = /<link\b[^>]*\bhref\s*=\s*(?:(["'])([^"']*fonts\.googleapis\.com[^"']*)\1|([^\s>]*fonts\.googleapis\.com[^\s>]*))[^>]*>/gi;
+  for (const match of source.matchAll(linkHrefRe)) {
+    const href = match[2] || match[3];
+    if (href) addUrl(href);
+  }
+  const importUrlRe = /@import\s+(?:url\(\s*)?(["']?)([^"')\s]*fonts\.googleapis\.com[^"')\s]*)\1\s*\)?/gi;
+  for (const style of styles) {
+    for (const match of style.content.matchAll(importUrlRe)) {
+      if (match[2]) addUrl(match[2]);
+    }
+  }
+  return families;
+}
+var fontRules = [
+  // google_fonts_import
+  ({ styles, source, rawSource, options }) => {
+    if (isRegistrySourceFile(options.filePath) || isRegistryInstalledFile(rawSource)) return [];
+    const findings = [];
+    const googleFontsInLink = /<link\b[^>]*fonts\.googleapis\.com[^>]*>/i.test(source);
+    const googleFontsInImport = styles.some(
+      (s) => /@import\s+url\s*\(\s*['"]?[^)]*fonts\.googleapis\.com/i.test(s.content)
+    );
+    if (googleFontsInLink || googleFontsInImport) {
+      findings.push({
+        code: "google_fonts_import",
+        severity: "warning",
+        message: "Composition loads fonts from fonts.googleapis.com. The producer resolves Google Fonts during compile/render, but raw external font requests add latency and can fail before canonicalization. Prefer mapped family names or local @font-face declarations when possible.",
+        fixHint: "For bundled fonts, remove the Google Fonts <link> or @import and keep the font-family declaration. For custom fonts, use @font-face { font-family: '...'; src: url('...woff2'); }."
+      });
+    }
+    return findings;
+  },
+  // system_font_will_alias — inform when a font will be silently substituted
+  ({ styles, options }) => {
+    const declared = extractFontFaceFamilies(styles);
+    const used = extractUsedFontFamilies(styles);
+    const aliased = collectAliasedFonts(used, declared);
+    if (aliased.length === 0) return [];
+    const severity = options.distributed ? "warning" : "info";
+    return [
+      {
+        code: "system_font_will_alias",
+        severity,
+        message: `Font ${aliased.length === 1 ? "family" : "families"} will be substituted at render time: ${aliased.join(", ")}. ` + (options.distributed ? "In distributed/Lambda rendering system-font capture is disabled \u2014 these fonts will fall back to OS defaults. Embed explicit @font-face declarations instead." : "The renderer maps these to bundled fonts for cross-platform consistency. Use the target font name directly for consistent preview and render results.")
+      }
+    ];
+  },
+  // font_family_without_font_face
+  ({ styles, source, rawSource, options }) => {
+    if (isRegistrySourceFile(options.filePath) || isRegistryInstalledFile(rawSource)) return [];
+    const findings = [];
+    const declared = extractFontFaceFamilies(styles);
+    const used = extractUsedFontFamilies(styles);
+    const googleFonts = collectGoogleFontFamilies(source, styles);
+    const undeclared = used.filter(
+      (name) => !declared.has(name) && !FONT_ALIAS_KEYS.has(name) && !googleFonts.has(name)
+    );
+    if (undeclared.length === 0) return findings;
+    findings.push({
+      code: "font_family_without_font_face",
+      severity: "error",
+      message: `Font ${undeclared.length === 1 ? "family" : "families"} used without @font-face declaration: ${undeclared.join(", ")}. These are not in the auto-resolved font list, so the renderer cannot supply them automatically. Text will fall back to a generic font, producing incorrect typography in the video.`,
+      fixHint: "Add @font-face { font-family: '...'; src: url('capture/assets/fonts/...woff2'); } for each font family, pointing to the captured .woff2 files."
+    });
+    return findings;
+  }
+];
+
+// src/rules/slideshow.ts
+import {
+  parseSlideshowManifest,
+  resolveSlideshow,
+  isSceneLikeCompositionId
+} from "@hyperframes/parsers/slideshow";
+function parseTiming(raw) {
+  const startStr = readAttr(raw, "data-start");
+  if (startStr === null) return null;
+  const start = Number(startStr);
+  if (!Number.isFinite(start)) return null;
+  const durationStr = readAttr(raw, "data-duration");
+  if (durationStr !== null) {
+    const duration = Number(durationStr);
+    if (Number.isFinite(duration)) return { start, duration };
+  }
+  const endStr = readAttr(raw, "data-end") ?? readAttr(raw, "data-hf-authored-end");
+  if (endStr !== null) {
+    const end = Number(endStr);
+    if (Number.isFinite(end) && end > start) return { start, duration: end - start };
+  }
+  return null;
+}
+function collectCompositionIdScenes(ctx, seen, out) {
+  for (const tag of ctx.tags) {
+    const compositionId = readAttr(tag.raw, "data-composition-id");
+    if (!compositionId || !isSceneLikeCompositionId(compositionId) || seen.has(compositionId))
+      continue;
+    const timing = parseTiming(tag.raw);
+    if (!timing || timing.duration <= 0) continue;
+    seen.add(compositionId);
+    out.push({ id: compositionId, ...timing });
+  }
+}
+function extractScenesFromClips(ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  const scenes = [];
+  collectCompositionIdScenes(ctx, seen, scenes);
+  return scenes;
+}
+var slideshowRules = [
+  (ctx) => {
+    const findings = [];
+    let manifest;
+    try {
+      manifest = parseSlideshowManifest(ctx.source);
+    } catch (e) {
+      findings.push({
+        code: "slideshow_invalid",
+        severity: "error",
+        message: `Slideshow island contains invalid JSON or structure: ${e instanceof Error ? e.message : String(e)}`,
+        fixHint: 'Ensure the <script type="application/hyperframes-slideshow+json"> block contains valid JSON matching the SlideshowManifest schema.'
+      });
+      return findings;
+    }
+    if (!manifest) return findings;
+    const scenes = extractScenesFromClips(ctx);
+    const { errors } = resolveSlideshow(manifest, scenes);
+    for (const error of errors) {
+      findings.push({
+        code: "slideshow_unresolved_ref",
+        severity: "error",
+        message: `Slideshow manifest error: ${error}`,
+        fixHint: "Ensure every sceneId in the slideshow island matches the data-composition-id of a scene element in the composition, or provide explicit startTime/endTime."
+      });
+    }
+    return findings;
+  }
+];
+
+// src/hyperframeLinter.ts
+var ALL_RULES = [
+  ...coreRules,
+  ...mediaRules,
+  ...gsapRules,
+  ...captionRules,
+  ...compositionRules,
+  ...adapterRules,
+  ...textureRules,
+  ...fontRules,
+  ...slideshowRules
+];
+async function lintHyperframeHtml(html, options = {}) {
+  const ctx = buildLintContext(html, options);
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of ALL_RULES) {
+    for (const finding of await Promise.resolve(rule(ctx))) {
+      const dedupeKey = [
+        finding.code,
+        finding.severity,
+        finding.selector || "",
+        finding.elementId || "",
+        finding.message
+      ].join("|");
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      findings.push(options.filePath ? { ...finding, file: options.filePath } : finding);
+    }
+  }
+  const errorCount = findings.filter((f) => f.severity === "error").length;
+  const warningCount = findings.filter((f) => f.severity === "warning").length;
+  const infoCount = findings.filter((f) => f.severity === "info").length;
+  return {
+    ok: errorCount === 0,
+    errorCount,
+    warningCount,
+    infoCount,
+    findings
+  };
+}
+function extractMediaUrls(html) {
+  const results = [];
+  const tagRe = /<(video|audio|img|source)\b[^>]*>/gi;
+  let match;
+  while ((match = tagRe.exec(html)) !== null) {
+    const tagName = (match[1] ?? "").toLowerCase();
+    const raw = match[0];
+    const src = readAttr(raw, "src");
+    if (!src) continue;
+    if (/^https?:\/\//i.test(src)) {
+      results.push({
+        url: src,
+        tagName,
+        elementId: readAttr(raw, "id") || void 0,
+        snippet: truncateSnippet(raw) ?? ""
+      });
+    }
+  }
+  return results;
+}
+async function lintMediaUrls(html, options = {}) {
+  const urls = extractMediaUrls(html);
+  if (urls.length === 0) return [];
+  const timeout = options.timeoutMs ?? 8e3;
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const unique = urls.filter((u) => {
+    if (seen.has(u.url)) return false;
+    seen.add(u.url);
+    return true;
+  });
+  const checks = unique.map(async ({ url, tagName, elementId, snippet }) => {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const resp = await fetch(url, {
+        method: "HEAD",
+        signal: controller.signal,
+        redirect: "follow"
+      });
+      clearTimeout(timer);
+      if (!resp.ok) {
+        findings.push({
+          code: "inaccessible_media_url",
+          severity: "error",
+          message: `<${tagName}${elementId ? ` id="${elementId}"` : ""}> references a URL that returned HTTP ${resp.status}: ${url.slice(0, 100)}`,
+          elementId,
+          fixHint: "This URL is not accessible. Replace with a valid, reachable media URL.",
+          snippet
+        });
+      }
+    } catch (err) {
+      const reason = err instanceof Error ? err.name : "unknown";
+      findings.push({
+        code: "inaccessible_media_url",
+        severity: "error",
+        message: `<${tagName}${elementId ? ` id="${elementId}"` : ""}> references an unreachable URL (${reason}): ${url.slice(0, 100)}`,
+        elementId,
+        fixHint: "This URL is not accessible. Replace with a valid, reachable media URL.",
+        snippet
+      });
+    }
+  });
+  await Promise.all(checks);
+  return findings;
+}
+
+// src/shouldBlockRender.ts
+function shouldBlockRender(strictErrors, strictAll, totalErrors, totalWarnings) {
+  return strictErrors && totalErrors > 0 || strictAll && (totalErrors > 0 || totalWarnings > 0);
+}
+export {
+  lintHyperframeHtml,
+  lintMediaUrls,
+  shouldBlockRender
+};
+//# sourceMappingURL=browser.js.map