@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-html-analyzer-O63XZLZD.js

@@ -0,0 +1,1759 @@
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import {
+  EXTENSION_LANGUAGE
+} from "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-html-analyzer.ts
+import * as path from "path";
+import { existsSync, statSync } from "fs";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function isHtmlSpace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12;
+}
+function asciiLower(text) {
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 65 && c <= 90) return text.slice(0, i) + text.slice(i).toLowerCase();
+  }
+  return text;
+}
+var NAMED_CHARACTER_REFERENCES = /* @__PURE__ */ new Map([
+  ["amp", "&"],
+  ["AMP", "&"],
+  ["lt", "<"],
+  ["LT", "<"],
+  ["gt", ">"],
+  ["GT", ">"],
+  ["quot", '"'],
+  ["QUOT", '"'],
+  ["apos", "'"],
+  ["nbsp", "\xA0"],
+  ["copy", "\xA9"],
+  ["reg", "\xAE"],
+  ["trade", "\u2122"],
+  ["hellip", "\u2026"],
+  ["mdash", "\u2014"],
+  ["ndash", "\u2013"],
+  ["lsquo", "\u2018"],
+  ["rsquo", "\u2019"],
+  ["ldquo", "\u201C"],
+  ["rdquo", "\u201D"],
+  ["bull", "\u2022"],
+  ["middot", "\xB7"],
+  ["deg", "\xB0"],
+  ["plusmn", "\xB1"],
+  ["times", "\xD7"],
+  ["divide", "\xF7"],
+  ["laquo", "\xAB"],
+  ["raquo", "\xBB"],
+  ["sect", "\xA7"],
+  ["para", "\xB6"],
+  ["euro", "\u20AC"],
+  ["pound", "\xA3"],
+  ["yen", "\xA5"],
+  ["cent", "\xA2"],
+  ["dagger", "\u2020"],
+  ["Dagger", "\u2021"],
+  ["permil", "\u2030"],
+  ["larr", "\u2190"],
+  ["rarr", "\u2192"],
+  ["harr", "\u2194"],
+  ["darr", "\u2193"],
+  ["uarr", "\u2191"]
+]);
+function isReferenceDigits(text, hex) {
+  if (text.length === 0) return false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 48 && c <= 57) continue;
+    if (hex && (c >= 97 && c <= 102 || c >= 65 && c <= 70)) continue;
+    return false;
+  }
+  return true;
+}
+function decodeCharacterReferences(text) {
+  if (text.indexOf("&") === -1) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const amp = text.indexOf("&", i);
+    if (amp === -1) {
+      out += text.slice(i);
+      break;
+    }
+    out += text.slice(i, amp);
+    const semi = text.indexOf(";", amp + 1);
+    if (semi === -1 || semi - amp > 33) {
+      out += "&";
+      i = amp + 1;
+      continue;
+    }
+    const body = text.slice(amp + 1, semi);
+    if (body.length === 0) {
+      out += "&";
+      i = amp + 1;
+      continue;
+    }
+    if (body.charCodeAt(0) === 35) {
+      const hex = body.charCodeAt(1) === 120 || body.charCodeAt(1) === 88 || body.charCodeAt(1) === 35 && (body.charCodeAt(2) === 120 || body.charCodeAt(2) === 88);
+      const digits = hex ? body.charCodeAt(1) === 35 ? body.slice(3) : body.slice(2) : body.slice(1);
+      if (digits.length > 0 && digits.length <= 8 && isReferenceDigits(digits, hex)) {
+        const code = hex ? Number.parseInt(digits, 16) : Number.parseInt(digits, 10);
+        if (code >= 0 && code <= 1114111 && !(code >= 55296 && code <= 57343)) {
+          out += String.fromCodePoint(code);
+          i = semi + 1;
+          continue;
+        }
+      }
+      out += "&";
+      i = amp + 1;
+      continue;
+    }
+    const named = NAMED_CHARACTER_REFERENCES.get(body);
+    if (named !== void 0) {
+      out += named;
+      i = semi + 1;
+      continue;
+    }
+    out += "&";
+    i = amp + 1;
+  }
+  return out;
+}
+function unquote(text) {
+  const n = text.length;
+  if (n >= 2) {
+    const first = text.charCodeAt(0);
+    const last = text.charCodeAt(n - 1);
+    if ((first === 34 || first === 39) && first === last) return text.slice(1, -1);
+  }
+  return text;
+}
+function urlScheme(value) {
+  const n = value.length;
+  for (let i = 0; i < n; i++) {
+    const c = value.charCodeAt(i);
+    if (c === 58) {
+      if (i === 0) return "";
+      const f = value.charCodeAt(0);
+      const alpha2 = f >= 65 && f <= 90 || f >= 97 && f <= 122;
+      return alpha2 ? asciiLower(value.slice(0, i)) : "";
+    }
+    const alpha = c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    const digit = c >= 48 && c <= 57;
+    if (!alpha && !digit && c !== 43 && c !== 45 && c !== 46) return "";
+  }
+  return "";
+}
+function isNetworkScheme(value) {
+  const s = urlScheme(value);
+  return s === "http" || s === "https" || s === "ftp" || s === "ftps";
+}
+function isNonResourceScheme(value) {
+  const s = urlScheme(value);
+  if (s === "") return false;
+  return !isNetworkScheme(value);
+}
+function isProtocolRelative(value) {
+  return value.length >= 2 && value.charCodeAt(0) === 47 && value.charCodeAt(1) === 47;
+}
+function fragmentTarget(value) {
+  return value.length > 1 && value.charCodeAt(0) === 35 ? value.slice(1) : "";
+}
+function srcsetCandidates(value) {
+  const out = [];
+  const n = value.length;
+  let i = 0;
+  while (i < n) {
+    while (i < n && (isHtmlSpace(value.charCodeAt(i)) || value.charCodeAt(i) === 44)) i++;
+    if (i >= n) break;
+    const urlStart = i;
+    while (i < n && !isHtmlSpace(value.charCodeAt(i))) i++;
+    const url = value.slice(urlStart, i);
+    let trimmed = url;
+    while (trimmed.length > 0 && trimmed.charCodeAt(trimmed.length - 1) === 44) {
+      trimmed = trimmed.slice(0, -1);
+      i++;
+    }
+    if (trimmed.length > 0) out.push(trimmed);
+    let depth = 0;
+    while (i < n) {
+      const c = value.charCodeAt(i);
+      if (c === 40) depth++;
+      else if (c === 41 && depth > 0) depth--;
+      else if (c === 44 && depth === 0) {
+        i++;
+        break;
+      }
+      i++;
+    }
+  }
+  return out;
+}
+function firstToken(text) {
+  const n = text.length;
+  let start = 0;
+  while (start < n && isHtmlSpace(text.charCodeAt(start))) start++;
+  if (start >= n) return "";
+  let end = start;
+  while (end < n && !isHtmlSpace(text.charCodeAt(end))) end++;
+  return text.slice(start, end);
+}
+function table(entries) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), entries);
+}
+function map() {
+  return /* @__PURE__ */ Object.create(null);
+}
+var SEMANTIC_ELEMENTS = table({
+  "header": true,
+  "nav": true,
+  "main": true,
+  "section": true,
+  "article": true,
+  "aside": true,
+  "footer": true,
+  "h1": true,
+  "h2": true,
+  "h3": true,
+  "h4": true,
+  "h5": true,
+  "h6": true,
+  "figure": true,
+  "figcaption": true,
+  "time": true,
+  "data": true,
+  "mark": true,
+  "details": true,
+  "summary": true,
+  "dialog": true,
+  "meter": true,
+  "progress": true,
+  "search": true,
+  "address": true,
+  "hgroup": true
+});
+var INTERACTIVE_ELEMENTS = table({
+  "button": true,
+  "input": true,
+  "select": true,
+  "textarea": true,
+  "a": true,
+  "details": true,
+  "summary": true,
+  "dialog": true,
+  "menu": true,
+  "option": true,
+  "optgroup": true,
+  "label": true,
+  "fieldset": true,
+  "output": true,
+  "area": true
+});
+var FORM_ELEMENTS = table({
+  "form": true,
+  "input": true,
+  "select": true,
+  "textarea": true,
+  "button": true,
+  "fieldset": true,
+  "legend": true,
+  "label": true,
+  "datalist": true,
+  "optgroup": true,
+  "option": true,
+  "output": true,
+  "meter": true,
+  "progress": true
+});
+var TEMPLATE_BARRIERS = table({ "template": true, "slot": true });
+var LINK_FETCHABLE_RELS = table({
+  "stylesheet": true,
+  "icon": true,
+  "shortcut icon": true,
+  "apple-touch-icon": true,
+  "apple-touch-icon-precomposed": true,
+  "mask-icon": true,
+  "manifest": true,
+  "preload": true,
+  "prefetch": true,
+  "preload-stylesheet": true,
+  "modulepreload": true,
+  "import": true,
+  "subresource": true,
+  "alternate": true,
+  "canonical": true
+});
+var LINK_RESOURCE_TYPES = table({
+  "stylesheet": "stylesheet",
+  "icon": "icon",
+  "shortcut icon": "icon",
+  "apple-touch-icon": "icon",
+  "apple-touch-icon-precomposed": "icon",
+  "mask-icon": "icon",
+  "manifest": "manifest",
+  "preload": "preload",
+  "modulepreload": "preload",
+  "prefetch": "prefetch",
+  "import": "import",
+  "alternate": "alternate",
+  "canonical": "canonical"
+});
+var PARAM_RESOURCE_NAMES = table({
+  "movie": true,
+  "src": true,
+  "url": true,
+  "codebase": true,
+  "archive": true
+});
+var CONDITIONAL_DIRECTIVE_SUFFIXES = ["if", "else", "elseif", "when", "unless", "show", "test"];
+var REPEAT_DIRECTIVE_SUFFIXES = ["for", "each", "repeat"];
+function spaceSeparatedUrls(value) {
+  const out = [];
+  let start = 0;
+  for (let i = 0; i <= value.length; i++) {
+    if (i !== value.length && !isHtmlSpace(value.charCodeAt(i))) continue;
+    if (i > start) out.push(value.slice(start, i));
+    start = i + 1;
+  }
+  return out;
+}
+function refreshContentUrl(content) {
+  const semi = content.indexOf(";");
+  if (semi === -1) return "";
+  if (!asciiLower(content.slice(semi + 1).trim()).startsWith("url=")) return "";
+  const inner = content.slice(semi + 1).trim().slice(4).trim();
+  if (inner.length < 2) return inner;
+  const first = inner[0];
+  const last = inner[inner.length - 1];
+  if ((first === '"' || first === "'") && first === last) return inner.slice(1, -1).trim();
+  return inner;
+}
+var RESOURCE_RULES = table({
+  script: [
+    { attr: "src", resourceType: "script", import: true },
+    // SVG2 spells a script's source `href`, not `src`. Inside `<svg>` that is the
+    // ONLY spelling there is, so a table with `src` alone dropped every inline SVG
+    // script's dependency. The row is keyed on the tag, not the namespace, which
+    // is safe because an HTML `<script>` has no `href` to read — the lookup finds
+    // no attribute and emits nothing, rather than needing a namespace test the
+    // table has no way to express.
+    { attr: "href", resourceType: "svg-script", import: true }
+  ],
+  link: [
+    // `rel` decides both WHETHER the href is a document the page fetches and
+    // WHICH kind it is: `rel=stylesheet` is a stylesheet, `rel=icon` an icon,
+    // and `rel=preconnect`/`dns-prefetch` name a host for a connection warm-up
+    // rather than a subresource — the pre-fix analyzer mirrored those into
+    // `imports`, so the index claimed a dependency on a URL nothing serves.
+    { attr: "href", resourceType: "link", import: true, relFilter: LINK_FETCHABLE_RELS }
+  ],
+  img: [
+    { attr: "src", resourceType: "img", import: true },
+    { attr: "srcset", resourceType: "img-srcset", candidates: "srcset", import: true },
+    { attr: "longdesc", resourceType: "img-longdesc", import: true }
+  ],
+  // `<source>` carries BOTH a single `src` and a `srcset` candidate list, and
+  // the pre-fix analyzer read only `src` and only when the IMMEDIATE parent was
+  // picture/audio/video — so `<video><div><source src=…></div></video>` lost the
+  // resource. A candidate's own `media` attribute is the context test, and the
+  // ancestor test is now a bounded walk (see `isMediaContext`).
+  source: [
+    { attr: "src", resourceType: "media-source", import: true },
+    { attr: "srcset", resourceType: "img-srcset", candidates: "srcset", import: true }
+  ],
+  video: [
+    { attr: "src", resourceType: "video", import: true },
+    { attr: "poster", resourceType: "video-poster", import: true }
+  ],
+  audio: [{ attr: "src", resourceType: "audio", import: true }],
+  track: [{ attr: "src", resourceType: "track", import: true }],
+  embed: [{ attr: "src", resourceType: "embed", import: true }],
+  // `<object data>` names the resource itself; `<object archive>` names the
+  // ADDITIONAL resources needed to instantiate it, and the HTML specification
+  // defines it as a SPACE-separated list of URIs — the same shape as `<a ping>`
+  // and for the same reason (several per attribute, no descriptor, no comma).
+  //
+  // It was missing, and the carrier census found it rather than the ontology gate:
+  // `script/m14/verify-carrier-census.ts` reports `object@archive` as UNREVIEWED at
+  // 4 occurrences in 2 documents, and a carrier nobody has ruled is a carrier
+  // nobody has decided about. Measured on the tree over 1,699 corpus documents
+  // (aspnetcore/src/Mvc/test/Mvc.FunctionalTests/compiler/resources/
+  // RazorWebSite.UrlResolution.Index.html and its .Encoded.html twin):
+  //
+  //   object@archive   4 occurrences, 2 files   — 3 real URLs, 1 Razor artifact
+  //
+  // That is a small population and the verdict does not pretend otherwise; the
+  // construct is real, it occurs, and the rule for it is one table row. It is a
+  // FETCH like `data`, so it takes the same shape and the same `import` mirror.
+  object: [
+    { attr: "data", resourceType: "object", import: true },
+    { attr: "archive", resourceType: "object-archive", import: true, valueList: "space" }
+  ],
+  input: [{ attr: "src", resourceType: "input-image", import: true }],
+  iframe: [{ attr: "src", resourceType: "iframe", import: true }],
+  frame: [{ attr: "src", resourceType: "frame", import: true }],
+  // SVG reference carriers. `xlink:href` is the legacy spelling; both are read
+  // and the attribute map is already lowercased, so `XLINK:HREF` lands here too.
+  use: [
+    // `href="#icon"` is the ordinary SVG form and is a same-document reference;
+    // `href="sprite.svg#icon"` is an external file and a fetch. Both spellings of
+    // the attribute are read, and the attribute map is lowercased, so the legacy
+    // `XLINK:HREF` lands on the same rule.
+    { attr: "href", resourceType: "svg-use", import: true, fragmentRef: true },
+    { attr: "xlink:href", resourceType: "svg-use", import: true, fragmentRef: true }
+  ],
+  image: [
+    { attr: "href", resourceType: "svg-image", import: true, fragmentRef: true },
+    { attr: "xlink:href", resourceType: "svg-image", import: true, fragmentRef: true }
+  ],
+  param: [{ attr: "value", resourceType: "param", import: true, paramNameFilter: PARAM_RESOURCE_NAMES }],
+  a: [
+    { attr: "href", resourceType: "navigation", link: true, navigation: true, fragmentRef: true },
+    // `ping` is a whitespace-separated list of URLs FETCHED when the link is
+    // activated. It is a fetch, not a navigation — the browser requests it; the
+    // user never goes there — so it takes the resource path and the `import`
+    // mirror, and the scheme contract filters an external endpoint.
+    { attr: "ping", resourceType: "ping", import: true, valueList: "space" }
+  ],
+  area: [{ attr: "href", resourceType: "navigation", link: true, navigation: true, fragmentRef: true }],
+  form: [{ attr: "action", resourceType: "form-action", link: true }],
+  button: [{ attr: "formaction", resourceType: "form-action", link: true }],
+  html: [{ attr: "manifest", resourceType: "manifest", import: true }],
+  meta: [
+    // The refresh PRAGMA. `content` is a URL only under `http-equiv=refresh`,
+    // and the gate is what keeps `charset`/`description`/viewport text from
+    // becoming an edge to a sentence. 40 occurrences across 26 files in one
+    // corpus, and entirely absent from the table until a carrier census looked
+    // for it rather than for what the table already knew.
+    { attr: "content", resourceType: "meta-refresh", link: true, navigation: true, httpEquiv: "refresh", contentUrl: true }
+  ],
+  // SVG filter reference. `feImage` pulls an image to paint INTO the filter
+  // result, which is a fetch like any other; the tag is lowercased by the
+  // walker, so the key is `feimage`.
+  feimage: [
+    { attr: "href", resourceType: "svg-filter-image", import: true },
+    { attr: "xlink:href", resourceType: "svg-filter-image", import: true }
+  ],
+  // `cite` names where a quotation or a change came FROM. Nothing fetches it and
+  // nothing navigates to it, but it IS a written reference out of the document,
+  // so it is an edge — recorded as a usage-contextual reference rather than as
+  // an import, because grading a citation as a structural fetch overstates it.
+  // Four elements carry it, and all four are in the table rather than one, since
+  // the ruling is about the attribute's meaning and not about any single tag.
+  q: [{ attr: "cite", resourceType: "citation", fragmentRef: true, evidenceClass: "usage_contextual" }],
+  blockquote: [{ attr: "cite", resourceType: "citation", fragmentRef: true, evidenceClass: "usage_contextual" }],
+  del: [{ attr: "cite", resourceType: "citation", fragmentRef: true, evidenceClass: "usage_contextual" }],
+  ins: [{ attr: "cite", resourceType: "citation", fragmentRef: true, evidenceClass: "usage_contextual" }],
+  // Legacy presentational background images. Deprecated in HTML5 and still
+  // fetched by every shipping browser, so the dependency is real; the
+  // `legacy-` resourceType says so at the edge, which is the difference between
+  // a recorded fact and an implied one.
+  //
+  // `td`/`th` ARE THE SAME ATTRIBUTE ON THE SAME SPEC LIST, AND THIS TABLE WAS
+  // MISSING THEM (carrier census, 2026-10-28). The legacy `background`
+  // attribute is defined on `body`, `table`, `td` and `th`; the two cell
+  // elements are not a variant this analyzer invented, they are the other half
+  // of the same construct, so `body` and `table` without them described two of
+  // four owners. Measured consequence: the census found `td@background`
+  // carrying a real image path
+  // (`FSharp.Data/tests/FSharp.Data.Tests/Data/MarketDepth.htm`,
+  // `/bwx_drop_shadow_900_300.gif`) with no table claiming it, so an edge the
+  // browser really fetches was absent from the graph. `th` is added in the same
+  // commit rather than after a census reports it: the two cells differ in
+  // nothing the attribute is concerned with, and a ruling that names one and
+  // not the other is a ruling about the corpus that happened to run.
+  body: [{ attr: "background", resourceType: "legacy-background", import: true }],
+  table: [{ attr: "background", resourceType: "legacy-background", import: true }],
+  td: [{ attr: "background", resourceType: "legacy-background", import: true }],
+  th: [{ attr: "background", resourceType: "legacy-background", import: true }]
+});
+var FORM_ACTION_INPUT_TYPES = table({ submit: true, image: true });
+var INPUT_FORMACTION_RULE = { attr: "formaction", resourceType: "form-action", link: true };
+var HTML_DOCUMENT_EXTS = new Set(
+  Object.keys(EXTENSION_LANGUAGE).filter((ext) => EXTENSION_LANGUAGE[ext] === "html")
+);
+function resourceExtension(value) {
+  const clean = value.split("#")[0].split("?")[0];
+  const base = clean.slice(clean.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
+}
+function rebaseToProject(documentPath, projectRoot, value) {
+  const written = value.split("#")[0].split("?")[0];
+  if (written.length === 0) return null;
+  const abs = written.startsWith("/") ? path.resolve(projectRoot, written.slice(1)) : path.resolve(path.dirname(documentPath), written);
+  const rel = path.relative(projectRoot, abs);
+  if (rel.length === 0) return null;
+  const posix2 = rel.split(path.sep).join("/");
+  if (posix2.startsWith("..") || path.posix.isAbsolute(posix2)) return null;
+  return posix2;
+}
+var IDREF_RULES = [
+  { tag: "", attr: "aria-labelledby", kind: "aria-labelledby", list: true },
+  { tag: "", attr: "aria-describedby", kind: "aria-describedby", list: true },
+  { tag: "", attr: "aria-details", kind: "aria-details", list: true },
+  { tag: "", attr: "aria-errormessage", kind: "aria-errormessage", list: false },
+  { tag: "", attr: "aria-controls", kind: "aria-controls", list: true },
+  { tag: "", attr: "aria-owns", kind: "aria-owns", list: true },
+  { tag: "", attr: "aria-flowto", kind: "aria-flowto", list: true },
+  { tag: "", attr: "aria-activedescendant", kind: "aria-activedescendant", list: false },
+  { tag: "td", attr: "headers", kind: "table-header", list: true },
+  { tag: "th", attr: "headers", kind: "table-header", list: true },
+  // The form owner and the datalist an input offers. Both name an element in the
+  // same document through its `id`, which is why they are here and not in the
+  // resource table: nothing is fetched and nothing is navigated to. Both are
+  // SINGLE references, which is why they carry no `idrefList`.
+  { tag: "", attr: "form", kind: "form-owner", list: false },
+  { tag: "", attr: "list", kind: "datalist", list: false },
+  // `<output for>` names the controls whose value the output reports — a
+  // space-separated token list, like `headers`.
+  { tag: "output", attr: "for", kind: "output-for", list: true }
+];
+var HEADING_ELEMENTS = table({ h1: true, h2: true, h3: true, h4: true, h5: true, h6: true });
+var DELEGATE_FILE_ACTOR = "(file)";
+var RealHtmlAnalyzer = class {
+  /**
+   * The embedded-block languages whose delegate analyzer could not be loaded in
+   * this process, populated only by `mergeEmbeddedBlocks` and published as
+   * `metadata.unavailableEmbeddedLangs`. Non-empty means: this document HAS inline
+   * blocks and they were NOT analysed. A field rather than a log line, because a
+   * consumer that asks "does this file contain code?" needs to be able to tell
+   * "no" from "not measured", and only a published field can say that.
+   */
+  unavailableEmbeddedLangs = [];
+  /**
+   * THE DOCUMENT AND ITS PROJECT ROOT, for the two claim keys a resource edge can carry.
+   *
+   * Fields rather than two more parameters on `emitResource`, whose six call sites already
+   * thread eight arguments each: the values are properties OF THE ANALYSIS (`filePath` and
+   * `context.projectRoot`), they are identical for every emission in one document, and
+   * `analyze` is synchronous, so the pair is set once at the top of the walk and read by the
+   * helper below. Empty `claimProjectRoot` means the caller did not name a project root — the
+   * fixture runner does not — and a project-relative candidate is then NOT stated: an
+   * unrooted path would be a claim about a file list the caller never supplied.
+   */
+  claimDocumentPath = "";
+  claimProjectRoot = "";
+  /**
+   * THE CLAIM A RESOURCE TARGET CAN CARRY — the reason the edge names something this run cannot
+   * resolve to a declaration, published on a key the ARBITER reads.
+   *
+   * THE DEFECT THIS CLOSES, in this lane's own measurement. `incoming-rule.ts` recognises a fixed
+   * list of keys (`EXTERNAL_KEYS`, `:56-80`) plus the file/source-path claim kinds, and the lane
+   * published `isExternalResource` on its network-URL fetches — a truthful marker on a spelling
+   * that is not in that list, so the arbiter read the edge as an unstated hole. `causeOK` was 0
+   * fleet-wide for exactly this reason. The fix is not to invent a new marker but to publish the
+   * claim in the vocabulary the arbiter already verifies:
+   *
+   *   A NETWORK URL (`https:`, `http:`, `//cdn…`) is outside every admitted file list BY
+   *   CONSTRUCTION, so the edge carries `sourcePathClaim`. Its polarity is inverted on purpose
+   *   (`incoming-rule.ts:317-339`): the project REFUTES the claim the moment a candidate IS an
+   *   admitted file, which is what stops this from becoming a laundering channel.
+   *
+   *   AN HTML DOCUMENT that exists beside this one — `../index.html`, `page.html`, `/guide.html`
+   *   — carries `importProjectFile`, the FILE claim, and it is the honest one: the project's own
+   *   admitted list then CONFIRMS the file. MEASURED over the lane's bounded population: of
+   *   20,470 such targets, 20,295 name a document that is on disk AND admitted, and the other
+   *   175 are DEAD LINKS — nothing on disk — which is why existence is probed before the claim is
+   *   published. Without that probe the claim would be published on 175 targets that name no file,
+   *   and the arbiter would count 175 refutations against the lane: a false statement, not a
+   *   better-looking table.
+   *
+   *   ANYTHING ELSE PATH-SHAPED (`../../styles/main.css`, `/assets/x.js`) carries the same
+   *   `sourcePathClaim`: the project admits no file answering the written string, which for an
+   *   extension this lane cannot admit is true by construction.
+   *
+   *   A BARE NAME GETS NOTHING (`details.html` with no file beside it, `main`, `getItem`). The
+   *   source-path claim is defined only for a target containing `/` or a scheme
+   *   (`incoming-rule.ts:335-337`), and a bare name is exactly the spelling that can also name a
+   *   DECLARATION — so publishing a claim on it is the one move that could hide a resolution.
+   *
+   * EVERY KEY HERE IS ADDITIVE. The target is untouched, no existing metadata key is renamed or
+   * removed, and a claim is read by the arbiter only where the target names no declaration
+   * (`classifyEdge`), so no edge's resolution can move because of this function.
+   */
+  resourceClaimMetadata(value, network) {
+    if (network) return { sourcePathClaim: [value] };
+    if (this.claimProjectRoot.length > 0 && HTML_DOCUMENT_EXTS.has(resourceExtension(value))) {
+      const rebased = rebaseToProject(this.claimDocumentPath, this.claimProjectRoot, value);
+      const absCandidate = rebased !== null ? path.join(this.claimProjectRoot, rebased) : null;
+      if (absCandidate !== null && existsSync(absCandidate)) {
+        const size = statSync(absCandidate).size;
+        if (size > 0 && size <= 1048576) return { importProjectFile: [rebased] };
+      }
+    }
+    if (urlScheme(value).length > 0) return { sourcePathClaim: [value] };
+    return {};
+  }
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    this.claimDocumentPath = filePath;
+    this.claimProjectRoot = context?.projectRoot ?? "";
+    const ERROR_REPORT_CAP = 50;
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if ((n.type === "ERROR" || n.isMissing) && errors.length < ERROR_REPORT_CAP) {
+          errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: this.nodeToRange(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    const moduleName = path.basename(filePath, path.extname(filePath)) || "document";
+    const documentRange = this.nodeToRange(rootNode);
+    const usedNames = map();
+    usedNames[moduleName] = 1;
+    symbols.push({
+      name: moduleName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: documentRange,
+      scope: "",
+      visibility: "public",
+      complexity: 0,
+      // filled with the addressable-descendant count below
+      metadata: {
+        htmlSpecific: true,
+        isDocument: true,
+        doctype: this.findDoctype(rootNode),
+        lang: this.documentLanguage(rootNode)
+      }
+    });
+    const handleToSymbol = map();
+    const ambiguousHandles = map();
+    const deferred = [];
+    let totalElements = 0;
+    let semanticCount = 0;
+    let interactiveCount = 0;
+    let formElementCount = 0;
+    let ariaCount = 0;
+    let headingCount = 0;
+    let headingLevelSkips = 0;
+    let imgCount = 0;
+    let imgWithAltCount = 0;
+    let iframeWithoutLoadingCount = 0;
+    const counters = { externalLinkCount: 0, internalLinkCount: 0, labelWithoutFor: 0, inputWithoutLabel: 0 };
+    let baseHrefCount = 0;
+    let branchCount = 0;
+    let maxDepth = 0;
+    let addressableCount = 0;
+    let hasForm = false;
+    let hasExternals = false;
+    let customElementCount = 0;
+    let templateFragmentCount = 0;
+    let lastHeadingLevel = 0;
+    const frameworks = table({ HTML5: true });
+    const insights = map();
+    const stack = [{ node: rootNode, nearestNamed: moduleName, depth: 0 }];
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      const node = frame.node;
+      if (node.type === "element" || node.type === "script_element" || node.type === "style_element") {
+        totalElements++;
+        if (frame.depth > maxDepth) maxDepth = frame.depth;
+        const tagNameNode = this.getElementTagName(node);
+        if (tagNameNode) {
+          const tagName = asciiLower(tagNameNode.text);
+          const { attrs, lines } = this.extractElementAttributes(node);
+          const startTag = this.getStartTag(node);
+          const tagLine = startTag ? startTag.startPosition.row + 1 : node.startPosition.row + 1;
+          const lineOf = (attr) => lines[attr] ?? tagLine;
+          const isSemantic = !!SEMANTIC_ELEMENTS[tagName];
+          const isInteractive = !!INTERACTIVE_ELEMENTS[tagName];
+          const isForm = !!FORM_ELEMENTS[tagName];
+          const isBarrier = !!TEMPLATE_BARRIERS[tagName];
+          if (isSemantic) semanticCount++;
+          if (isInteractive) interactiveCount++;
+          if (isForm) {
+            hasForm = true;
+            formElementCount++;
+          }
+          if (attrs["aria-label"] || attrs["role"] || attrs["aria-labelledby"] || attrs["aria-describedby"]) ariaCount++;
+          if (HEADING_ELEMENTS[tagName]) {
+            headingCount++;
+            const level = Number.parseInt(tagName.slice(1), 10);
+            if (lastHeadingLevel !== 0 && level > lastHeadingLevel + 1) headingLevelSkips += level - lastHeadingLevel - 1;
+            lastHeadingLevel = level;
+          }
+          if (tagName.indexOf("-") !== -1 && tagName !== "annotation-xml") {
+            customElementCount++;
+            insights["Custom-element-shaped tags present (registration is a cross-file fact this analyzer cannot see)"] = true;
+          }
+          if (this.hasDirective(attrs, CONDITIONAL_DIRECTIVE_SUFFIXES) || this.hasDirective(attrs, REPEAT_DIRECTIVE_SUFFIXES)) branchCount++;
+          if (isBarrier) branchCount++;
+          if (attrs["media"]) branchCount++;
+          if (tagName === "picture") branchCount++;
+          const rawId = attrs["id"] ?? "";
+          const rawName = rawId.length > 0 ? "" : attrs["name"] ?? "";
+          const handle = rawId.length > 0 ? rawId : rawName;
+          let currentId = frame.nearestNamed;
+          if (handle.length > 0) {
+            addressableCount++;
+            let symbolName = handle;
+            const seen = usedNames[handle];
+            if (seen === void 0) {
+              usedNames[handle] = 1;
+            } else {
+              let n = seen;
+              do {
+                n++;
+                symbolName = `${handle}#${n}`;
+              } while (usedNames[symbolName] !== void 0);
+              usedNames[symbolName] = 1;
+              usedNames[handle] = n;
+            }
+            if (handleToSymbol[handle] === void 0) {
+              handleToSymbol[handle] = symbolName;
+            } else {
+              ambiguousHandles[handle] = true;
+            }
+            currentId = symbolName;
+            symbols.push({
+              name: symbolName,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.nodeToRange(node),
+              scope: "",
+              // HTML has one scope: a document. There is no private/package/
+              // protected, so `public` is the only truthful value here and it is
+              // pinned by fixture rather than left as an unexamined default.
+              visibility: "public",
+              ownerName: frame.nearestNamed,
+              ownerKind: frame.nearestNamed === moduleName ? ASTEngine.SymbolKind.Module : ASTEngine.SymbolKind.Class,
+              complexity: 1,
+              metadata: {
+                tagName,
+                attributes: attrs,
+                htmlSpecific: true,
+                isAddressable: true,
+                identityAttribute: rawId.length > 0 ? "id" : "name",
+                isSemantic,
+                isInteractive,
+                isForm,
+                ...rawId.length === 0 && rawName.length > 0 ? { alsoNamed: rawName } : {},
+                ...symbolName !== handle ? { duplicateId: true, duplicateOf: handle } : {},
+                ...frame.inBarrier ? { inTemplateBarrier: true } : {},
+                ...attrs["is"] ? { isCustomElement: attrs["is"] } : {}
+              }
+            });
+            if (frame.nearestNamed !== symbolName) {
+              relationships.push({
+                source: frame.nearestNamed,
+                target: symbolName,
+                type: ASTEngine.RelationshipType.Contains,
+                confidence: 1,
+                line_number: this.nodeToRange(node).startLine,
+                metadata: {
+                  htmlSpecific: true,
+                  isDOMHierarchy: true,
+                  evidenceClass: "structural",
+                  ...frame.nearestNamed === moduleName ? { isDocumentRoot: true } : {}
+                }
+              });
+            }
+          }
+          const rules = RESOURCE_RULES[tagName];
+          if (rules) {
+            for (let r = 0; r < rules.length; r++) {
+              const rule = rules[r];
+              const raw = attrs[rule.attr];
+              if (!raw || raw.length === 0) continue;
+              let effectiveType = rule.resourceType;
+              if (rule.relFilter) {
+                const rel = this.fetchableRelToken(attrs["rel"], rule.relFilter);
+                if (rel === null) continue;
+                effectiveType = LINK_RESOURCE_TYPES[rel] ?? rule.resourceType;
+              }
+              if (rule.paramNameFilter && !rule.paramNameFilter[asciiLower(attrs["name"] ?? "")]) continue;
+              if (rule.httpEquiv !== void 0 && asciiLower(attrs["http-equiv"] ?? "") !== rule.httpEquiv) continue;
+              const line = lineOf(rule.attr);
+              const owner = currentId;
+              const attrRange = this.attributeRange(startTag, rule.attr, node, line);
+              if (rule.contentUrl) {
+                const inner = refreshContentUrl(decodeCharacterReferences(raw).trim());
+                if (inner.length === 0) continue;
+                this.countOutcome(
+                  this.emitResource(inner, owner, rule, line, attrRange, relationships, imports, deferred, true),
+                  counters
+                );
+                continue;
+              }
+              if (rule.valueList === "space") {
+                const urls = spaceSeparatedUrls(decodeCharacterReferences(raw));
+                for (let u = 0; u < urls.length; u++) {
+                  this.countOutcome(
+                    this.emitResource(urls[u], owner, rule, line, attrRange, relationships, imports, deferred),
+                    counters
+                  );
+                }
+                continue;
+              }
+              if (rule.candidates === "srcset") {
+                const candidates = srcsetCandidates(raw);
+                for (let c = 0; c < candidates.length; c++) {
+                  this.countOutcome(
+                    this.emitResource(candidates[c], owner, rule, line, attrRange, relationships, imports, deferred),
+                    counters
+                  );
+                }
+                continue;
+              }
+              this.countOutcome(
+                this.emitResource(raw, owner, { ...rule, resourceType: effectiveType }, line, attrRange, relationships, imports, deferred),
+                counters
+              );
+            }
+          }
+          if (tagName === "input" && FORM_ACTION_INPUT_TYPES[asciiLower(attrs["type"] ?? "")]) {
+            const fa = attrs["formaction"];
+            if (fa && fa.length > 0) {
+              this.countOutcome(
+                this.emitResource(
+                  fa,
+                  currentId,
+                  INPUT_FORMACTION_RULE,
+                  lineOf("formaction"),
+                  this.attributeRange(startTag, "formaction", node, lineOf("formaction")),
+                  relationships,
+                  imports,
+                  deferred
+                ),
+                counters
+              );
+            }
+          }
+          if (tagName === "label") {
+            const forAttr = attrs["for"];
+            if (forAttr && forAttr.length > 0) {
+              deferred.push({
+                // THE ELEMENT THAT WRITES THE REFERENCE, not the nearest named
+                // ancestor — `currentId` is the label's OWN handle when it is
+                // addressable (an `id`/`name`) and the ancestor only when it is not.
+                //
+                // This branch used `frame.nearestNamed` unconditionally, and it was
+                // the ONLY one of the four in-document reference emitters that did:
+                // the resource carriers pass `currentId` (`emitResource`'s caller),
+                // the IDREF class passes `currentId` (`owner`), the fragment href in
+                // `emitResource` passes its caller's `source`, and the lane's own F5
+                // oracle `deriveHtmlEdges` passes `next` — which is the element's own
+                // symbol name whenever it has one. MEASURED, both documents through
+                // `deriveHtmlEdges`:
+                //
+                //   scope-barriers-and-references.html (labels `lbl-later`,
+                //     `lbl-above`, `lbl-twin`, each with an id):
+                //     oracle `uses lbl-later -> declared-below`; the analyzer said
+                //     `uses app -> declared-below` — 3 rows, 100% of that file's
+                //     label associations, sourced at the wrong actor.
+                //   idref-carriers.html (`<label id="lbl" for="named-target">`):
+                //     oracle `uses lbl -> named-target`; analyzer `uses app -> ...`.
+                //
+                // A label WITHOUT identity is unaffected: `currentId` is then the
+                // nearest named ancestor, which is what identity-addressable's
+                // `<label for="query">` (no id, inside `#search-form`) pins and what
+                // the oracle also derives (`uses search-form -> query`). So this
+                // changes the actor only where an actor was available to name, and it
+                // is what makes the analyzer agree with its own truth rather than
+                // pinning a divergence in two fixtures.
+                source: currentId,
+                handle: forAttr,
+                kind: "label",
+                rel: "uses",
+                line: lineOf("for")
+              });
+            } else {
+              counters.labelWithoutFor++;
+            }
+          }
+          for (let ir = 0; ir < IDREF_RULES.length; ir++) {
+            const rule = IDREF_RULES[ir];
+            if (rule.tag.length > 0 && rule.tag !== tagName) continue;
+            const raw = attrs[rule.attr];
+            if (raw === void 0 || raw.length === 0) continue;
+            const line = lineOf(rule.attr);
+            const owner = currentId;
+            let start = 0;
+            for (let i = 0; i <= raw.length; i++) {
+              const atEnd = i === raw.length;
+              const c = atEnd ? 32 : raw.charCodeAt(i);
+              if (!(c === 32 || c === 9 || c === 10 || c === 13 || c === 12)) continue;
+              if (i > start) {
+                deferred.push({
+                  source: owner,
+                  handle: raw.slice(start, i),
+                  kind: rule.kind,
+                  rel: "references",
+                  list: rule.list,
+                  line
+                });
+              }
+              start = i + 1;
+            }
+          }
+          if (tagName === "input") {
+            const type = asciiLower(attrs["type"] ?? "text");
+            if (type !== "hidden" && type !== "submit" && type !== "button" && type !== "reset" && type !== "image") {
+              counters.inputWithoutLabel++;
+            }
+          }
+          if (tagName === "base" && attrs["href"]) baseHrefCount++;
+          if (tagName === "iframe" && !attrs["loading"]) iframeWithoutLoadingCount++;
+          if (tagName === "img") {
+            imgCount++;
+            if (attrs["alt"] !== void 0) imgWithAltCount++;
+          }
+          const nextBarrier = isBarrier;
+          const nextNamed = currentId;
+          if (isBarrier) {
+            templateFragmentCount++;
+            const children3 = node.namedChildren;
+            for (let i = children3.length - 1; i >= 0; i--) {
+              const child = children3[i];
+              if (child) {
+                stack.push({
+                  node: child,
+                  nearestNamed: nextNamed,
+                  depth: frame.depth + 1,
+                  inBarrier: true
+                });
+              }
+            }
+            continue;
+          }
+          const children2 = node.namedChildren;
+          for (let i = children2.length - 1; i >= 0; i--) {
+            const child = children2[i];
+            if (child) {
+              stack.push({ node: child, nearestNamed: nextNamed, depth: frame.depth + 1, inBarrier: frame.inBarrier });
+            }
+          }
+          continue;
+        }
+      }
+      const children = node.namedChildren;
+      for (let i = children.length - 1; i >= 0; i--) {
+        const child = children[i];
+        if (child) {
+          stack.push({
+            node: child,
+            nearestNamed: frame.nearestNamed,
+            depth: frame.depth,
+            inBarrier: frame.inBarrier
+          });
+        }
+      }
+    }
+    for (let i = 0; i < deferred.length; i++) {
+      const ref = deferred[i];
+      const target = handleToSymbol[ref.handle];
+      if (target === void 0) continue;
+      if (ref.rel === "references") {
+        relationships.push({
+          source: ref.source,
+          target,
+          type: ASTEngine.RelationshipType.References,
+          confidence: 1,
+          line_number: ref.line,
+          metadata: {
+            htmlSpecific: true,
+            isIdref: true,
+            idrefKind: ref.kind,
+            // Published for the LIST carriers only, never as `idrefList: false`: a
+            // single-valued reference and a one-token list must not read alike, and
+            // the absent/present test is the only one that survives a consumer's
+            // truthiness check (`false` and `undefined` are both falsy).
+            ...ref.list ? { idrefList: true } : {},
+            evidenceClass: "structural",
+            ...ambiguousHandles[ref.handle] ? { ambiguousTarget: true } : {}
+          }
+        });
+        continue;
+      }
+      if (ref.kind === "label") {
+        relationships.push({
+          source: ref.source,
+          target,
+          type: ASTEngine.RelationshipType.Uses,
+          confidence: 1,
+          line_number: ref.line,
+          metadata: {
+            htmlSpecific: true,
+            isLabelAssociation: true,
+            evidenceClass: "structural",
+            ...ambiguousHandles[ref.handle] ? { ambiguousTarget: true } : {}
+          }
+        });
+      } else {
+        relationships.push({
+          source: ref.source,
+          target,
+          type: ASTEngine.RelationshipType.Uses,
+          confidence: 1,
+          line_number: ref.line,
+          metadata: {
+            htmlSpecific: true,
+            isInternalAnchor: true,
+            evidenceClass: "structural",
+            ...ambiguousHandles[ref.handle] ? { ambiguousTarget: true } : {}
+          }
+        });
+      }
+    }
+    this.accumulateSubtreeSizes(symbols);
+    const structural = this.computeScores({
+      totalElements,
+      semanticCount,
+      interactiveCount,
+      formElementCount,
+      ariaCount,
+      headingCount,
+      headingLevelSkips,
+      imgCount,
+      imgWithAltCount,
+      iframeWithoutLoadingCount,
+      labelWithoutForCount: counters.labelWithoutFor,
+      inputWithoutLabelCount: counters.inputWithoutLabel,
+      branchCount,
+      maxDepth,
+      addressableCount,
+      customElementCount,
+      templateFragmentCount
+    });
+    if (addressableCount > 0) insights["Addressable DOM nodes identified by id/name"] = true;
+    if (semanticCount > 0) insights["Well-structured semantic document"] = true;
+    if (ariaCount > 0) insights["Commitment to accessibility detected"] = true;
+    if (headingLevelSkips > 0) insights["Heading levels skip a level"] = true;
+    if (hasExternals) {
+      insights["External resources linked"] = true;
+      let hasExternalScript = false;
+      let hasExternalStyle = false;
+      for (let i = 0; i < imports.length; i++) {
+        if (imports[i].metadata?.isScript) hasExternalScript = true;
+        if (imports[i].metadata?.isStylesheet) hasExternalStyle = true;
+      }
+      if (hasExternalScript) insights["External interactivity linked"] = true;
+      if (hasExternalStyle) insights["External styling linked"] = true;
+    }
+    if (hasForm) insights["Contains user input forms"] = true;
+    if (customElementCount > 0) insights["Custom-element-shaped tags present; registration not observable from this document"] = true;
+    if (templateFragmentCount > 0) insights["Deferred template fragments present"] = true;
+    if (baseHrefCount > 0) insights["Base URL rewrites relative resource resolution"] = true;
+    if (counters.externalLinkCount > 0) insights["Outbound cross-origin navigation (recorded, not graphed)"] = true;
+    const patterns = [];
+    if (hasForm) patterns.push("Form Controls Usage");
+    if (semanticCount > 0) patterns.push("Semantic HTML5 Structure");
+    if (ariaCount > 0) patterns.push("ARIA Accessibility Enhancements");
+    if (addressableCount > 0) patterns.push("Addressable DOM Identity");
+    if (customElementCount > 0) patterns.push("Custom-element-shaped tag usage");
+    const detectedFrameworks = [];
+    for (const f in frameworks) detectedFrameworks.push(f);
+    const architecturalInsights = [];
+    for (const insight in insights) architecturalInsights.push(insight);
+    if (context && Array.isArray(context.htmlEmbeddedTrees) && context.htmlEmbeddedTrees.length > 0) {
+      const unavailable = this.mergeEmbeddedBlocks(context, moduleName, symbols, relationships, imports, exports, errors);
+      if (unavailable.length > 0) this.unavailableEmbeddedLangs = [...new Set(unavailable)].sort();
+    }
+    return {
+      language: "html",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // Structural depth, not a symbol count: `symbols.length` was the pre-fix
+        // value and it is not a complexity measure of anything.
+        complexity: maxDepth + 1,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: 1 + branchCount,
+        elementCount: totalElements,
+        addressableNodeCount: addressableCount,
+        maxElementDepth: maxDepth,
+        framework: "HTML5",
+        patterns,
+        detectedFrameworks,
+        frameworkPatterns: [],
+        architecturalInsights,
+        architecturalScore: structural.architecturalScore,
+        codeQuality: structural.architecturalScore > 80 ? "Excellent" : structural.architecturalScore > 60 ? "Good" : "Fair",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: true,
+        // The three scores are published under engine-forwarded keys AND as
+        // metadata.score, so the numbers survive the engine's metadata literal
+        // instead of being computed and dropped.
+        accessibilityScore: structural.accessibility,
+        semanticScore: structural.semantic,
+        performanceScore: structural.performance,
+        score: structural,
+        analysisVersion: "m14-html-identity-v2",
+        ...this.unavailableEmbeddedLangs.length > 0 ? { unavailableEmbeddedLangs: [...this.unavailableEmbeddedLangs] } : {},
+        documentMetrics: {
+          totalElements,
+          semanticCount,
+          interactiveCount,
+          formElementCount,
+          ariaCount,
+          headingCount,
+          headingLevelSkips,
+          imgCount,
+          imgWithAltCount,
+          iframeWithoutLoadingCount,
+          labelWithoutForCount: counters.labelWithoutFor,
+          inputWithoutLabelCount: counters.inputWithoutLabel,
+          customElementCount,
+          templateFragmentCount,
+          baseHrefCount,
+          // A hyperlink is not a code dependency, so outbound navigation is a
+          // DOCUMENT METRIC rather than 200-odd `uses` edges into a graph whose
+          // every edge is scored for architectural criticality.
+          externalLinkCount: counters.externalLinkCount,
+          internalLinkCount: counters.internalLinkCount
+        }
+      }
+    };
+  }
+  // ==========================================================================
+  // RESOURCE EMISSION
+  // ==========================================================================
+  /**
+   * One fetch/inline-resource edge, or one hyperlink, or nothing.
+   *
+   * Returns what it decided so the caller's document metrics stay exact without
+   * this method needing a reference to them:
+   *   "fetch"        a `uses` edge was emitted for a resource the document loads
+   *   "fragment"     a same-document reference; the caller already deferred it
+   *   "navigation"   an in-project hyperlink/endpoint, emitted as `uses`
+   *   "external"     a cross-origin or non-resource-scheme URL: deliberately
+   *                  NOT graphed (see the header) — the caller counts it
+   *   "script-url"   a `javascript:` URL: a hazard, not a dependency
+   *   "none"         nothing to say
+   *
+   * The decision table:
+   *   - a same-document fragment is NOT a fetch: it is a reference into the
+   *     document's own address space, resolved after the walk (deferred).
+   *   - a non-resource scheme (`mailto:`, `tel:`, `javascript:`, `data:`, …) is
+   *     not a dependency. Decoded BEFORE the scheme test (see the header), so
+   *     `&#106;avascript:` and `&#0000106;avascript:` cannot slip past — the
+   *     pre-fix filter was a bare `startsWith("javascript:")` and missed both,
+   *     AND existed only in the `<a>` branch, so `<form action="javascript:…">`
+   *     emitted a `calls` edge and an `imports` row for one.
+   *   - a network URL is a fetch, but its target is not a project module, so the
+   *     edge is `usage_contextual` and is NOT mirrored into `imports` (mirroring
+   *     it put `https://cdn.example.com/x.js` in brain_import, where every other
+   *     lane's import is a module the index can resolve).
+   *   - anything else is a project-relative module: `import_based`, and mirrored.
+   */
+  emitResource(rawValue, source, rule, line, range, relationships, imports, deferred, alreadyDecoded = false) {
+    const value = (alreadyDecoded ? rawValue : decodeCharacterReferences(rawValue)).trim();
+    if (value.length === 0) return "none";
+    const fragment = fragmentTarget(value);
+    if (value === "#") return "none";
+    if (fragment.length > 0) {
+      if (rule.fragmentRef) {
+        deferred.push({ source, handle: fragment, kind: "anchor", rel: "uses", line });
+        return "fragment";
+      }
+      relationships.push({
+        source,
+        target: value,
+        type: ASTEngine.RelationshipType.Uses,
+        confidence: 1,
+        line_number: line,
+        metadata: {
+          htmlSpecific: true,
+          resourceType: rule.resourceType,
+          isInternalAnchor: true,
+          isUnresolvedFragment: true,
+          evidenceClass: "structural"
+        }
+      });
+      return "fragment";
+    }
+    if (isNonResourceScheme(value)) {
+      if (urlScheme(value) === "javascript") {
+        relationships.push({
+          source,
+          target: "javascript:",
+          type: ASTEngine.RelationshipType.Uses,
+          confidence: 1,
+          line_number: line,
+          metadata: {
+            htmlSpecific: true,
+            resourceType: "javascript-url",
+            isScriptUrl: true,
+            evidenceClass: "usage_contextual"
+          }
+        });
+        return "script-url";
+      }
+      return "external";
+    }
+    const network = isProtocolRelative(value) || isNetworkScheme(value);
+    if (rule.link) {
+      if (network) return "external";
+      relationships.push({
+        source,
+        target: value,
+        type: ASTEngine.RelationshipType.Uses,
+        // 0.9, not 1.0: an observed hyperlink is not a derived fact. The tier
+        // classifier in every other gated lane reads confidence, and a 1.0 here
+        // would claim `structural` for a link that was merely written down.
+        confidence: 0.9,
+        line_number: line,
+        // Honesty contract §4.1: a relationship below 1.0 must carry a
+        // MACHINE-READABLE reason code, and the only justification this tier had
+        // was the comment above. Measured over this lane's corpus (1,185
+        // git-tracked documents, `validation/m14/probes/html/ontology-census.mts`):
+        // 60,285 html-native edges sit at this tier — 59,953 `navigation` and 332
+        // `form-action` — and not one carried a field a consumer or an audit could
+        // read. The code makes the tier machine-checkable without re-reading the
+        // analyzer: a consumer filtering "observed, not derived" reads a field.
+        metadata: {
+          htmlSpecific: true,
+          resourceType: rule.resourceType,
+          isNavigation: rule.navigation === true,
+          // A form endpoint is a dependency on a backend route, which is a
+          // materially different fact from "the user can click away".
+          isFormEndpoint: rule.navigation !== true,
+          evidenceClass: "usage_contextual",
+          confidenceReason: "observed-hyperlink-not-derived",
+          // THE CLAIM, on the channel the arbiter reads. A hyperlink is the largest
+          // unresolved class this lane has (22,260 of 32,656 in the bounded
+          // population) and it was emitted as a bare relative spelling, so the
+          // document that wrote it was the only thing that could answer it.
+          ...this.resourceClaimMetadata(value, false)
+        }
+      });
+      return "navigation";
+    }
+    relationships.push({
+      source,
+      target: value,
+      type: ASTEngine.RelationshipType.Uses,
+      confidence: 1,
+      line_number: line,
+      metadata: {
+        htmlSpecific: true,
+        resourceType: rule.resourceType,
+        isExternalResource: network,
+        evidenceClass: rule.evidenceClass ?? (network ? "usage_contextual" : "import_based"),
+        // Same claim, same keys: a fetch names a FILE (`../styles/main.css`) or a
+        // network URL, and both were published verbatim with no reason attached.
+        ...this.resourceClaimMetadata(value, network)
+      }
+    });
+    if (rule.import && !network) {
+      imports.push({
+        module: value,
+        items: ["*"],
+        isDefaultImport: true,
+        isNamespaceImport: false,
+        range,
+        metadata: { isHtmlResource: true, resourceType: rule.resourceType }
+      });
+    }
+    return "fetch";
+  }
+  /**
+   * Merge the sub-analysed inline blocks into the document's own payload.
+   *
+   * Each block is analysed by the JS/TS/CSS analyzer for its own grammar and the
+   * result is re-based onto the document:
+   *   - a `line_number` and every metadata key whose NAME is a line move by
+   *     `startLine - 1` (the block's first line, 1-based, to file coordinates);
+   *   - a `range`'s startLine/endLine move by the same amount and its
+   *     startIndex/endIndex by the byte offset, because an index-based consumer
+   *     (bb_edit) is misaligned by lines alone;
+   *   - a multi-line block is indented, so the FIRST line needs no column shift
+   *     and the rest need none either — the block's text is copied verbatim from
+   *     the source, so its columns are already the document's;
+   *   - the owner of a delegate symbol with no owner is the DOCUMENT, because a
+   *     top-level `function` in an inline block is a document-scope declaration,
+   *     and `contains` then carries the same line the symbol does.
+   *
+   * Every shifted row is tagged `htmlEmbedded: true` with the block's language
+   * and the offset applied. That tag is what makes the seam falsifiable: a
+   * fixture can assert that an inline script's symbol is on the line it is
+   * written on, and a mutant that drops the shift fails that pin instead of
+   * silently shipping off-by-N lines.
+   */
+  mergeEmbeddedBlocks(context, moduleName, symbols, relationships, imports, exports, errors) {
+    const unavailable = [];
+    const trees = context.htmlEmbeddedTrees ?? [];
+    const langs = context.htmlEmbeddedLangs ?? [];
+    const startLines = context.htmlEmbeddedStartLines ?? [];
+    const startColumns = context.htmlEmbeddedStartColumns ?? [];
+    const startIndices = context.htmlEmbeddedStartIndices ?? [];
+    const delegates = map();
+    const delegateFor = (lang) => {
+      if (delegates[lang] !== void 0) return delegates[lang];
+      let instance = null;
+      try {
+        const mod = lang === "css" ? require2("./real-css-analyzer") : lang === "ts" || lang === "tsx" ? require2("./real-typescript-analyzer") : require2("./real-javascript-analyzer");
+        const cls = lang === "css" ? mod.RealCssAnalyzer : lang === "ts" || lang === "tsx" ? mod.RealTypeScriptAnalyzer : mod.RealJavaScriptAnalyzer;
+        instance = typeof cls === "function" ? new cls() : null;
+      } catch {
+        try {
+          const nodeRequire = createRequire(import.meta.url);
+          const mod = lang === "css" ? nodeRequire("./real-css-analyzer") : lang === "ts" || lang === "tsx" ? nodeRequire("./real-typescript-analyzer") : nodeRequire("./real-javascript-analyzer");
+          const cls = lang === "css" ? mod.RealCssAnalyzer : lang === "ts" || lang === "tsx" ? mod.RealTypeScriptAnalyzer : mod.RealJavaScriptAnalyzer;
+          instance = typeof cls === "function" ? new cls() : null;
+        } catch {
+          instance = null;
+        }
+      }
+      if (instance === null) unavailable.push(lang);
+      delegates[lang] = instance;
+      return instance;
+    };
+    for (let i = 0; i < trees.length; i++) {
+      const tree = trees[i];
+      if (!tree) continue;
+      const lang = langs[i] ?? "js";
+      const lineOffset = (startLines[i] ?? 1) - 1;
+      const byteOffset = startIndices[i] ?? 0;
+      const delegate = delegateFor(lang);
+      if (delegate === null) continue;
+      let sub;
+      try {
+        sub = delegate.analyze(tree.rootNode, "", moduleName);
+      } catch {
+        continue;
+      }
+      for (const s of sub.symbols ?? []) {
+        if (s.range) {
+          s.range = {
+            ...s.range,
+            startLine: s.range.startLine + lineOffset,
+            endLine: s.range.endLine + lineOffset,
+            startIndex: typeof s.range.startIndex === "number" ? s.range.startIndex + byteOffset : s.range.startIndex,
+            endIndex: typeof s.range.endIndex === "number" ? s.range.endIndex + byteOffset : s.range.endIndex
+          };
+        }
+        if (!s.ownerName) {
+          s.ownerName = moduleName;
+          s.ownerKind = ASTEngine.SymbolKind.Module;
+          s.scope = moduleName;
+        }
+        s.metadata = {
+          ...s.metadata ?? {},
+          htmlEmbedded: true,
+          embeddedLang: lang,
+          embeddedLineOffset: lineOffset
+        };
+        symbols.push(s);
+        if (s.ownerName && s.ownerName !== s.name && s.range?.startLine) {
+          relationships.push({
+            source: s.ownerName,
+            target: s.name,
+            type: ASTEngine.RelationshipType.Contains,
+            confidence: 1,
+            line_number: s.range.startLine,
+            metadata: {
+              htmlSpecific: true,
+              isEmbeddedCode: true,
+              // ORIGIN DISCLOSURE (2026-10-05, measured). This row was the ONE
+              // merged row that carried no `htmlEmbedded` tag and no
+              // `embeddedLineOffset`, while the symbols at :1585, the delegate
+              // relationships at :1633 and the imports at :1652 all carried
+              // both. Measured on vuejs through the production path: of 921
+              // delegate rows, 676 carried `htmlEmbedded === true` and 245 did
+              // not — and 245 is the seam-created `contains` class.
+              //
+              // The consequence is not cosmetic. The header of this method
+              // claims "Every shifted row is tagged htmlEmbedded: true"; an
+              // auditor who takes that as the origin test concludes these rows
+              // are html's OWN, which is exactly the delegation question this
+              // lane exists to answer honestly, and gets it backwards for a
+              // quarter of the merged graph. html-origin-census.ts answers the
+              // same question WITHOUT this tag — by differencing the
+              // production path against the seam switched off — and the two
+              // numbers have to agree or one of them is wrong.
+              //
+              // `htmlSpecific: true` on a delegate-created edge is also a lie of
+              // the same shape: the row is not a fact about HTML's grammar, it
+              // is a fact about the javascript inside a `<script>`. It stays,
+              // because it is what tells a consumer the edge arrived through the
+              // html module — but `htmlEmbedded` is what tells them WHERE it was
+              // written, and that was missing.
+              htmlEmbedded: true,
+              embeddedLang: lang,
+              embeddedLineOffset: lineOffset,
+              evidenceClass: "structural"
+            }
+          });
+        }
+      }
+      const delegateBases = /* @__PURE__ */ new Map();
+      for (const r of sub.relationships ?? []) {
+        if (r?.type !== ASTEngine.RelationshipType.Extends) continue;
+        if (typeof r.source === "string" && r.source !== "" && typeof r.target === "string" && r.target !== "") {
+          delegateBases.set(r.source, r.target);
+        }
+      }
+      for (const r of sub.relationships ?? []) {
+        if (r.type === ASTEngine.RelationshipType.Imports) {
+          const mod = r.metadata?.module;
+          if (typeof mod === "string" && mod !== "" && typeof r.target === "string" && r.target !== "" && !r.target.includes(":") && !r.target.includes("/")) {
+            r.target = `${mod}:${r.target}`;
+          }
+        }
+        if (r.type === ASTEngine.RelationshipType.Overrides) {
+          if (typeof r.source === "string" && typeof r.target === "string" && r.target !== "" && !r.target.includes(".")) {
+            const owner = r.source.slice(0, r.source.lastIndexOf("."));
+            const base = owner === "" ? void 0 : delegateBases.get(owner);
+            if (base) r.target = `${base}.${r.target}`;
+          }
+        }
+        if (typeof r.line_number === "number") r.line_number += lineOffset;
+        if (r.metadata) {
+          for (const k of Object.keys(r.metadata)) {
+            if (!asciiLower(k).includes("line")) continue;
+            const v = r.metadata[k];
+            if (typeof v === "number") r.metadata[k] = v + lineOffset;
+            else if (Array.isArray(v) && v.some((x) => typeof x === "number")) {
+              ;
+              r.metadata[k] = v.map((x) => typeof x === "number" ? x + lineOffset : x);
+            }
+          }
+        }
+        if (r.source === DELEGATE_FILE_ACTOR) r.source = moduleName;
+        r.metadata = {
+          ...r.metadata ?? {},
+          htmlEmbedded: true,
+          embeddedLang: lang,
+          embeddedLineOffset: lineOffset
+        };
+        relationships.push(r);
+      }
+      for (const imp of sub.imports ?? []) {
+        if (imp.range) {
+          imp.range = {
+            ...imp.range,
+            startLine: imp.range.startLine + lineOffset,
+            endLine: imp.range.endLine + lineOffset,
+            startIndex: typeof imp.range.startIndex === "number" ? imp.range.startIndex + byteOffset : imp.range.startIndex,
+            endIndex: typeof imp.range.endIndex === "number" ? imp.range.endIndex + byteOffset : imp.range.endIndex
+          };
+        }
+        imp.metadata = { ...imp.metadata ?? {}, htmlEmbedded: true, embeddedLang: lang };
+        imports.push(imp);
+      }
+      for (const e of sub.exports ?? []) {
+        if (e.range) e.range = { ...e.range, startLine: e.range.startLine + lineOffset, endLine: e.range.endLine + lineOffset };
+        if (e.range) {
+          e.range = {
+            ...e.range,
+            startLine: e.range.startLine + lineOffset,
+            endLine: e.range.endLine + lineOffset,
+            startIndex: typeof e.range.startIndex === "number" ? e.range.startIndex + byteOffset : e.range.startIndex,
+            endIndex: typeof e.range.endIndex === "number" ? e.range.endIndex + byteOffset : e.range.endIndex
+          };
+        }
+        e.metadata = { ...e.metadata ?? {}, htmlEmbedded: true, embeddedLang: lang, embeddedLineOffset: lineOffset };
+        exports.push(e);
+      }
+      for (const er of sub.errors ?? []) {
+        if (er.range) {
+          er.range = {
+            ...er.range,
+            startLine: er.range.startLine + lineOffset,
+            endLine: er.range.endLine + lineOffset,
+            startIndex: typeof er.range.startIndex === "number" ? er.range.startIndex + byteOffset : er.range.startIndex,
+            endIndex: typeof er.range.endIndex === "number" ? er.range.endIndex + byteOffset : er.range.endIndex
+          };
+        }
+        er.metadata = { ...er.metadata ?? {}, htmlEmbedded: true, embeddedLang: lang, embeddedLineOffset: lineOffset };
+        errors.push(er);
+      }
+    }
+    return unavailable;
+  }
+  /**
+   * Fold one emission decision into the document metrics. O(1).
+   *
+   * A hyperlink that left the project is COUNTED and not graphed: the pre-fix
+   * analyzer emitted a `uses` edge for every one, so a page linking to fifty
+   * external sites published fifty graph edges that the enrichment pass then
+   * scored for architectural criticality, and the differential could not tell a
+   * CDN dependency from a hyperlink. The count survives in
+   * `documentMetrics.externalLinkCount`, so the information is not lost — it is
+   * where it belongs.
+   */
+  countOutcome(outcome, counters) {
+    if (outcome === "external") counters.externalLinkCount++;
+    else if (outcome === "navigation") counters.internalLinkCount++;
+  }
+  // ==========================================================================
+  // NODE / ATTRIBUTE ACCESS — index cursors, no array mapping, no regex
+  // ==========================================================================
+  /** The element's start_tag or self_closing_tag, or null. */
+  getStartTag(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child?.type === "start_tag" || child?.type === "self_closing_tag") return child;
+    }
+    return null;
+  }
+  getElementTagName(node) {
+    const startTag = this.getStartTag(node);
+    if (!startTag) return null;
+    for (let j = 0; j < startTag.childCount; j++) {
+      const grandChild = startTag.child(j);
+      if (grandChild?.type === "tag_name") return grandChild;
+    }
+    return null;
+  }
+  /**
+   * Attribute map, LOWERCASED KEYS, plus the line each attribute is written on.
+   *
+   * The lowercasing is the whole point and it is the one-line defect that cost
+   * this analyzer its entire graph on any document written in mixed case: the tag
+   * name was lowercased and the attribute name was not, so `<IMG SRC=…>` matched
+   * no rule and produced nothing. HTML attribute names are ASCII
+   * case-INSENSITIVE; the grammar hands them over verbatim.
+   */
+  extractElementAttributes(node) {
+    const attrs = map();
+    const lines = map();
+    const startTag = this.getStartTag(node);
+    if (!startTag) return { attrs, lines };
+    for (let j = 0; j < startTag.childCount; j++) {
+      const attribute = startTag.child(j);
+      if (attribute?.type !== "attribute") continue;
+      let attrName = "";
+      let attrValue = "";
+      let attrLine = attribute.startPosition.row + 1;
+      for (let k = 0; k < attribute.childCount; k++) {
+        const attrChild = attribute.child(k);
+        const t = attrChild?.type;
+        if (t === "attribute_name") {
+          attrName = attrChild.text;
+          attrLine = attrChild.startPosition.row + 1;
+        } else if (t === "quoted_attribute_value" || t === "attribute_value") {
+          const inner = this.findChildByType(attrChild, "attribute_value");
+          attrValue = inner ? inner.text : unquote(attrChild.text);
+        }
+      }
+      if (!attrName) continue;
+      const key = asciiLower(attrName);
+      if (attrs[key] === void 0) {
+        attrs[key] = attrValue;
+        lines[key] = attrLine;
+      }
+    }
+    return { attrs, lines };
+  }
+  /**
+   * The range of ONE attribute of a start_tag, falling back to the element's own
+   * range when the grammar gave us no attribute node for it. O(A) over the
+   * start_tag's children, A = the tag's attribute count.
+   */
+  attributeRange(startTag, attrName, element, line) {
+    if (startTag) {
+      for (let j = 0; j < startTag.childCount; j++) {
+        const attribute = startTag.child(j);
+        if (attribute?.type !== "attribute") continue;
+        for (let k = 0; k < attribute.childCount; k++) {
+          const an = attribute.child(k);
+          if (an?.type === "attribute_name" && asciiLower(an.text) === attrName) {
+            return {
+              startLine: line,
+              startColumn: an.startPosition.column + 1,
+              endLine: an.endPosition.row + 1,
+              endColumn: an.endPosition.column + 1,
+              startIndex: attribute.startIndex,
+              endIndex: attribute.endIndex
+            };
+          }
+        }
+      }
+    }
+    const r = this.nodeToRange(element);
+    r.startLine = line;
+    return r;
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  /** A directive attribute whose NAME ends with one of `suffixes` — the shape
+   *  `v-if` / `ng-repeat` / `:show` / `x-if` all take. Pure-String, O(1) per attr. */
+  hasDirective(attrs, suffixes) {
+    for (const key in attrs) {
+      for (let s = 0; s < suffixes.length; s++) {
+        const suffix = suffixes[s];
+        if (key === suffix) return true;
+        if (key.length > suffix.length + 1 && key.endsWith(suffix) && key.charCodeAt(key.length - suffix.length - 1) === 45) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * The first FETCHABLE token of a `<link rel>` list, or null.
+   *
+   * `rel` is a space-separated token list, not one value: the ubiquitous
+   * `rel="shortcut icon"` is two tokens, and `rel="preconnect stylesheet"` is a
+   * hint plus a real document. Returning the token (rather than a boolean) is
+   * what lets the edge say WHICH kind of link it is.
+   */
+  fetchableRelToken(rel, filter) {
+    if (rel === void 0 || rel.length === 0) return null;
+    const lowered = asciiLower(rel);
+    const n = lowered.length;
+    let start = 0;
+    while (start < n) {
+      while (start < n && isHtmlSpace(lowered.charCodeAt(start))) start++;
+      let end = start;
+      while (end < n && !isHtmlSpace(lowered.charCodeAt(end))) end++;
+      if (end > start) {
+        const token = lowered.slice(start, end);
+        if (filter[token]) return token;
+      }
+      start = end;
+    }
+    return null;
+  }
+  findDoctype(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "doctype") {
+        for (let j = 0; j < c.childCount; j++) {
+          const d = c.child(j);
+          if (d && d.type !== "<!" && d.type !== ">" && d.text.trim().length > 0) {
+            return firstToken(d.text);
+          }
+        }
+        return "html";
+      }
+    }
+    return null;
+  }
+  documentLanguage(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "element") {
+        for (let j = 0; j < c.childCount; j++) {
+          const startTag = c.child(j);
+          if (startTag && (startTag.type === "start_tag" || startTag.type === "self_closing_tag")) {
+            for (let k = 0; k < startTag.childCount; k++) {
+              const a = startTag.child(k);
+              if (a?.type === "attribute") {
+                for (let m = 0; m < a.childCount; m++) {
+                  const an = a.child(m);
+                  if (an?.type === "attribute_name" && asciiLower(an.text) === "lang") {
+                    const inner = this.findChildByType(a, "attribute_value");
+                    return inner ? inner.text : unquote(a.text);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Accumulate each addressable element's addressable-subtree size into its
+   * `complexity`, bottom-up, without an O(depth) walk per node.
+   *
+   * One reverse pass over the emitted symbols: a child's count is added to its
+   * owner's accumulator. O(s) time, O(1) extra space beyond the accumulator map
+   * that the symbol list itself already implies. Symbols whose owner is not in
+   * this file (never, for html — every owner is either the module or another
+   * emitted symbol) simply do not accumulate further.
+   */
+  accumulateSubtreeSizes(symbols) {
+    const totals = map();
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      totals[s.name] = typeof s.complexity === "number" ? s.complexity : 1;
+    }
+    for (let i = symbols.length - 1; i >= 1; i--) {
+      const s = symbols[i];
+      const owner = s.ownerName;
+      if (owner === void 0 || totals[owner] === void 0) continue;
+      totals[owner] += totals[s.name];
+    }
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      s.complexity = totals[s.name] ?? 1;
+    }
+  }
+  // ==========================================================================
+  // SCORING — bounded, monotone, and every input is a MEASURED count
+  // ==========================================================================
+  computeScores(m) {
+    const countable = m.totalElements > 0 ? Math.max(1, m.totalElements - 4) : 1;
+    const semanticRatio = m.semanticCount / countable;
+    let semantic = 50;
+    if (semanticRatio > 0.05) semantic += 20;
+    if (semanticRatio > 0.15) semantic += 20;
+    if (m.headingCount === 0 && m.totalElements > 20) semantic -= 20;
+    let accessibility = 50;
+    if (m.imgCount > 0) {
+      accessibility += Math.round(m.imgWithAltCount / m.imgCount * 30);
+    } else {
+      accessibility += 20;
+    }
+    if (m.ariaCount > 0) accessibility += 10;
+    if (m.headingCount > 0) accessibility += 10;
+    accessibility -= m.headingLevelSkips * 5;
+    accessibility -= Math.min(20, m.labelWithoutForCount * 5);
+    accessibility -= Math.min(20, m.inputWithoutLabelCount);
+    accessibility -= Math.min(15, m.iframeWithoutLoadingCount * 5);
+    let performance = 80;
+    performance -= Math.min(40, m.iframeWithoutLoadingCount * 10);
+    if (m.maxDepth > 30) performance -= 10;
+    performance -= Math.min(10, (m.templateFragmentCount ?? 0) * 2);
+    const architecturalScore = Math.round(
+      (clamp(semantic, 0, 100) + clamp(accessibility, 0, 100) + clamp(performance, 0, 100)) / 3
+    );
+    return {
+      accessibility: clamp(accessibility, 0, 100),
+      semantic: clamp(semantic, 0, 100),
+      performance: clamp(performance, 0, 100),
+      architecturalScore
+    };
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+function clamp(value, lo, hi) {
+  return value < lo ? lo : value > hi ? hi : value;
+}
+export {
+  RealHtmlAnalyzer
+};