@hyperframes/inspector 0.8.155 → 0.8.157

package/dist/live.js

@@ -4,6 +4,263 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import { randomUUID } from "node:crypto";
 import { readFileSync as readFileSync2, realpathSync } from "node:fs";
 
+// src/authoredState.ts
+var PLAIN_CLASS = /^[a-zA-Z_-][\w-]*$/;
+function withAuthoredState(snapshot, sources) {
+  const byHfId = group(sources.htmlTags, (tag) => tag.hfId);
+  const byId = group(sources.htmlTags, (tag) => tag.id);
+  const live = snapshot.nodes;
+  const matched = live.map((node) => sourceTag(node, byHfId, byId));
+  const generated = generatedInsideText(live, matched, sources);
+  const nodes = live.map(
+    (node, index) => generated.has(index) ? steadyGenerated(node, live, generated) : authoredNode(node, matched[index], sources, live)
+  );
+  return { ...snapshot, nodes };
+}
+function authoredNode(node, tag, sources, live) {
+  if (!tag) return node;
+  const text = directText(sources, tag) ?? node.text;
+  const id = node.id || tag.id || "";
+  const classes = authoredClasses(node, tag, live);
+  const next = { ...node, text, id };
+  return classes ? { ...next, ...classes } : next;
+}
+function generatedInsideText(live, matched, sources) {
+  const generated = /* @__PURE__ */ new Set();
+  for (const [index, tag] of matched.entries()) {
+    if (!tag || !directText(sources, tag)) continue;
+    for (const child of live[index].children)
+      if (!matched[child]) markGenerated(child, live, matched, generated);
+  }
+  return generated;
+}
+function markGenerated(index, live, matched, generated) {
+  if (generated.has(index) || matched[index]) return;
+  generated.add(index);
+  for (const child of live[index].children) markGenerated(child, live, matched, generated);
+}
+function steadyGenerated(node, live, generated) {
+  const siblings = node.parent === null ? [node] : live[node.parent].children.map((index) => live[index]);
+  const siblingMatchCount = siblings.filter(
+    (other) => generated.has(other.index) && other.tag === node.tag
+  ).length;
+  return {
+    ...node,
+    id: "",
+    classes: [],
+    text: "",
+    generated: true,
+    groupSelector: node.tag,
+    relative: `${node.tag}:nth-child(${node.position})`,
+    siblingMatchCount
+  };
+}
+function group(tags, key) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const value = key(tag);
+    if (value) groups.set(value, [...groups.get(value) ?? [], tag]);
+  }
+  return groups;
+}
+function sourceTag(node, byHfId, byId) {
+  const named = node.hfId && byHfId.get(node.hfId) || node.id && byId.get(node.id) || [];
+  const matches = named.filter((tag) => tag.tag === node.tag);
+  return matches.length === 1 ? matches[0] : void 0;
+}
+var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "textarea", "title", "xmp", "noembed", "noframes"]);
+var VOID = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function directText(sources, tag) {
+  const text = sources.files.get(tag.file)?.text;
+  if (text === void 0) return null;
+  if (VOID.has(tag.tag)) return "";
+  return normalizedInner(text, tag);
+}
+function normalizedInner(text, tag) {
+  const inner = sliceUntilClose(text, tag.end, tag.tag);
+  if (inner === null) return null;
+  return decodeEntities(textNodes(inner)).replace(/\s+/g, " ").trim();
+}
+function sliceUntilClose(html, from, tag) {
+  const end = closeOffset(html, from, tag, 1);
+  return end === null ? null : html.slice(from, end);
+}
+function closeOffset(html, from, tag, depth) {
+  let cursor = from;
+  let level = depth;
+  for (; ; ) {
+    const step = closeStep(html, cursor, tag, level);
+    if (!step) return null;
+    if (step.done) return step.at;
+    cursor = step.at;
+    level = step.depth;
+  }
+}
+function closeStep(html, from, tag, depth) {
+  const found = nextMarkup(html, from);
+  if (!found) return null;
+  if (found.kind !== "tag") return { at: found.end, depth, done: false };
+  if (isRawOpen(found)) return rawStep(html, found, depth);
+  return tagStep(found, tag, depth);
+}
+function isRawOpen(found) {
+  return !found.closing && RAW_TEXT.has(found.name);
+}
+function rawStep(html, found, depth) {
+  const rawEnd = rawElementEnd(html.toLowerCase(), found.name, found.bracket);
+  if (rawEnd < 0) return null;
+  return { at: rawEnd, depth, done: false };
+}
+function tagStep(found, tag, depth) {
+  const same = found.name === tag && !VOID.has(found.name);
+  if (!same || !found.closing) return openStep(found, depth, same);
+  return closingStep(found, depth);
+}
+function closingStep(found, depth) {
+  if (depth === 1) return { at: found.start, depth, done: true };
+  return { at: found.bracket + 1, depth: depth - 1, done: false };
+}
+function openStep(found, depth, same) {
+  const nextDepth = same ? depth + 1 : depth;
+  return { at: found.bracket + 1, depth: nextDepth, done: false };
+}
+function textNodes(inner) {
+  const found = nextMarkup(inner, 0);
+  if (!found) return inner;
+  return inner.slice(0, found.start) + textAfter(inner, found);
+}
+function textAfter(inner, found) {
+  if (found.kind !== "tag") return textNodes(inner.slice(found.end));
+  return textAfterTag(inner, found);
+}
+function textAfterTag(inner, found) {
+  if (skipsTag(found)) return textNodes(inner.slice(found.bracket + 1));
+  if (RAW_TEXT.has(found.name)) return textAfterRaw(inner, found);
+  return textAfterChild(inner, found);
+}
+function skipsTag(found) {
+  return found.closing || VOID.has(found.name);
+}
+function textAfterRaw(inner, found) {
+  const rawEnd = rawElementEnd(inner.toLowerCase(), found.name, found.bracket);
+  return textNodes(inner.slice(rawEnd < 0 ? inner.length : rawEnd));
+}
+function textAfterChild(inner, found) {
+  const child = sliceUntilClose(inner, found.bracket + 1, found.name);
+  if (child === null) return "";
+  const closeBracket = inner.indexOf(">", found.bracket + 1 + child.length);
+  return textNodes(inner.slice(closeBracket < 0 ? inner.length : closeBracket + 1));
+}
+function nextMarkup(html, from) {
+  const start = html.indexOf("<", from);
+  if (start < 0) return null;
+  return markupAt(html, start);
+}
+function markupAt(html, start) {
+  const skipped = skippedMarkup(html, start);
+  if (skipped) return skipped;
+  return tagMarkup(html, start);
+}
+function skippedMarkup(html, start) {
+  if (html.startsWith("<!--", start)) return boundedSkip(html, start, "-->", 4);
+  if (html.startsWith("<!", start) || html.startsWith("<?", start))
+    return boundedSkip(html, start, ">", 1);
+  return null;
+}
+function boundedSkip(html, start, marker, from) {
+  const end = html.indexOf(marker, start + from);
+  return end < 0 ? null : { kind: "skip", start, end: end + marker.length };
+}
+function tagMarkup(html, start) {
+  const name = /^<\/?([a-zA-Z][^\s/>]*)/.exec(html.slice(start, start + 128));
+  if (!name) return { kind: "skip", start, end: start + 1 };
+  const bracket = closingBracket(html, start + name[0].length);
+  if (bracket < 0) return null;
+  return {
+    kind: "tag",
+    start,
+    name: name[1].toLowerCase(),
+    closing: html[start + 1] === "/",
+    bracket
+  };
+}
+function rawElementEnd(lower, tag, openBracket) {
+  const marker = `</${tag}`;
+  const at2 = nextRawClose(lower, marker, openBracket + 1);
+  if (at2 < 0) return -1;
+  const bracket = lower.indexOf(">", at2 + marker.length);
+  return bracket < 0 ? -1 : bracket + 1;
+}
+function nextRawClose(lower, marker, from) {
+  const at2 = lower.indexOf(marker, from);
+  if (at2 < 0) return -1;
+  const next = lower[at2 + marker.length];
+  if (closesRawText(next)) return at2;
+  return nextRawClose(lower, marker, at2 + marker.length);
+}
+function closesRawText(next) {
+  return next !== void 0 && /[\s/>]/.test(next);
+}
+function closingBracket(html, from) {
+  let quote = "";
+  for (let i = from; i < html.length; i++) {
+    const c = html[i];
+    if (quote) quote = c === quote ? "" : quote;
+    else if (c === '"' || c === "'") quote = c;
+    else if (c === ">") return i;
+  }
+  return -1;
+}
+function decodeEntities(value) {
+  return value.replace(
+    /&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos|nbsp);/gi,
+    (entity, body) => {
+      const named = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+      const lower = body.toLowerCase();
+      if (lower in named) return named[lower];
+      const code = Number.parseInt(
+        lower.slice(lower.startsWith("#x") ? 2 : 1),
+        lower.startsWith("#x") ? 16 : 10
+      );
+      return Number.isInteger(code) && code >= 0 && code <= 1114111 ? String.fromCodePoint(code) : entity;
+    }
+  );
+}
+function authoredClasses(node, tag, live) {
+  const classes = [...tag.classes];
+  if (classes.join(" ") === node.classes.join(" ")) return null;
+  if (!classes.every((c) => PLAIN_CLASS.test(c) && node.classes.includes(c))) return null;
+  const simple = `${node.tag}${classes.map((c) => `.${c}`).join("")}`;
+  const siblings = node.parent === null ? [node] : live[node.parent].children.map((i) => live[i]);
+  const siblingMatchCount = siblings.filter(
+    (other) => other.tag === node.tag && classes.every((c) => other.classes.includes(c))
+  ).length;
+  const relative2 = node.relative.startsWith("#") ? node.relative : siblingMatchCount === 1 ? simple : `${node.tag}:nth-child(${node.position})`;
+  return { classes, groupSelector: simple, siblingMatchCount, relative: relative2 };
+}
+
 // src/elementMap.js
 import { createHash } from "node:crypto";
 function collectElementDom() {
@@ -11,64 +268,65 @@ function collectElementDom() {
   const nodes = [];
   const paths = /* @__PURE__ */ new Map();
   const siblingGroups = /* @__PURE__ */ new WeakMap();
-  function siblingCount(element2, selector) {
-    const owner = element2.parentElement ?? element2;
+  function siblingCount(element, selector) {
+    const owner = element.parentElement ?? element;
     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];
+      const siblings = element.parentElement ? [...element.parentElement.children] : [element];
       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);
+  function path(element) {
+    if (paths.has(element)) return paths.get(element);
     const candidates = [];
-    if (element2.id) candidates.push(`#${CSS.escape(element2.id)}`);
-    const hfId = element2.getAttribute("data-hf-id");
+    if (element.id) candidates.push(`#${CSS.escape(element.id)}`);
+    const hfId = element.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 parent = element.parentElement;
+    const tag = element.localName;
+    const position2 = parent ? [...parent.children].indexOf(element) + 1 : 1;
     const selector = unique ?? (parent ? `${path(parent)} > ${CSS.escape(tag)}:nth-child(${position2})` : CSS.escape(tag));
-    paths.set(element2, selector);
+    paths.set(element, 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) {
+  function visit(element, parent) {
+    if (excluded2.has(element.tagName)) return;
+    const selector = path(element);
+    if (document.querySelectorAll(selector).length !== 1 || document.querySelector(selector) !== element) {
       throw new Error(`Element map selector does not resolve uniquely: ${selector}`);
     }
-    const classes = [...element2.classList].sort();
-    const tag = element2.localName;
+    const classes = [...element.classList].sort();
+    const tag = element.localName;
     const simple = `${CSS.escape(tag)}${classes.map((value) => `.${CSS.escape(value)}`).join("")}`;
-    const siblings = element2.parentElement ? [...element2.parentElement.children] : [element2];
+    const siblings = element.parentElement ? [...element.parentElement.children] : [element];
     const index = nodes.length;
     const node = {
       index,
       parent,
       selector,
       tag,
-      id: element2.id,
-      hfId: element2.getAttribute("data-hf-id"),
+      id: element.id,
+      hfId: element.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})`,
+      composition: element.getAttribute("data-composition-id"),
+      compositionSrc: element.getAttribute("data-composition-src"),
+      text: [...element.childNodes].filter((child) => child.nodeType === 3).map((child) => child.textContent).join("").replace(/\s+/g, " ").trim(),
+      media: ["img", "video", "audio", "source", "iframe"].includes(tag) ? element.getAttribute("src") : null,
+      relative: element.id && document.querySelectorAll(`#${CSS.escape(element.id)}`).length === 1 ? `#${CSS.escape(element.id)}` : siblingCount(element, simple) === 1 ? simple : `${CSS.escape(tag)}:nth-child(${siblings.indexOf(element) + 1})`,
+      position: siblings.indexOf(element) + 1,
       groupSelector: simple,
-      siblingMatchCount: siblingCount(element2, simple),
+      siblingMatchCount: siblingCount(element, simple),
       children: []
     };
     nodes.push(node);
-    for (const child of element2.children) {
+    for (const child of element.children) {
       const childIndex = visit(child, index);
       if (childIndex !== void 0) node.children.push(childIndex);
     }
@@ -106,10 +364,26 @@ function mediaIdentifier(source) {
   if (source.startsWith("blob:")) return "blob:runtime";
   return source;
 }
-function describe(node, selector, count) {
+function childPlaces(members) {
+  const runs = [];
+  let start = members[0].position;
+  let previous = start;
+  for (const member of members.slice(1)) {
+    if (member.position === previous + 1) {
+      previous = member.position;
+      continue;
+    }
+    runs.push(start === previous ? `${start}` : `${start}-${previous}`);
+    start = previous = member.position;
+  }
+  runs.push(start === previous ? `${start}` : `${start}-${previous}`);
+  return runs.join(",");
+}
+function describe(node, selector, count, places = "") {
   const fields = [selector];
   if (!selector.startsWith(node.tag)) fields.push(node.tag);
-  if (count > 1) fields.push(`\xD7${count}`);
+  if (count > 1) fields.push(`\xD7${count}${places ? ` @${places}` : ""}`);
+  if (node.generated) fields.push("(generated)");
   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(" "))}`);
@@ -132,8 +406,8 @@ function formatElementMap(snapshot, { file = "index.html" } = {}) {
       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]);
+    for (const group2 of groups) {
+      const members = group2.indices.map((index) => nodes[index]);
       const node = members[0];
       const exactGroup = members.length > 1 && node.siblingMatchCount === members.length;
       if (members.length > 1 && !exactGroup) {
@@ -144,7 +418,8 @@ function formatElementMap(snapshot, { file = "index.html" } = {}) {
   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)}`);
+    const places = members.length > 1 && !repeatedParents ? childPlaces(members) : "";
+    lines.push(`${"  ".repeat(depth)}${describe(node, selector, members.length, places)}`);
     entries.push({
       line: lines.length,
       selectors: members.map((member) => member.selector),
@@ -262,14 +537,14 @@ var PREVIEW_IGNORED_DIRS = /* @__PURE__ */ new Set([
 
 // src/sources.ts
 var starts = (text) => [0, ...[...text.matchAll(/\n/g)].map((m) => m.index + 1)];
-function position(lines, offset2) {
+function position(lines, offset) {
   let lo = 0, hi = lines.length - 1;
   while (lo < hi) {
     const mid = Math.ceil((lo + hi) / 2);
-    if (lines[mid] <= offset2) lo = mid;
+    if (lines[mid] <= offset) lo = mid;
     else hi = mid - 1;
   }
-  return { line: lo + 1, column: offset2 - lines[lo] };
+  return { line: lo + 1, column: offset - lines[lo] };
 }
 function occurrences(text, needle) {
   const hits = [];
@@ -371,6 +646,36 @@ function rawTextElements(text, tag) {
   }
   return elements;
 }
+function htmlTagsOf(file, text) {
+  return [...text.matchAll(/<([a-z][\w-]*)\b[^>]*>/gi)].map((m) => {
+    const attr = (name) => {
+      const quoted = new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`, "i").exec(m[0]);
+      if (quoted) return quoted[1];
+      return new RegExp(`\\s${name}\\s*=\\s*([^\\s"'=<>]+)`, "i").exec(m[0])?.[1];
+    };
+    return {
+      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)
+    };
+  });
+}
+function authoredHtml(project) {
+  const html = { files: /* @__PURE__ */ new Map(), htmlTags: [] };
+  for (const path of sourceFiles(project)) {
+    const file = relative(project, path);
+    if (!file.endsWith(".html") || /(?:^|\/)(?:vendor|lib)\//.test(file)) continue;
+    const text = readFileSync(path, "utf8");
+    if (text.length > 2e6) continue;
+    html.files.set(file, { text });
+    html.htmlTags.push(...htmlTagsOf(file, text));
+  }
+  return html;
+}
 var Sources = class {
   constructor(project) {
     this.project = project;
@@ -394,18 +699,7 @@ var Sources = class {
             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)
-          });
-        }
+        this.htmlTags.push(...htmlTagsOf(file, text));
       }
     }
   }
@@ -413,7 +707,7 @@ var Sources = class {
   chunks = [];
   cssRules = [];
   htmlTags = [];
-  addChunk(file, source, offset2) {
+  addChunk(file, source, offset) {
     const text = source.trim();
     const lead = source.length - source.trimStart().length;
     if (text) {
@@ -422,7 +716,7 @@ var Sources = class {
       this.chunks.push({
         file,
         text,
-        offset: offset2 + lead,
+        offset: offset + lead,
         get statements() {
           return ranges ??= statements(text);
         },
@@ -432,7 +726,7 @@ var Sources = class {
       });
     }
   }
-  addCss(file, text, offset2) {
+  addCss(file, text, offset) {
     try {
       postcss.parse(text).walkRules((rule) => {
         const start = rule.source?.start?.offset;
@@ -442,14 +736,14 @@ var Sources = class {
             id: `css:${this.cssRules.length}`,
             selector: rule.selector,
             file,
-            start: offset2 + start,
-            end: offset2 + end + 1
+            start: offset + start,
+            end: offset + end + 1
           });
       });
     } catch {
     }
   }
-  slice(file, start, end, kind, target2) {
+  slice(file, start, end, kind, target) {
     const source = this.files.get(file);
     if (!source) return null;
     const first = position(source.lines, start).line;
@@ -464,16 +758,18 @@ var Sources = class {
       startLine: first,
       endLine: last,
       kind: [kind],
-      targets: [target2],
+      targets: [target],
       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)))
+  markup(element, target) {
+    const sameTag = this.htmlTags.filter((tag) => tag.tag === element.tag);
+    const byHfId = element.hfId ? sameTag.filter((tag) => tag.hfId === element.hfId) : [];
+    const tags = byHfId.length ? byHfId : sameTag.filter(
+      (tag) => element.id ? tag.id === element.id : element.classes.length > 0 && element.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;
+    return tags.length === 1 ? this.slice(tags[0].file, tags[0].start, tags[0].end, "html opening tag", target) : null;
   }
   mapper(html, provenance) {
     const htmlLines = starts(html);
@@ -492,29 +788,29 @@ var Sources = class {
         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 locate = (text, offset) => {
+      const found = (ranges.get(text) ?? []).filter(({ chunk, at: at2 }) => offset >= at2 && offset < at2 + chunk.text.length).map(({ chunk, at: at2 }) => ({ chunk, local: offset - 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) => {
+    return (stack, target) => {
       const cached = cache.get(stack);
-      if (cached) return cached.map((snippet2) => ({ ...snippet2, targets: [target2] }));
+      if (cached) return cached.map((snippet) => ({ ...snippet, targets: [target] }));
       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;
+        const offset = m ? htmlLines[Number(m[1]) - 1] + Number(m[2]) - 1 : -1;
+        let hit = m ? locate(html, offset) : 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)
+            if (script ? map.p.sourceURL !== script[1] : offset < map.at || offset >= 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 generated = script ? { line: Number(script[2]), column: Number(script[3]) - 1 } : position(map.lines, offset - 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);
@@ -526,21 +822,21 @@ var Sources = class {
           (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(
+        const snippet = this.slice(
           hit.chunk.file,
           hit.chunk.offset + range.start,
           hit.chunk.offset + range.end,
           result.length ? "animation caller" : "animation creation",
-          target2
+          target
         );
-        if (snippet2) result.push(snippet2);
+        if (snippet) result.push(snippet);
         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
+            target
           );
           if (definition) result.push(definition);
         }
@@ -550,26 +846,26 @@ var Sources = class {
     };
   }
 };
-function markupSnippet(sources, element2, target2) {
-  return sources.markup(element2, target2);
+function markupSnippet(sources, element, target) {
+  return sources.markup(element, target);
 }
 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) {
+  for (const snippet 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);
+    if (last && last.file === snippet.file && snippet.startLine <= last.endLine + 1) {
+      last.endLine = Math.max(last.endLine, snippet.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.targets = [.../* @__PURE__ */ new Set([...last.targets, ...snippet.targets])];
+      last.kind = [.../* @__PURE__ */ new Set([...last.kind, ...snippet.kind])];
       last.uniqueInFile = occurrences(source.text, last.code).length === 1;
-    } else output.push({ ...snippet2 });
+    } else output.push({ ...snippet });
   }
   return output;
 }
@@ -582,7 +878,7 @@ var coverage = [
   "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 { sources, map, catalog, generation, sourceVersion, reused, start, visualState } = context;
   const maxBytes = request.maxBytes ?? 12e3;
   const collected = [];
   const results = raw.results.map((result, index) => {
@@ -593,35 +889,35 @@ function mapInspection(raw, request, context) {
       collected.push(...mapped);
       for (const stack of animation.attachmentStacks)
         collected.push(
-          ...map(stack, index).map((snippet2) => ({ ...snippet2, kind: ["timeline attachment"] }))
+          ...map(stack, index).map((snippet) => ({ ...snippet, kind: ["timeline attachment"] }))
         );
     }
     for (const el of result.elements) {
-      const snippet2 = markupSnippet(sources, el, index);
-      if (snippet2) collected.push(snippet2);
+      const snippet = markupSnippet(sources, el, index);
+      if (snippet) collected.push(snippet);
     }
     for (const id of result.css) {
       const rule = sources.cssRules.find((rule2) => rule2.id === id);
       if (rule) {
-        const snippet2 = sources.slice(
+        const snippet = sources.slice(
           rule.file,
           rule.start,
           rule.end,
           "matched CSS candidate",
           index
         );
-        if (snippet2) collected.push(snippet2);
+        if (snippet) collected.push(snippet);
       }
     }
     return {
       target: index,
       status: result.status,
-      candidates: result.candidates.slice(0, 5),
-      candidatesOmitted: Math.max(0, result.candidates.length - 5),
+      candidates: result.candidates,
+      candidatesOmitted: 0,
       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])
+          result.animations.flatMap((animation) => animation.targets).filter((element) => !result.elements.some((own) => own.ref === element.ref)).map((element) => [element.ref, element])
         ).values()
       ].slice(0, 10),
       unmappedAnimations,
@@ -629,16 +925,16 @@ function mapInspection(raw, request, context) {
     };
   });
   const merged = mergeSnippets(collected, sources);
-  for (const snippet2 of merged) catalog.set(snippet2.id, snippet2);
+  for (const snippet of merged) catalog.set(snippet.id, snippet);
   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 snippet = catalog.get(id);
+      if (!snippet) throw new Error(`unknown_snippet: ${id}`);
+      return snippet;
     });
   const response = {
-    generation: generation2,
+    generation,
     visualState,
     sourceVersion,
     reused,
@@ -653,25 +949,33 @@ function mapInspection(raw, request, context) {
     debugAvailable: true,
     elapsedMs: Math.round(performance.now() - start)
   };
-  const offset2 = request.offset ?? 0;
-  if (!Number.isInteger(offset2) || offset2 < 0)
+  const offset = request.offset ?? 0;
+  if (!Number.isInteger(offset) || offset < 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) {
+  const size = () => Buffer.byteLength(JSON.stringify(response));
+  const trimCandidates = (limit, keep) => {
+    while (size() > limit) {
+      const longest = response.results.reduce(
+        (a, b) => b.candidates.length > a.candidates.length ? b : a
+      );
+      if (longest.candidates.length <= keep) return;
+      longest.candidates.pop();
+      longest.candidatesOmitted++;
+    }
+  };
+  trimCandidates(maxBytes / 2, 5);
+  for (let i = offset; i < selected.length; i++) {
+    response.snippets.push(selected[i]);
+    if (size() > 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;
+      const nothingFit = response.snippets.length === 0;
+      response.nextOffset = nothingFit ? i + 1 < selected.length ? i + 1 : null : 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++;
-  }
+  trimCandidates(maxBytes, 0);
   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 };
@@ -694,20 +998,21 @@ function timelinePage(request) {
   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 generation = inspected.__hfLiveInspection?.generation ?? null;
+  const duration = inspected.__player?.getDuration();
+  if (request.boundary === void 0) return { ...result, following, generation, duration };
   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) {
+    for (const target 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))
+        (event) => event.kind === "animation" && event.start > boundary && event.targets.some((t) => t.ref === target.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 };
+  return { ...result, following, generation, duration };
 }
 function liveGenerationPage() {
   return window.__hfLiveInspection?.generation ?? null;
@@ -721,27 +1026,30 @@ 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 offset = request.offset ?? 0;
+  const allGroups = byComponent(groupEvents(raw.events));
+  const groups = allGroups.slice(offset, offset + 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) => ({
+    sources: onePerSourceLine(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 nextOffset = offset + groups.length < allGroups.length ? offset + 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}`) : [],
+    ...raw.status !== "found" ? raw.candidates.map(
+      (c) => `${c.ref} ${targetSummary([c])[0]} ${c.tag}${c.composition ? ` in ${c.composition}` : ""}`
+    ) : [],
+    ...pastTheEnd(request, raw.duration),
     ...request.boundary !== void 0 ? [`Boundary ${request.boundary}s: ${BOUNDARY_NOTE}`] : [],
     ...describeGroups(groups, request, view.map, label),
     ...describeFollowing(raw, view.map, label),
-    ...describeRelations(events),
+    ...describeRelations(groups),
     ...nextOffset !== null ? [`More groups: repeat with offset=${nextOffset} and generation.`] : [],
     ...raw.warnings.map((w) => `Coverage: ${w}`),
     ...events.some((e) => e.values) ? [
@@ -777,6 +1085,21 @@ function groupEvents(events) {
   }
   return [...groups.values()];
 }
+var headingOf = (event) => event.component?.id ? `#${event.component.id}` : event.component?.composition ?? "unassigned";
+function byComponent(groups) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const group2 of groups) {
+    const heading = headingOf(group2[0]);
+    owners.set(heading, [...owners.get(heading) ?? [], group2]);
+  }
+  return [...owners.values()].flat();
+}
+function pastTheEnd(request, duration) {
+  const from = request.range?.[0] ?? request.at ?? request.boundary;
+  const filmLength = duration !== void 0 && duration > 0 ? duration : void 0;
+  if (filmLength === void 0 || from === void 0 || from < filmLength) return [];
+  return [`Requested time is past the end: the film is ${Number(filmLength.toFixed(4))}s long.`];
+}
 function labeler() {
   const labels = /* @__PURE__ */ new Map();
   return (ref) => {
@@ -785,10 +1108,15 @@ function labeler() {
   };
 }
 var at = (seconds) => seconds.toFixed(4);
-var located = (sources) => sources.map((s) => `${s.file}:${s.startLine}`).join(", ");
+function onePerSourceLine(sources) {
+  return [...new Map(sources.map((s) => [`${s.file}:${s.startLine}`, s])).values()];
+}
+var located = (sources) => onePerSourceLine(sources).map((s) => `${s.file}:${s.startLine}`).join(", ");
 function describeValue(value) {
   if (value.kind === "unknown") return "?";
-  return `${value.value}${value.kind === "literal" ? "" : ` (${value.kind})`}`;
+  if (value.kind === "expression" && value.value === "custom function") return "custom function";
+  const shown = typeof value.value === "number" ? Number(value.value.toFixed(4)) : value.value;
+  return `${shown}${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)}`;
@@ -805,7 +1133,7 @@ function describeGroups(groups, request, map, label) {
       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";
+    const heading = headingOf(event);
     if (owner !== heading) {
       lines.push(`
 ${heading}${component ? ` [${component.ref}]` : ""}`);
@@ -834,8 +1162,9 @@ ${heading}${component ? ` [${component.ref}]` : ""}`);
 }
 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);
+  for (const target of targets) {
+    const own = target.id ? `#${target.id}` : target.hfId ?? (target.classes.length ? `.${target.classes.join(".")}` : target.tag);
+    const name = !target.id && target.withinId ? `${own} in #${target.withinId}` : own;
     counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   return [...counts].map(([name, count]) => count > 1 ? `${name} \xD7${count}` : name);
@@ -882,18 +1211,23 @@ function describeFollowing(raw, map, label) {
     lines.push(`  ${raw.following.length - FOLLOWING_SHOWN} additional following actions omitted.`);
   return lines;
 }
-function describeRelations(events) {
+function describeRelations(groups) {
   const lines = [];
+  const events = groups.flatMap((members, group2) => members.map((event) => ({ event, group: group2 })));
+  const described = /* @__PURE__ */ new Set();
   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];
+      const left = events[a].event;
+      const right = events[b].event;
+      const pair = `${events[a].group}:${events[b].group}`;
+      if (described.has(pair)) continue;
       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";
+      described.add(pair);
       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.`
       );
@@ -936,7 +1270,10 @@ async function inspectTimeline(runner, view, request, 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 });
+  const authored = view.authoredHtml?.();
+  const map = formatElementMap(authored ? withAuthoredState(snapshot, authored) : snapshot, {
+    file
+  });
   await view.assertCurrent();
   return { ...map, sourceVersion: view.sourceVersion, generation: view.generation };
 }
@@ -945,10 +1282,10 @@ async function inspectElementMap(runner, view, file = "index.html") {
 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(
+  for (const target of request.targets) {
+    if (!target || typeof target !== "object") throw new Error("Invalid target");
+    const keys = ["selector", "hfId", "ref"].filter((key) => key in target);
+    if (keys.length !== 1 || Object.values(target).some(
       (value) => typeof value !== "string" || !value || value.length > 1e3
     ))
       throw new Error("Each target needs exactly one selector, hfId or ref; within is optional.");
@@ -982,260 +1319,35 @@ function validateTimelineRequest(request) {
   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)
+  const offset = request.offset ?? 0;
+  if (!Number.isInteger(offset) || offset < 0)
     throw new Error("offset must be non-negative integer");
-  if (offset2 && !request.generation) throw new Error("pagination requires generation");
+  if (offset && !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 generation = randomUUID();
+  const stamp = `window.__hfLiveInspection=${JSON.stringify({ generation, 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;
+  let authored;
   const catalog = /* @__PURE__ */ new Map();
   const view = {
-    generation: generation2,
+    generation,
     sourceVersion,
-    pageGeneration: generation2,
+    pageGeneration: generation,
     sourceContext() {
       if (!context) {
         const sources = new Sources(project);
@@ -1243,19 +1355,22 @@ ${runtime()}`.replace(/<\/script/gi, "<\\/script");
       }
       return context;
     },
+    authoredHtml() {
+      return authored ??= authoredHtml(project);
+    },
     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)
+    if (await previewGeneration(runner) !== generation)
       throw new Error("stale_preview: the preview reloaded; query again");
     await view.assertCurrent();
   }
   return {
     html: prepared,
-    generation: generation2,
+    generation,
     finalizeDocument(servedHtml) {
       document2 = servedHtml;
       context = void 0;
@@ -1263,7 +1378,7 @@ ${runtime()}`.replace(/<\/script/gi, "<\\/script");
     async inspect(runner, request) {
       validateInspectRequest(request);
       if (request.time != null) throw new Error("live_query_does_not_seek");
-      assertGeneration(request.generation, generation2);
+      assertGeneration(request.generation, generation);
       await current(runner);
       return inspectComponents(runner, view, request, {
         catalog,
@@ -1273,7 +1388,7 @@ ${runtime()}`.replace(/<\/script/gi, "<\\/script");
     },
     async timeline(runner, request) {
       validateTimelineRequest(request);
-      assertGeneration(request.generation, generation2);
+      assertGeneration(request.generation, generation);
       await current(runner);
       return inspectTimeline(runner, view, request, true);
     },
@@ -1287,10 +1402,7 @@ function previewGeneration(runner) {
   return runner.run(liveGenerationPage, void 0);
 }
 export {
-  componentsTool,
   fingerprint,
   prepareLiveInspection,
-  previewGeneration,
-  timelineTool,
-  toolContent
+  previewGeneration
 };