@hyperframes/inspector 0.0.0-stage → 0.8.152

package/dist/live.js

@@ -0,0 +1,1288 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// src/live.ts
+import { randomUUID } from "node:crypto";
+import { readFileSync as readFileSync2, realpathSync } from "node:fs";
+
+// src/elementMap.js
+import { createHash } from "node:crypto";
+function collectElementDom() {
+  const excluded2 = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "LINK", "META"]);
+  const nodes = [];
+  const paths = /* @__PURE__ */ new Map();
+  const siblingGroups = /* @__PURE__ */ new WeakMap();
+  function siblingCount(element2, selector) {
+    const owner = element2.parentElement ?? element2;
+    let counts = siblingGroups.get(owner);
+    if (!counts) {
+      counts = /* @__PURE__ */ new Map();
+      siblingGroups.set(owner, counts);
+    }
+    if (!counts.has(selector)) {
+      const siblings = element2.parentElement ? [...element2.parentElement.children] : [element2];
+      counts.set(selector, siblings.filter((sibling) => sibling.matches(selector)).length);
+    }
+    return counts.get(selector);
+  }
+  const quote = (value) => JSON.stringify(value);
+  function path(element2) {
+    if (paths.has(element2)) return paths.get(element2);
+    const candidates = [];
+    if (element2.id) candidates.push(`#${CSS.escape(element2.id)}`);
+    const hfId = element2.getAttribute("data-hf-id");
+    if (hfId) candidates.push(`[data-hf-id=${quote(hfId)}]`);
+    const unique = candidates.find((selector2) => document.querySelectorAll(selector2).length === 1);
+    const parent = element2.parentElement;
+    const tag = element2.localName;
+    const position2 = parent ? [...parent.children].indexOf(element2) + 1 : 1;
+    const selector = unique ?? (parent ? `${path(parent)} > ${CSS.escape(tag)}:nth-child(${position2})` : CSS.escape(tag));
+    paths.set(element2, selector);
+    return selector;
+  }
+  function visit(element2, parent) {
+    if (excluded2.has(element2.tagName)) return;
+    const selector = path(element2);
+    if (document.querySelectorAll(selector).length !== 1 || document.querySelector(selector) !== element2) {
+      throw new Error(`Element map selector does not resolve uniquely: ${selector}`);
+    }
+    const classes = [...element2.classList].sort();
+    const tag = element2.localName;
+    const simple = `${CSS.escape(tag)}${classes.map((value) => `.${CSS.escape(value)}`).join("")}`;
+    const siblings = element2.parentElement ? [...element2.parentElement.children] : [element2];
+    const index = nodes.length;
+    const node = {
+      index,
+      parent,
+      selector,
+      tag,
+      id: element2.id,
+      hfId: element2.getAttribute("data-hf-id"),
+      classes,
+      composition: element2.getAttribute("data-composition-id"),
+      compositionSrc: element2.getAttribute("data-composition-src"),
+      text: [...element2.childNodes].filter((child) => child.nodeType === 3).map((child) => child.textContent).join("").replace(/\s+/g, " ").trim(),
+      media: ["img", "video", "audio", "source", "iframe"].includes(tag) ? element2.getAttribute("src") : null,
+      relative: element2.id && document.querySelectorAll(`#${CSS.escape(element2.id)}`).length === 1 ? `#${CSS.escape(element2.id)}` : siblingCount(element2, simple) === 1 ? simple : `${CSS.escape(tag)}:nth-child(${siblings.indexOf(element2) + 1})`,
+      groupSelector: simple,
+      siblingMatchCount: siblingCount(element2, simple),
+      children: []
+    };
+    nodes.push(node);
+    for (const child of element2.children) {
+      const childIndex = visit(child, index);
+      if (childIndex !== void 0) node.children.push(childIndex);
+    }
+    return index;
+  }
+  if (document.body) visit(document.body, null);
+  return {
+    generation: window.__hfLiveInspection?.generation ?? null,
+    nodes,
+    limitations: {
+      canvas: nodes.filter((node) => node.tag === "canvas").length,
+      iframes: nodes.filter((node) => node.tag === "iframe").length,
+      shadowRoots: [...document.querySelectorAll("*")].filter((node) => node.shadowRoot).length
+    }
+  };
+}
+function signature(node, nodes) {
+  return [
+    node.tag,
+    node.id,
+    node.classes,
+    node.composition,
+    node.compositionSrc,
+    node.text,
+    node.media,
+    node.children.map((index) => signature(nodes[index], nodes))
+  ];
+}
+function mediaIdentifier(source) {
+  if (source.startsWith("data:")) {
+    const mime = source.slice(5).split(/[;,]/, 1)[0] || "text/plain";
+    const hash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+    return `data:${mime}#sha256:${hash}`;
+  }
+  if (source.startsWith("blob:")) return "blob:runtime";
+  return source;
+}
+function describe(node, selector, count) {
+  const fields = [selector];
+  if (!selector.startsWith(node.tag)) fields.push(node.tag);
+  if (count > 1) fields.push(`\xD7${count}`);
+  if (node.id && selector !== `#${node.id}`) fields.push(`id=${JSON.stringify(node.id)}`);
+  if (node.classes.length && !selector.includes("."))
+    fields.push(`class=${JSON.stringify(node.classes.join(" "))}`);
+  if (node.text) fields.push(JSON.stringify(node.text));
+  if (node.media) fields.push(`src=${JSON.stringify(mediaIdentifier(node.media))}`);
+  if (node.composition) fields.push(`composition=${JSON.stringify(node.composition)}`);
+  if (node.compositionSrc) fields.push(`file=${JSON.stringify(node.compositionSrc)}`);
+  return fields.join(" ");
+}
+function formatElementMap(snapshot, { file = "index.html" } = {}) {
+  const { nodes } = snapshot;
+  const lines = [`File: ${JSON.stringify(file)}`];
+  const entries = [];
+  function siblings(indices, depth) {
+    const groups = [];
+    for (const index of indices) {
+      const node = nodes[index];
+      const key = JSON.stringify(signature(node, nodes));
+      const previous = groups.at(-1);
+      if (!node.id && previous?.key === key) previous.indices.push(index);
+      else groups.push({ key, indices: [index] });
+    }
+    for (const group of groups) {
+      const members = group.indices.map((index) => nodes[index]);
+      const node = members[0];
+      const exactGroup = members.length > 1 && node.siblingMatchCount === members.length;
+      if (members.length > 1 && !exactGroup) {
+        for (const member of members) emit([member], depth);
+      } else emit(members, depth);
+    }
+  }
+  function emit(members, depth, repeatedParents = false) {
+    const node = members[0];
+    const selector = members.length > 1 && !repeatedParents ? node.groupSelector : node.relative;
+    lines.push(`${"  ".repeat(depth)}${describe(node, selector, members.length)}`);
+    entries.push({
+      line: lines.length,
+      selectors: members.map((member) => member.selector),
+      nodeIndices: members.map((member) => member.index)
+    });
+    if (members.length === 1) {
+      siblings(node.children, depth + 1);
+      return;
+    }
+    for (let position2 = 0; position2 < node.children.length; position2++) {
+      emit(
+        members.map((member) => nodes[member.children[position2]]),
+        depth + 1,
+        true
+      );
+    }
+  }
+  siblings(
+    nodes.filter((node) => node.parent === null).map((node) => node.index),
+    0
+  );
+  const { canvas, iframes, shadowRoots } = snapshot.limitations;
+  if (canvas || iframes || shadowRoots)
+    lines.push(
+      `Unmapped contents: canvas=${canvas}, iframe=${iframes}, shadow-root=${shadowRoots}.`
+    );
+  const covered = entries.flatMap((entry) => entry.nodeIndices);
+  if (covered.length !== nodes.length || new Set(covered).size !== nodes.length)
+    throw new Error("Element map coverage mismatch");
+  return {
+    text: `${lines.join("\n")}
+`,
+    entries,
+    elementCount: nodes.length,
+    coveredCount: covered.length
+  };
+}
+
+// src/sources.ts
+import { closeSync, fstatSync, openSync, readFileSync, readdirSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { parse as parse2 } from "acorn";
+import postcss from "postcss";
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
+
+// src/sourceDependencies.ts
+import { parse } from "acorn";
+import { analyze } from "eslint-scope";
+function sourceDependencies(text) {
+  try {
+    const ast = parse(text, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowReturnOutsideFunction: true,
+      ranges: true
+    });
+    const scopes = analyze(ast, {
+      ecmaVersion: 2022,
+      sourceType: "module",
+      optimistic: false
+    });
+    const references = scopes.scopes.flatMap(
+      (scope) => scope.references.flatMap((reference) => {
+        const location = reference.identifier.range;
+        if (!reference.isRead() || !location) return [];
+        const definitions = (reference.resolved?.defs ?? []).flatMap((definition) => {
+          const node = definition.type === "Variable" ? definition.parent : definition.type === "FunctionName" ? definition.node : null;
+          return node?.range ? [{ start: node.range[0], end: node.range[1] }] : [];
+        });
+        return definitions.length ? [{ start: location[0], end: location[1], definitions }] : [];
+      })
+    );
+    return (range) => {
+      const pending = [range];
+      const found = /* @__PURE__ */ new Map();
+      for (let index = 0; index < pending.length; index++) {
+        const current = pending[index];
+        for (const reference of references) {
+          if (reference.start < current.start || reference.end > current.end) continue;
+          for (const { start, end } of reference.definitions) {
+            if (start >= range.start && end <= range.end) continue;
+            const key = `${start}:${end}`;
+            if (found.has(key)) continue;
+            const dependency = { start, end };
+            found.set(key, dependency);
+            pending.push(dependency);
+          }
+        }
+      }
+      return [...found.values()].sort((a, b) => a.start - b.start);
+    };
+  } catch {
+    return () => [];
+  }
+}
+
+// src/sources.ts
+var starts = (text) => [0, ...[...text.matchAll(/\n/g)].map((m) => m.index + 1)];
+function position(lines, offset2) {
+  let lo = 0, hi = lines.length - 1;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (lines[mid] <= offset2) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, column: offset2 - lines[lo] };
+}
+function occurrences(text, needle) {
+  const hits = [];
+  if (!needle) return hits;
+  let at2 = text.indexOf(needle);
+  while (at2 >= 0) {
+    hits.push(at2);
+    at2 = text.indexOf(needle, at2 + needle.length);
+  }
+  return hits;
+}
+var excluded = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hyperframes",
+  ".agents",
+  ".claude",
+  "evidence",
+  "outputs",
+  "renders",
+  "snapshots"
+]);
+function sourceFiles(project) {
+  const files = [];
+  function visit(dir) {
+    for (const item of readdirSync(dir, { withFileTypes: true })) {
+      if (excluded.has(item.name) || item.isSymbolicLink()) continue;
+      const path = join(dir, item.name);
+      if (item.isDirectory()) visit(path);
+      else if ([".html", ".js", ".mjs", ".css", ".json"].includes(extname(path))) files.push(path);
+    }
+  }
+  visit(project);
+  return files.sort();
+}
+function fingerprint(project) {
+  const hash = createHash2("sha256");
+  for (const path of sourceFiles(project)) {
+    hash.update(relative(project, path));
+    hash.update(readFileSync(path));
+  }
+  return hash.digest("hex");
+}
+function statements(text) {
+  const result = [];
+  function visit(value) {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    if ("type" in value && "start" in value && "end" in value && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number") {
+      if ([
+        "ExpressionStatement",
+        "VariableDeclaration",
+        "ReturnStatement",
+        "ThrowStatement",
+        "FunctionDeclaration"
+      ].includes(value.type))
+        result.push({ start: value.start, end: value.end, type: value.type });
+    }
+    for (const entry of Object.values(value)) if (typeof entry === "object") visit(entry);
+  }
+  try {
+    const ast = parse2(text, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowReturnOutsideFunction: true
+    });
+    visit(ast);
+  } catch {
+  }
+  return result;
+}
+function rawTextElements(text, tag) {
+  const lower = text.toLowerCase();
+  const opening = `<${tag}`;
+  const closing = `</${tag}`;
+  const elements = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = lower.indexOf(opening, cursor);
+    if (start < 0) break;
+    const boundary = lower[start + opening.length];
+    if (boundary && boundary !== ">" && !/\s/.test(boundary)) {
+      cursor = start + opening.length;
+      continue;
+    }
+    const contentStart = lower.indexOf(">", start + opening.length);
+    if (contentStart < 0) break;
+    let close = lower.indexOf(closing, contentStart + 1);
+    let closeEnd = -1;
+    while (close >= 0) {
+      let at2 = close + closing.length;
+      while (at2 < lower.length && /\s/.test(lower[at2])) at2++;
+      if (lower[at2] === ">") {
+        closeEnd = at2 + 1;
+        break;
+      }
+      close = lower.indexOf(closing, at2);
+    }
+    if (close < 0) break;
+    elements.push({
+      attributes: text.slice(start + opening.length, contentStart),
+      content: text.slice(contentStart + 1, close),
+      contentStart: contentStart + 1
+    });
+    cursor = closeEnd;
+  }
+  return elements;
+}
+var Sources = class {
+  constructor(project) {
+    this.project = project;
+    for (const path of sourceFiles(project)) {
+      const file = relative(project, path);
+      if (/(?:^|\/)(?:vendor|lib)\//.test(file)) continue;
+      const fd = openSync(path, "r");
+      let text;
+      try {
+        if (fstatSync(fd).size > 2e6) continue;
+        text = readFileSync(fd, "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      this.files.set(file, { text, lines: starts(text) });
+      if (/\.m?js$/.test(file)) this.addChunk(file, text, 0);
+      if (/\.css$/.test(file)) this.addCss(file, text, 0);
+      if (/\.html$/.test(file)) {
+        for (const script of rawTextElements(text, "script"))
+          if (!/\bsrc\s*=/.test(script.attributes))
+            this.addChunk(file, script.content, script.contentStart);
+        for (const style of rawTextElements(text, "style"))
+          this.addCss(file, style.content, style.contentStart);
+        for (const m of text.matchAll(/<([a-z][\w-]*)\b[^>]*>/gi)) {
+          const attr = (name) => new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`, "i").exec(m[0])?.[1];
+          this.htmlTags.push({
+            file,
+            start: m.index,
+            end: m.index + m[0].length,
+            tag: m[1].toLowerCase(),
+            id: attr("id"),
+            hfId: attr("data-hf-id"),
+            classes: (attr("class") ?? "").split(/\s+/).filter(Boolean)
+          });
+        }
+      }
+    }
+  }
+  files = /* @__PURE__ */ new Map();
+  chunks = [];
+  cssRules = [];
+  htmlTags = [];
+  addChunk(file, source, offset2) {
+    const text = source.trim();
+    const lead = source.length - source.trimStart().length;
+    if (text) {
+      let ranges;
+      let dependencies;
+      this.chunks.push({
+        file,
+        text,
+        offset: offset2 + lead,
+        get statements() {
+          return ranges ??= statements(text);
+        },
+        dependencies(range) {
+          return (dependencies ??= sourceDependencies(text))(range);
+        }
+      });
+    }
+  }
+  addCss(file, text, offset2) {
+    try {
+      postcss.parse(text).walkRules((rule) => {
+        const start = rule.source?.start?.offset;
+        const end = rule.source?.end?.offset;
+        if (start != null && end != null)
+          this.cssRules.push({
+            id: `css:${this.cssRules.length}`,
+            selector: rule.selector,
+            file,
+            start: offset2 + start,
+            end: offset2 + end + 1
+          });
+      });
+    } catch {
+    }
+  }
+  slice(file, start, end, kind, target2) {
+    const source = this.files.get(file);
+    if (!source) return null;
+    const first = position(source.lines, start).line;
+    const last = position(source.lines, Math.max(start, end - 1)).line;
+    const code = source.text.slice(
+      source.lines[first - 1],
+      source.lines[last] ?? source.text.length
+    );
+    return {
+      id: `${file}:${first}-${last}`,
+      file,
+      startLine: first,
+      endLine: last,
+      kind: [kind],
+      targets: [target2],
+      code,
+      uniqueInFile: occurrences(source.text, code).length === 1
+    };
+  }
+  markup(element2, target2) {
+    const tags = this.htmlTags.filter(
+      (tag) => tag.tag === element2.tag && (element2.hfId ? tag.hfId === element2.hfId : element2.id ? tag.id === element2.id : element2.classes.length > 0 && element2.classes.every((c) => tag.classes.includes(c)))
+    );
+    return tags.length === 1 ? this.slice(tags[0].file, tags[0].start, tags[0].end, "html opening tag", target2) : null;
+  }
+  mapper(html, provenance) {
+    const htmlLines = starts(html);
+    const maps = provenance.flatMap(
+      (p) => occurrences(html, p.output).map((at2) => ({
+        at: at2,
+        p,
+        lines: starts(p.output),
+        inputLines: starts(p.input),
+        map: new TraceMap(p.sourceMap)
+      }))
+    );
+    const ranges = /* @__PURE__ */ new Map();
+    for (const text of [html, ...provenance.map((p) => p.input)])
+      ranges.set(
+        text,
+        this.chunks.flatMap((chunk) => occurrences(text, chunk.text).map((at2) => ({ chunk, at: at2 })))
+      );
+    const locate = (text, offset2) => {
+      const found = (ranges.get(text) ?? []).filter(({ chunk, at: at2 }) => offset2 >= at2 && offset2 < at2 + chunk.text.length).map(({ chunk, at: at2 }) => ({ chunk, local: offset2 - at2 }));
+      const unique = new Map(
+        found.map((hit) => [`${hit.chunk.file}:${hit.chunk.offset + hit.local}`, hit])
+      );
+      return unique.size === 1 ? [...unique.values()][0] : null;
+    };
+    const cache = /* @__PURE__ */ new Map();
+    return (stack, target2) => {
+      const cached = cache.get(stack);
+      if (cached) return cached.map((snippet2) => ({ ...snippet2, targets: [target2] }));
+      const result = [];
+      for (const frame of stack.split("\n")) {
+        const script = /(hf-inspect-[a-f0-9]+\.js):(\d+):(\d+)\)?$/.exec(frame);
+        const m = /https?:\/\/[^/]+\/(?:index\.html)?:(\d+):(\d+)\)?$/.exec(frame);
+        if (!m && !script) continue;
+        const offset2 = m ? htmlLines[Number(m[1]) - 1] + Number(m[2]) - 1 : -1;
+        let hit = m ? locate(html, offset2) : null;
+        if (!hit)
+          for (const map of maps) {
+            if (script ? map.p.sourceURL !== script[1] : offset2 < map.at || offset2 >= map.at + map.p.output.length)
+              continue;
+            const generated = script ? { line: Number(script[2]), column: Number(script[3]) - 1 } : position(map.lines, offset2 - map.at);
+            const original = originalPositionFor(map.map, generated);
+            if (original.line != null && original.column != null)
+              hit = locate(map.p.input, map.inputLines[original.line - 1] + original.column);
+          }
+        if (!hit) continue;
+        const enclosing = hit.chunk.statements.filter((s) => hit.local >= s.start && hit.local < s.end).sort((a, b) => a.end - a.start - (b.end - b.start))[0];
+        if (!enclosing) continue;
+        const helper = hit.chunk.statements.filter(
+          (s) => s.type === "FunctionDeclaration" && hit.local >= s.start && hit.local < s.end && s.end - s.start <= 2e3
+        ).sort((a, b) => a.end - a.start - (b.end - b.start))[0];
+        const range = helper ?? enclosing;
+        const snippet2 = this.slice(
+          hit.chunk.file,
+          hit.chunk.offset + range.start,
+          hit.chunk.offset + range.end,
+          result.length ? "animation caller" : "animation creation",
+          target2
+        );
+        if (snippet2) result.push(snippet2);
+        for (const dependency of hit.chunk.dependencies(range)) {
+          const definition = this.slice(
+            hit.chunk.file,
+            hit.chunk.offset + dependency.start,
+            hit.chunk.offset + dependency.end,
+            "animation source dependency",
+            target2
+          );
+          if (definition) result.push(definition);
+        }
+      }
+      cache.set(stack, result);
+      return result;
+    };
+  }
+};
+function markupSnippet(sources, element2, target2) {
+  return sources.markup(element2, target2);
+}
+function mergeSnippets(snippets, sources) {
+  const sorted = snippets.sort((a, b) => a.file.localeCompare(b.file) || a.startLine - b.startLine);
+  const output = [];
+  for (const snippet2 of sorted) {
+    const last = output.at(-1);
+    if (last && last.file === snippet2.file && snippet2.startLine <= last.endLine + 1) {
+      last.endLine = Math.max(last.endLine, snippet2.endLine);
+      last.id = `${last.file}:${last.startLine}-${last.endLine}`;
+      const source = sources.files.get(last.file);
+      last.code = source.text.slice(
+        source.lines[last.startLine - 1],
+        source.lines[last.endLine] ?? source.text.length
+      );
+      last.targets = [.../* @__PURE__ */ new Set([...last.targets, ...snippet2.targets])];
+      last.kind = [.../* @__PURE__ */ new Set([...last.kind, ...snippet2.kind])];
+      last.uniqueInFile = occurrences(source.text, last.code).length === 1;
+    } else output.push({ ...snippet2 });
+  }
+  return output;
+}
+
+// src/mapInspection.ts
+var coverage = [
+  "GSAP associations observed since page initialization; callback-created animations may require an explicit time query.",
+  "Animation source dependencies include lexically resolved declarations in the same script; later mutations, imports, and cross-script bindings are not traced.",
+  "CSS selector matches are candidates, not a full cascade or dependency graph. HTML is the authored opening tag when uniquely located.",
+  "Direct constructors, other animation systems, iframe contents, removed animations and unexecuted paths may be absent; missing origins are reported."
+];
+function mapInspection(raw, request, context) {
+  const { sources, map, catalog, generation: generation2, sourceVersion, reused, start, visualState } = context;
+  const maxBytes = request.maxBytes ?? 12e3;
+  const collected = [];
+  const results = raw.results.map((result, index) => {
+    let unmappedAnimations = 0;
+    for (const animation of result.animations) {
+      const mapped = animation.stack ? map(animation.stack, index) : [];
+      if (!mapped.length) unmappedAnimations++;
+      collected.push(...mapped);
+      for (const stack of animation.attachmentStacks)
+        collected.push(
+          ...map(stack, index).map((snippet2) => ({ ...snippet2, kind: ["timeline attachment"] }))
+        );
+    }
+    for (const el of result.elements) {
+      const snippet2 = markupSnippet(sources, el, index);
+      if (snippet2) collected.push(snippet2);
+    }
+    for (const id of result.css) {
+      const rule = sources.cssRules.find((rule2) => rule2.id === id);
+      if (rule) {
+        const snippet2 = sources.slice(
+          rule.file,
+          rule.start,
+          rule.end,
+          "matched CSS candidate",
+          index
+        );
+        if (snippet2) collected.push(snippet2);
+      }
+    }
+    return {
+      target: index,
+      status: result.status,
+      candidates: result.candidates.slice(0, 5),
+      candidatesOmitted: Math.max(0, result.candidates.length - 5),
+      animations: result.animations.length,
+      coTargets: [
+        ...new Map(
+          result.animations.flatMap((animation) => animation.targets).filter((element2) => !result.elements.some((own) => own.ref === element2.ref)).map((element2) => [element2.ref, element2])
+        ).values()
+      ].slice(0, 10),
+      unmappedAnimations,
+      scopeTruncated: result.truncated
+    };
+  });
+  const merged = mergeSnippets(collected, sources);
+  for (const snippet2 of merged) catalog.set(snippet2.id, snippet2);
+  let selected = merged;
+  if (request.snippets)
+    selected = request.snippets.map((id) => {
+      const snippet2 = catalog.get(id);
+      if (!snippet2) throw new Error(`unknown_snippet: ${id}`);
+      return snippet2;
+    });
+  const response = {
+    generation: generation2,
+    visualState,
+    sourceVersion,
+    reused,
+    results,
+    snippets: [],
+    omitted: [],
+    omittedCount: 0,
+    nextOffset: null,
+    coverage,
+    recordLimitReached: raw.recordLimitReached,
+    hooked: raw.hooked,
+    debugAvailable: true,
+    elapsedMs: Math.round(performance.now() - start)
+  };
+  const offset2 = request.offset ?? 0;
+  if (!Number.isInteger(offset2) || offset2 < 0)
+    throw new Error("offset must be a non-negative integer");
+  for (let i = offset2; i < selected.length; i++) {
+    const snippet2 = selected[i];
+    response.snippets.push(snippet2);
+    if (Buffer.byteLength(JSON.stringify(response)) > maxBytes - 700) {
+      response.snippets.pop();
+      response.omittedCount = selected.length - i;
+      response.omitted = selected.slice(i, i + 8).map((item) => ({ id: item.id, bytes: Buffer.byteLength(item.code) }));
+      response.nextOffset = i;
+      break;
+    }
+  }
+  while (Buffer.byteLength(JSON.stringify(response)) > maxBytes && response.results.some((r) => r.candidates.length)) {
+    const r = response.results.find((r2) => r2.candidates.length);
+    r.candidates.pop();
+    r.candidatesOmitted++;
+  }
+  if (Buffer.byteLength(JSON.stringify(response)) > maxBytes)
+    throw new Error("metadata_exceeds_budget: use fewer targets or increase maxBytes");
+  if (request.debug) return { ...response, debug: raw };
+  return response;
+}
+
+// src/pageQueries.ts
+function queryPage(query) {
+  const inspected = window;
+  const inspection = inspected.__hfInspection;
+  if (!inspection) throw new Error("inspector_unavailable");
+  return {
+    generation: inspected.__hfLiveInspection?.generation ?? null,
+    ...inspection.query(query)
+  };
+}
+function timelinePage(request) {
+  const inspected = window;
+  const inspection = inspected.__hfInspection;
+  if (!inspection) throw new Error("inspector_unavailable");
+  const result = inspection.timeline(request);
+  const following = [];
+  const generation2 = inspected.__hfLiveInspection?.generation ?? null;
+  if (request.boundary === void 0) return { ...result, following, generation: generation2 };
+  const boundary = request.boundary;
+  const schedule = inspection.timeline({ ...request, boundary: void 0 });
+  for (const crossing of result.events) {
+    if (crossing.kind !== "animation" || crossing.relation !== "crosses") continue;
+    for (const target2 of crossing.targets) {
+      const next = schedule.events.filter(
+        (event) => event.kind === "animation" && event.start > boundary && event.targets.some((t) => t.ref === target2.ref) && event.properties.some((p) => crossing.properties.includes(p))
+      ).sort((a, b) => a.start - b.start)[0];
+      if (next && !following.includes(next)) following.push(next);
+    }
+  }
+  return { ...result, following, generation: generation2 };
+}
+function liveGenerationPage() {
+  return window.__hfLiveInspection?.generation ?? null;
+}
+
+// src/timelineReport.ts
+var GROUPS_PER_PAGE = 60;
+var FOLLOWING_SHOWN = 16;
+var MEMBERS_SHOWN = 8;
+var RELATIONS_SHOWN = 8;
+var COVERAGE_NOTE = "Observed DOM-target GSAP and explicit HF items only; callbacks/object tweens/unexecuted code are not inspected. Scheduled intervals do not establish visibility; no visual verification. at/range are half-open; boundary includes exact endpoints. No seek performed.";
+var BOUNDARY_NOTE = "only actions crossing, starting, ending or instantaneous here. Later stagger members are excluded, not absent. Group spans do not imply simultaneous starts. Target labels T1, T2, ... identify the same element within this response, not DOM order.";
+function formatTimeline(raw, request, view) {
+  const offset2 = request.offset ?? 0;
+  const allGroups = groupEvents(raw.events);
+  const groups = allGroups.slice(offset2, offset2 + GROUPS_PER_PAGE);
+  const label = labeler();
+  const events = groups.flat().map((event, index) => ({
+    ...event,
+    stack: void 0,
+    sources: (event.stack ? view.map(event.stack, index) : []).map((s) => ({
+      file: s.file,
+      line: s.startLine
+    }))
+  }));
+  const nextOffset = offset2 + groups.length < allGroups.length ? offset2 + groups.length : null;
+  const lines = [
+    `Timeline \xB7 global seconds \xB7 ${raw.status}`,
+    `generation: ${view.generation}`,
+    ...raw.status !== "found" ? raw.candidates.map((c) => `${c.ref} #${c.id} ${c.tag}`) : [],
+    ...request.boundary !== void 0 ? [`Boundary ${request.boundary}s: ${BOUNDARY_NOTE}`] : [],
+    ...describeGroups(groups, request, view.map, label),
+    ...describeFollowing(raw, view.map, label),
+    ...describeRelations(events),
+    ...nextOffset !== null ? [`More groups: repeat with offset=${nextOffset} and generation.`] : [],
+    ...raw.warnings.map((w) => `Coverage: ${w}`),
+    ...events.some((e) => e.values) ? [
+      "Authored values describe the original tween, not sampled state or reversed repeat direction; ? means unknown. Relative values and expressions are not resolved."
+    ] : [],
+    COVERAGE_NOTE
+  ];
+  return {
+    text: lines.join("\n"),
+    generation: view.generation,
+    reused: view.reused,
+    status: raw.status,
+    candidates: raw.candidates,
+    events,
+    eventCount: raw.events.length,
+    groupCount: allGroups.length,
+    nextOffset,
+    warnings: raw.warnings
+  };
+}
+function groupEvents(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const identity = event.targets.map((t) => t.id || t.hfId || `${t.composition}:${t.tag}:${t.classes.join(".")}`).sort();
+    const key = event.kind === "animation" && event.stack ? JSON.stringify([
+      event.stack,
+      event.component?.ref,
+      event.relation,
+      [...event.properties].sort(),
+      identity
+    ]) : `unique:${groups.size}`;
+    groups.set(key, [...groups.get(key) ?? [], event]);
+  }
+  return [...groups.values()];
+}
+function labeler() {
+  const labels = /* @__PURE__ */ new Map();
+  return (ref) => {
+    if (!labels.has(ref)) labels.set(ref, `T${labels.size + 1}`);
+    return labels.get(ref);
+  };
+}
+var at = (seconds) => seconds.toFixed(4);
+var located = (sources) => sources.map((s) => `${s.file}:${s.startLine}`).join(", ");
+function describeValue(value) {
+  if (value.kind === "unknown") return "?";
+  return `${value.value}${value.kind === "literal" ? "" : ` (${value.kind})`}`;
+}
+function describeValues(values) {
+  return `    authored: ${values.properties.map((p) => `${p.property}: ${describeValue(p.from)} \u2192 ${describeValue(p.to)}`).join("; ")}; ease: ${describeValue(values.ease)}`;
+}
+function describeGroups(groups, request, map, label) {
+  const lines = [];
+  let owner = "";
+  for (const members of groups) {
+    const first = members[0];
+    const event = {
+      ...first,
+      start: Math.min(...members.map((e) => e.start)),
+      end: Math.max(...members.map((e) => e.end)),
+      targets: [...new Map(members.flatMap((e) => e.targets).map((t) => [t.ref, t])).values()]
+    };
+    const component = event.component;
+    const heading = component?.id ? `#${component.id}` : component?.composition ?? "unassigned";
+    if (owner !== heading) {
+      lines.push(`
+${heading}${component ? ` [${component.ref}]` : ""}`);
+      owner = heading;
+    }
+    const targets = targetSummary(event.targets);
+    const more = targets.length > 4 ? ` (+${targets.length - 4} groups)` : "";
+    lines.push(
+      `  ${at(event.start)}\u2013${at(event.end)}s ${event.relation} ${event.kind} ${targets.slice(0, 4).join(", ")}${more} ${event.properties.join(",")}`
+    );
+    const variants = new Map(
+      members.filter((m) => m.values).map((m) => [JSON.stringify(m.values), m.values])
+    );
+    if (variants.size === 1) lines.push(describeValues(variants.values().next().value));
+    else if (variants.size > 1)
+      lines.push("    authored values vary across events; inspect the per-event JSON values.");
+    if (event.kind === "animation") {
+      const sources = event.stack ? map(event.stack, 0) : [];
+      lines.push(`    ${sources.length ? located(sources) : "source unknown"}`);
+    }
+    if (request.boundary !== void 0 && event.kind === "animation")
+      lines.push(...describeMembers(event.targets, members, label));
+    if (members.length > 1) lines.push(describeSpacing(members));
+  }
+  return lines;
+}
+function targetSummary(targets) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const target2 of targets) {
+    const name = target2.id ? `#${target2.id}` : target2.hfId ?? (target2.classes.length ? `.${target2.classes.join(".")}` : target2.tag);
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return [...counts].map(([name, count]) => count > 1 ? `${name} \xD7${count}` : name);
+}
+function describeMembers(targets, members, label) {
+  const lines = [`    targets: ${targets.map((t) => label(t.ref)).join(", ")}`];
+  if (members.length < 2) return lines;
+  for (const member of members.slice(0, MEMBERS_SHOWN))
+    lines.push(
+      `    ${member.targets.map((t) => label(t.ref)).join(", ")}: ${at(member.start)}\u2013${at(member.end)}s ${member.relation}`
+    );
+  if (members.length > MEMBERS_SHOWN)
+    lines.push(
+      `    ${members.length - MEMBERS_SHOWN} more member intervals omitted; do not infer their exact timing from this span.`
+    );
+  return lines;
+}
+function describeSpacing(members) {
+  const durations = members.map((e) => e.end - e.start);
+  const starts2 = [...new Set(members.map((e) => e.start))].sort((a, b) => a - b);
+  const step = starts2.length > 1 ? starts2[1] - starts2[0] : null;
+  const regular = step !== null && starts2.every((t, i) => i === 0 || Math.abs(t - starts2[i - 1] - step) < 1e-4);
+  const uniform = durations.every((d) => Math.abs(d - durations[0]) < 1e-7);
+  return `    ${members.length} events; span is not continuous activity; ${uniform ? `each ${at(durations[0])}s` : "varying durations"}${regular ? `; approx. start spacing ${at(step)}s` : "; irregular or simultaneous starts"}`;
+}
+function describeFollowing(raw, map, label) {
+  if (!raw.following.length) return [];
+  const lines = ["\nFollowing actions (context only; these do NOT start at the queried boundary):"];
+  for (const event of raw.following.slice(0, FOLLOWING_SHOWN)) {
+    const sources = event.stack ? map(event.stack, 0) : [];
+    lines.push(
+      `  ${event.targets.map((t) => label(t.ref)).join(", ")}: ${at(event.start)}\u2013${at(event.end)}s ${event.properties.join(",")} ${located(sources)}`
+    );
+    for (const prior of raw.events) {
+      if (prior.kind !== "animation" || prior.relation !== "crosses") continue;
+      if (!prior.targets.some((t) => event.targets.some((n) => n.ref === t.ref))) continue;
+      if (!prior.properties.some((p) => event.properties.includes(p))) continue;
+      const overlap = Math.min(prior.end, event.end) - Math.max(prior.start, event.start);
+      const handoff = overlap > 1e-7 ? `overlap ${at(overlap)}s` : Math.abs(prior.end - event.start) < 1e-7 ? "endpoint handoff: NO duration overlap on this target" : "NO duration overlap on this target";
+      lines.push(`    previous action ends ${at(prior.end)}s; ${handoff}.`);
+    }
+  }
+  if (raw.following.length > FOLLOWING_SHOWN)
+    lines.push(`  ${raw.following.length - FOLLOWING_SHOWN} additional following actions omitted.`);
+  return lines;
+}
+function describeRelations(events) {
+  const lines = [];
+  for (let a = 0; a < events.length; a++)
+    for (let b = a + 1; b < events.length; b++) {
+      const left = events[a];
+      const right = events[b];
+      if (left.kind !== "animation" || right.kind !== "animation") continue;
+      if (left.end < right.start || right.end < left.start) continue;
+      const shared = left.targets.some((t) => right.targets.some((r) => r.ref === t.ref));
+      const properties = left.properties.filter((p) => right.properties.includes(p));
+      if (!shared || !properties.length || lines.length >= RELATIONS_SHOWN) continue;
+      const kind = left.start === left.end || right.start === right.end ? "instantaneous action touches or occurs inside the other interval" : Math.min(left.end, right.end) > Math.max(left.start, right.start) ? "intervals overlap" : "touch at an endpoint only, no positive-duration overlap";
+      lines.push(
+        `Relation: ${at(left.start)}\u2013${at(left.end)} and ${at(right.start)}\u2013${at(right.end)} share targets and ${properties.join(",")}; ${kind}; not necessarily an error.`
+      );
+    }
+  return lines;
+}
+
+// src/engine.ts
+function assertPageGeneration(view, actual) {
+  if (view.pageGeneration !== void 0 && actual !== view.pageGeneration)
+    throw new Error("stale_preview: the preview reloaded; query again");
+}
+async function inspectComponents(runner, view, request, context) {
+  const { sources, map } = view.sourceContext();
+  const raw = await runner.run(queryPage, {
+    targets: request.targets,
+    descendants: request.descendants ?? true,
+    cssRules: sources.cssRules.map(({ id, selector }) => ({ id, selector }))
+  });
+  assertPageGeneration(view, raw.generation);
+  await view.assertCurrent();
+  return mapInspection(raw, request, {
+    ...context,
+    sources,
+    map,
+    generation: view.generation,
+    sourceVersion: view.sourceVersion
+  });
+}
+async function inspectTimeline(runner, view, request, reused) {
+  const raw = await runner.run(timelinePage, request);
+  assertPageGeneration(view, raw.generation);
+  await view.assertCurrent();
+  return formatTimeline(raw, request, {
+    generation: view.generation,
+    map: view.sourceContext().map,
+    reused
+  });
+}
+async function inspectElementMap(runner, view, file = "index.html") {
+  const snapshot = await runner.run(collectElementDom, void 0);
+  assertPageGeneration(view, snapshot.generation);
+  const map = formatElementMap(snapshot, { file });
+  await view.assertCurrent();
+  return { ...map, sourceVersion: view.sourceVersion, generation: view.generation };
+}
+
+// src/requests.ts
+function validateInspectRequest(request) {
+  if (!Array.isArray(request.targets) || request.targets.length > 20 || !request.targets.length && !request.snippets?.length)
+    throw new Error("Provide 1\u201320 targets, or snippet IDs from a previous query.");
+  for (const target2 of request.targets) {
+    if (!target2 || typeof target2 !== "object") throw new Error("Invalid target");
+    const keys = ["selector", "hfId", "ref"].filter((key) => key in target2);
+    if (keys.length !== 1 || Object.values(target2).some(
+      (value) => typeof value !== "string" || !value || value.length > 1e3
+    ))
+      throw new Error("Each target needs exactly one selector, hfId or ref; within is optional.");
+  }
+  const maxBytes = request.maxBytes ?? 12e3;
+  if (!Number.isInteger(maxBytes) || maxBytes < 2048 || maxBytes > 256e3)
+    throw new Error("maxBytes must be 2048\u2013256000");
+  if (request.time != null && (!Number.isFinite(request.time) || request.time < 0))
+    throw new Error("time must be a finite non-negative number");
+  if (request.snippets?.length && !request.generation)
+    throw new Error("snippet continuation requires generation");
+}
+var TIMELINE_KEYS = ["component", "at", "range", "boundary", "generation", "offset"];
+var COMPONENT_KEYS = ["selector", "hfId", "ref", "within"];
+function validateTimelineRequest(request) {
+  if (!request || typeof request !== "object" || Array.isArray(request))
+    throw new Error("Expected query object");
+  if (Object.keys(request).some((key) => !TIMELINE_KEYS.includes(key)))
+    throw new Error("Unknown timeline query parameter");
+  const times = [request.at, request.range, request.boundary].filter((v) => v !== void 0);
+  if (times.length > 1) throw new Error("at, range and boundary are mutually exclusive");
+  const numbers = [
+    request.at,
+    request.boundary,
+    ...Array.isArray(request.range) ? request.range : []
+  ].filter((v) => v !== void 0);
+  if (numbers.some((v) => typeof v !== "number" || !Number.isFinite(v) || v < 0))
+    throw new Error("Times must be finite non-negative seconds");
+  if (request.range !== void 0 && (!Array.isArray(request.range) || request.range.length !== 2 || request.range[0] >= request.range[1]))
+    throw new Error("range must be [start,end] with start < end");
+  const component = request.component;
+  if (component && (typeof component !== "object" || Object.keys(component).some((key) => !COMPONENT_KEYS.includes(key)) || ["selector", "hfId", "ref"].filter((key) => key in component).length !== 1 || Object.values(component).some((v) => typeof v !== "string" || !v)))
+    throw new Error("component requires one selector, hfId or ref");
+  const offset2 = request.offset ?? 0;
+  if (!Number.isInteger(offset2) || offset2 < 0)
+    throw new Error("offset must be non-negative integer");
+  if (offset2 && !request.generation) throw new Error("pagination requires generation");
+}
+function assertGeneration(requested, current) {
+  if (requested && requested !== current)
+    throw new Error("stale_generation: query targets again after source changes or idle disposal");
+}
+
+// src/outputSchemas.ts
+var string = { type: "string" };
+var number = { type: "number" };
+var boolean = { type: "boolean" };
+var array = (items) => ({ type: "array", items });
+var nullable = (schema) => ({ oneOf: [schema, { type: "null" }] });
+var object = (properties, optional = []) => ({
+  type: "object",
+  properties,
+  required: Object.keys(properties).filter((key) => !optional.includes(key)),
+  additionalProperties: false
+});
+var element = object({
+  ref: string,
+  tag: string,
+  id: string,
+  hfId: nullable(string),
+  classes: array(string),
+  composition: nullable(string)
+});
+var snippet = object({
+  id: string,
+  file: string,
+  startLine: number,
+  endLine: number,
+  kind: array(string),
+  targets: array(number),
+  code: string,
+  uniqueInFile: boolean
+});
+var componentOutputSchema = object(
+  {
+    generation: string,
+    sourceVersion: string,
+    reused: boolean,
+    visualState: object({ time: number, duration: number }, ["time", "duration"]),
+    results: array(
+      object({
+        target: number,
+        status: {
+          type: "string",
+          enum: ["found", "missing", "ambiguous", "stale-ref", "invalid-selector"]
+        },
+        candidates: array(element),
+        candidatesOmitted: number,
+        animations: number,
+        coTargets: array(element),
+        unmappedAnimations: number,
+        scopeTruncated: boolean
+      })
+    ),
+    snippets: array(snippet),
+    omitted: array(object({ id: string, bytes: number })),
+    omittedCount: number,
+    nextOffset: nullable(number),
+    coverage: array(string),
+    recordLimitReached: boolean,
+    hooked: boolean,
+    debugAvailable: boolean,
+    elapsedMs: number
+  },
+  ["visualState"]
+);
+var declaredValue = object({
+  kind: { type: "string", enum: ["literal", "relative", "expression", "unknown"] },
+  value: { oneOf: [number, string, { type: "null" }] }
+});
+var animationValues = object({
+  basis: { type: "string", enum: ["authored-tween"] },
+  properties: array(object({ property: string, from: declaredValue, to: declaredValue })),
+  ease: declaredValue
+});
+var timelineOutputSchema = object({
+  text: string,
+  generation: string,
+  reused: boolean,
+  status: string,
+  candidates: array(element),
+  events: array(
+    object(
+      {
+        kind: { type: "string", enum: ["animation", "item"] },
+        relation: string,
+        component: nullable(element),
+        targets: array(element),
+        properties: array(string),
+        values: animationValues,
+        start: number,
+        end: number,
+        sources: array(object({ file: string, line: number }))
+      },
+      ["values"]
+    )
+  ),
+  eventCount: number,
+  groupCount: number,
+  nextOffset: nullable(number),
+  warnings: array(string)
+});
+
+// src/tools.ts
+var within = {
+  type: "string",
+  description: "Optional CSS selector restricting target lookup; omit for an unambiguous target."
+};
+var target = {
+  oneOf: [
+    {
+      type: "object",
+      required: ["selector"],
+      additionalProperties: false,
+      properties: {
+        selector: { type: "string", description: "CSS selector, such as #title or .word." },
+        within
+      }
+    },
+    {
+      type: "object",
+      required: ["hfId"],
+      additionalProperties: false,
+      properties: {
+        hfId: { type: "string", description: "Existing element data-hf-id value." },
+        within
+      }
+    },
+    {
+      type: "object",
+      required: ["ref"],
+      additionalProperties: false,
+      properties: {
+        ref: {
+          type: "string",
+          description: "Element ref returned by this inspector session; do not invent it. Rediscover after reload."
+        }
+      }
+    }
+  ]
+};
+var generation = {
+  type: "string",
+  description: "Generation returned by the previous query. Use for continuation; if stale, query targets again."
+};
+var offset = {
+  type: "integer",
+  minimum: 0,
+  description: "Returned nextOffset for continuation; repeat the same query with its generation."
+};
+var componentsTool = {
+  description: "HyperFrames-native grep for element-related source. Retrieve related HTML/CSS/GSAP snippets with file paths and line numbers to understand, debug, or edit known elements without whole-file lookup. Batch targets. Shared code may affect other elements; unknown animation origins are explicit.",
+  inputSchema: {
+    type: "object",
+    required: ["targets"],
+    additionalProperties: false,
+    properties: {
+      targets: {
+        type: "array",
+        maxItems: 20,
+        description: "Batch 1\u201320 targets. Use an empty array only when retrieving snippets by ID.",
+        items: target
+      },
+      descendants: {
+        type: "boolean",
+        default: true,
+        description: "Include source related to descendant elements."
+      },
+      maxBytes: {
+        type: "integer",
+        minimum: 2048,
+        maximum: 256e3,
+        default: 12e3,
+        description: "Response budget in bytes. Whole snippets may be omitted; use returned continuation data or increase the budget."
+      },
+      snippets: {
+        type: "array",
+        items: { type: "string" },
+        description: "Snippet IDs returned by a prior query; requires its generation. May use targets: []."
+      },
+      generation,
+      offset,
+      time: {
+        type: "number",
+        minimum: 0,
+        description: "Optional exact preview seek in global seconds. Does not filter animations by time; omit for ordinary source lookup."
+      }
+    }
+  },
+  outputSchema: componentOutputSchema
+};
+var timelineTool = {
+  description: "HyperFrames-native structured search for animation timing and activity. Use to find animations by time or boundary, including when the target element is unknown. Return scheduled HF entries and observed DOM-target GSAP timing, targets, properties and source locations, not full source blocks. Use at, range or boundary (at most one); omit all for the full schedule. Does not seek. Callbacks and unexecuted animation code are outside coverage.",
+  inputSchema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      component: {
+        ...target,
+        description: "Optional element/component scope including descendants; omit for the full project. Uses the same target format as the components tool."
+      },
+      at: {
+        type: "number",
+        minimum: 0,
+        description: "Global second: active scheduled intervals use start <= at < end; includes instantaneous actions at that time."
+      },
+      range: {
+        type: "array",
+        items: { type: "number", minimum: 0 },
+        minItems: 2,
+        maxItems: 2,
+        description: "Global [start, end) seconds, start < end. Return intersecting scheduled intervals and instantaneous actions inside the range."
+      },
+      boundary: {
+        type: "number",
+        minimum: 0,
+        description: "Global second: return only actions crossing, starting, ending or instantaneous here. Later stagger members are excluded. Group spans are not simultaneous per-target schedules; match target labels and member intervals before inferring overlap."
+      },
+      generation,
+      offset
+    }
+  },
+  outputSchema: timelineOutputSchema
+};
+function toolContent(tool, report) {
+  const text = tool === "timeline" && report.text ? report.text : JSON.stringify(report);
+  return { content: [{ type: "text", text }], structuredContent: report };
+}
+
+// src/live.ts
+var runtime = () => readFileSync2(new URL(`./inspection.${"js"}`, import.meta.url), "utf8");
+function prepareLiveInspection(projectDir, html, provenance, sourceVersion) {
+  const project = realpathSync(projectDir);
+  if (fingerprint(project) !== sourceVersion) throw new Error("source_changed_during_load");
+  if (!/<head\b[^>]*>/i.test(html)) throw new Error("preview_head_missing");
+  const generation2 = randomUUID();
+  const stamp = `window.__hfLiveInspection=${JSON.stringify({ generation: generation2, project })};`;
+  const script = `${stamp}
+${runtime()}`.replace(/<\/script/gi, "<\\/script");
+  const prepared = html.replace(/<head\b[^>]*>/i, (head) => `${head}<script>${script}</script>`);
+  let document2 = prepared;
+  let context;
+  const catalog = /* @__PURE__ */ new Map();
+  const view = {
+    generation: generation2,
+    sourceVersion,
+    pageGeneration: generation2,
+    sourceContext() {
+      if (!context) {
+        const sources = new Sources(project);
+        context = { sources, map: sources.mapper(document2, [...provenance]) };
+      }
+      return context;
+    },
+    async assertCurrent() {
+      if (fingerprint(project) !== sourceVersion)
+        throw new Error("stale_preview: the project changed; query again once the preview reloads");
+    }
+  };
+  async function current(runner) {
+    if (await previewGeneration(runner) !== generation2)
+      throw new Error("stale_preview: the preview reloaded; query again");
+    await view.assertCurrent();
+  }
+  return {
+    html: prepared,
+    generation: generation2,
+    finalizeDocument(servedHtml) {
+      document2 = servedHtml;
+      context = void 0;
+    },
+    async inspect(runner, request) {
+      validateInspectRequest(request);
+      if (request.time != null) throw new Error("live_query_does_not_seek");
+      assertGeneration(request.generation, generation2);
+      await current(runner);
+      return inspectComponents(runner, view, request, {
+        catalog,
+        reused: true,
+        start: performance.now()
+      });
+    },
+    async timeline(runner, request) {
+      validateTimelineRequest(request);
+      assertGeneration(request.generation, generation2);
+      await current(runner);
+      return inspectTimeline(runner, view, request, true);
+    },
+    async elementMap(runner) {
+      await current(runner);
+      return inspectElementMap(runner, view);
+    }
+  };
+}
+function previewGeneration(runner) {
+  return runner.run(liveGenerationPage, void 0);
+}
+export {
+  componentsTool,
+  fingerprint,
+  prepareLiveInspection,
+  previewGeneration,
+  timelineTool,
+  toolContent
+};