@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-xml-analyzer-YL465ZJW.js

@@ -0,0 +1,2405 @@
+import {
+  fileClaimForTarget
+} from "./chunk-EWMWK7WN.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-xml-analyzer.ts
+import { statSync } from "fs";
+import * as path from "path";
+var RealXmlAnalyzer = class _RealXmlAnalyzer {
+  /**
+   * Every node type this analyzer acts on, and why. The F8 completeness gate
+   * compares this against the analyzer's dispatch sites AND against the node
+   * types observed in a real corpus, so a type that appears in the corpus, is
+   * not declared here, and is not a pass-through literal is a red gate.
+   */
+  static DECLARED = {
+    document: "walk root; the root element is reached through the walk",
+    prolog: "container: XMLDecl, doctypedecl and the misc PIs/comments under it are dispatched from here",
+    element: "the document's structural unit: a symbol plus a `contains` edge from its parent element",
+    STag: "start tag: carries the element Name and the Attribute list",
+    EmptyElemTag: "empty tag: carries the element Name and the Attribute list",
+    Name: "the name-bearing leaf for tags, attributes, PIs, DTD declarations and notations",
+    Attribute: "a property of its element, and the source of `references` / `imports` edges for its value",
+    doctypedecl: "a Type symbol naming the DTD, plus its ExternalID import",
+    ExternalID: "a file reference on a doctypedecl, entity or notation \u2014 ONLY when it carries a SystemLiteral",
+    SystemLiteral: "the file path inside a SYSTEM ExternalID",
+    PubidLiteral: "the public identifier inside a PUBLIC ExternalID; a catalogue name, not a path",
+    elementdecl: "a Type symbol for a DTD element declaration; its contentspec is the content model",
+    AttlistDecl: "the element whose attributes are declared here",
+    AttDef: "a Property symbol plus a `contains` edge from the element it is declared for",
+    GEDecl: "a general entity declaration: a Type symbol owned by the DTD, plus its ExternalID import",
+    PEDecl: "a parameter entity declaration: a Type symbol owned by the DTD, plus its ExternalID import",
+    NotationDecl: "a notation declaration: a Type symbol owned by the DTD, plus its ExternalID import",
+    PublicID: "a PUBLIC identifier on a NotationDecl; it names NO file, so it publishes no import",
+    NDataDecl: "the notation an unparsed entity points at: a `contains` edge",
+    contentspec: "the content model of an element declaration; each Name leaf becomes a `contains` edge",
+    NotationType: "the notations an attribute may carry: each Name leaf becomes a `contains` edge",
+    PI: "a processing instruction: a Module symbol owned by its enclosing element",
+    PITarget: "the name-bearing leaf of a PI",
+    StyleSheetPI: "a file reference: the PI spelling the `xml-stylesheet` external token produces",
+    XmlModelPI: "a file reference: the PI spelling the `xml-model` external token produces",
+    PseudoAtt: "a pseudo-attribute of a StyleSheetPI / XmlModelPI",
+    PseudoAttValue: "the value of a pseudo-attribute; `href` is a file path"
+  };
+  /**
+   * Node types the walk deliberately walks THROUGH without acting on them. The
+   * F8 gate requires every observed named type to be in `DECLARED` or here; the
+   * value is the reason, so a pass-through is a decision on record and not a
+   * shrug.
+   */
+  static PASSTHROUGH_LITERALS = {
+    XMLDecl: "`xml` is reserved; version and encoding are not declarations",
+    Comment: "not a declaration",
+    CharData: "text, not a declaration",
+    CData: "text, not a declaration",
+    CDSect: "wrapper around CData",
+    CDStart: "wrapper for `<![CDATA[`",
+    CharRef: "a numeric character reference, not a name",
+    EntityRef: "a USE; the declaration is GEDecl / PEDecl",
+    PEReference: "inside an internal subset a PEReference is a DeclSep \u2014 a separator, not a use",
+    content: "an element's child sequence: walked through so each child element is reached; nothing on it is a name",
+    conditionalSect: "an INCLUDE/IGNORE section inside an internal subset; walked through so the declarations it guards are reached",
+    VersionNum: "the version pseudo-attribute literal inside an XMLDecl, not a name",
+    EncName: "the encoding pseudo-attribute literal inside an XMLDecl, not a name",
+    URI: "the aliased body of a SystemLiteral; the edge target is the enclosing literal, and the LITERAL carries the edge line",
+    _intSubsetItem: "hidden rule; the repeat that carries a subset's declarations and conditional sections",
+    ETag: "the repaired grammar rejects a mismatched end name, so the name adds nothing",
+    AttValue: "read by the Attribute branch",
+    Mixed: "`(#PCDATA|a|b)*` \u2014 the names are read from the Name leaves, not the wrapper",
+    children: "the element content model; its Name leaves are the declarations that matter",
+    Nmtoken: "an enumeration member is a token, not a name",
+    Enumeration: "wrapper over the Nmtokens of a DTD attribute type",
+    StringType: "the literal CDATA, not a name",
+    TokenizedType: "the literal ID / IDREF / \u2026 token, not a name",
+    DefaultDecl: "the literal #REQUIRED / #IMPLIED / #FIXED value, not a name",
+    EntityValue: "an entity's replacement text, not a name"
+  };
+  /**
+   * Namespaces whose members are specification built-ins rather than project
+   * symbols. A `type="xsd:string"` reference is real and is emitted, but it is
+   * marked `resolvable: "builtin"` and never published as a phantom symbol —
+   * recording a `string` symbol that no document in the corpus declares is the
+   * M60.R10 "a value where a name belongs" class of lie.
+   */
+  /**
+   * WHERE A DECLARATION'S NAME ACTUALLY LIVES, per vocabulary.
+   *
+   * In a schema language the DECLARED NAME of a construct is the VALUE of its
+   * `name` attribute, not its tag name: `<xs:complexType name="RootType">`
+   * declares the type `RootType`. An analyzer that publishes the tag name files
+   * every type in a project under one symbol — `xsd:element` alone appears 5,914
+   * times in this corpus — and makes the search a developer actually types,
+   * `bb_search("RootType")`, return nothing at all.
+   *
+   * The rule is gated on the element's EFFECTIVE NAMESPACE and on a DECLARED set
+   * of local names, and both halves are load-bearing:
+   *
+   *   · tag-only gating is wrong, and measurably so. Outside a declaration
+   *     vocabulary 29,196 elements carry a `name` attribute in this corpus and
+   *     nearly all of them are DATA: `<property name="wsdl.dir">`,
+   *     `<target name="client">`, a POM's `<name>` display label. Renaming those
+   *     would publish a data value as a graph symbol.
+   *   · `rng:ref name="…"` is a REFERENCE, not a declaration, so it is
+   *     deliberately absent from the RelaxNG set; and because the value carries
+   *     no prefix the QName pass cannot see it either. That gap is DECLARED here
+   *     rather than left silently open.
+   *
+   * XSLT's local bindings (`xsl:variable`, `xsl:param`, `xsl:with-param`) are
+   * included: they are named, they are scoped to the enclosing template, and the
+   * walk already carries that owner.
+   */
+  static DECLARATION_VOCABULARIES = {
+    "http://www.w3.org/2001/XMLSchema": /* @__PURE__ */ new Set([
+      "element",
+      "attribute",
+      "complexType",
+      "simpleType",
+      "group",
+      "attributeGroup",
+      "notation",
+      "key",
+      "keyref",
+      "unique"
+    ]),
+    "http://relaxng.org/ns/structure/1.0": /* @__PURE__ */ new Set([
+      "grammar",
+      "define",
+      "element",
+      "attribute",
+      "group",
+      "data",
+      "value",
+      "text",
+      "list",
+      "div",
+      "except",
+      "name",
+      "externalRef"
+    ]),
+    "http://www.w3.org/1999/XSL/Transform": /* @__PURE__ */ new Set([
+      "template",
+      "attribute-set",
+      "key",
+      "decimal-format",
+      "character-map",
+      "output",
+      "strip-space",
+      "preserve-space",
+      "variable",
+      "param",
+      "with-param",
+      "function"
+    ]),
+    "http://schemas.xmlsoap.org/wsdl/": /* @__PURE__ */ new Set([
+      "definitions",
+      "binding",
+      "portType",
+      "message",
+      "service",
+      "port",
+      "operation"
+    ])
+  };
+  /**
+   * ATTRIBUTE NAMES whose unprefixed value names a declaration.
+   *
+   * A PREFIX is the primary signal and needs no table: a value written `tns:X`
+   * names a declaration, and the census over 3,000 corpus files puts 14,479 such
+   * occurrences on real naming attributes (`type` 7,770, `ref` 1,903, `base`
+   * 1,608, Spring's `serviceName` 1,526 and `endpointName` 1,516, …). A prefixed
+   * value is a reference wherever it appears.
+   *
+   * An UNPREFIXED value is not, and the first version of this rule treated it as
+   * one, which is the M60.R10 class in reverse: the census counted 9,391 bare
+   * `key="…"` values that are property names, 4,453 `use="optional|required"`,
+   * 1,404 `maxOccurs="unbounded"`, 14,023 `value="…"` and 2,157 `w:val="Normal"`,
+   * and the analyzer published references to names like `unbounded` and `Normal`
+   * that nothing declares as a type. So an unprefixed value is a reference only
+   * on an attribute in this set, and the set is the DECLARATION (this is the
+   * M60.R10 target-spelling register, per-vocabulary, with the census above as
+   * its evidence).
+   */
+  static REFERENCE_ATTRIBUTES = /* @__PURE__ */ new Set([
+    // XSD 1.0 §4.2 / §3.4.3 / §3.4.4 — the four attributes whose value is a type
+    // or element reference by definition.
+    "type",
+    "base",
+    "ref",
+    "itemType",
+    "memberTypes",
+    "substitutionGroup",
+    "refer",
+    // WSDL 1.1 §3.5 / §3.6, and the SOAP binding's own reference attributes.
+    "portType",
+    "binding",
+    // RelaxNG: a `name` on a `ref` names another pattern, not this one. The
+    // DECLARING uses of `name` (`rng:element`, `rng:attribute`) are handled by
+    // the declared-name rule and must not also become references, which is why
+    // `name` is NOT in this set and `rng:ref` is named explicitly below.
+    "pattern"
+  ]);
+  /**
+   * XSLT and RelaxNG name ONE construct by an attribute the generic set cannot
+   * carry, because the attribute is `name` and `name` is a DECLARATION on every
+   * sibling construct. Declared explicitly for that reason, and each is pinned by
+   * a fixture with its sibling case pinned the other way.
+   *
+   * `call-template` WAS here and was removed, and the removal is the M60
+   * ontology finding rather than a tidiness change. XSLT 1.0 §6 Named Templates
+   * is unambiguous about the construct:
+   *
+   *     "An xsl:call-template element INVOKES A TEMPLATE BY NAME; it has a
+   *      required name attribute that identifies the template to be invoked."
+   *
+   * and a named template is the only procedure the XML family has: it takes
+   * parameters (§11.6), is invoked by name, and returns a result tree fragment.
+   * Labelling that edge `references` says the document MENTIONS a name, when the
+   * document says it CALLS one — a `calls` edge existed in the ontology and the
+   * vocabulary was withholding it. So `call-template` emits `calls` (see
+   * `XSLT_CALL_ELEMENTS`), and `apply-templates` stays a `references` edge
+   * because XSLT 1.0 §5.4 gives `xsl:apply-templates` NO `name` attribute at
+   * all — §6 says so outright: "the name attribute on an xsl:template element
+   * does not affect whether the template is invoked by an xsl:apply-templates
+   * element". A dispatch by pattern and mode is not a call.
+   */
+  static NAMED_REFERENCE_ELEMENTS = {
+    "http://www.w3.org/1999/XSL/Transform": /* @__PURE__ */ new Set(["apply-templates"]),
+    "http://relaxng.org/ns/structure/1.0": /* @__PURE__ */ new Set(["ref"])
+  };
+  /**
+   * The XSLT instructions whose `name` attribute names a template that is
+   * INVOKED, which is a `calls` edge and not a `references` one.
+   *
+   * `xsl:call-template` is the whole list, and deliberately so. `xsl:apply-imports`
+   * (§5.6) invokes the rule a stylesheet overrides, but it names it by nothing —
+   * it takes no `name` — so there is no edge to write. `xsl:apply-templates`
+   * dispatches by pattern and mode and, in XSLT 1.0, carries no `name`.
+   */
+  static XSLT_CALL_ELEMENTS = /* @__PURE__ */ new Set(["call-template"]);
+  /**
+   * XSLT names a template at its definition and calls it by that name, so `name`
+   * on these two is a REFERENCE to a declaration elsewhere in the same document.
+   * The QName pass cannot see it: the value carries no prefix, so it is not a
+   * QName. Declared explicitly, for the same reason.
+   */
+  static XSLT_NAMED_TEMPLATE_REFERENCES = /* @__PURE__ */ new Set([
+    "call-template",
+    "apply-templates"
+  ]);
+  /**
+   * The M14 Matrix 1d evidence tier for each edge CLASS, assigned where the edge
+   * is written so a tier cannot drift from the rule that produced it.
+   *
+   *   structural         the parent/child or declaration/member relation is READ
+   *                       off the tree — the fact needs nothing outside the file
+   *   import_based       the target is a FILE, taken from a path the document
+   *                       itself writes
+   *   reference_qualified the target is a NAME reached through a declared
+   *                       namespace prefix, or an XSLT named template reached by
+   *                       its declared name
+   *   usage_contextual   a containment the document states through an attribute
+   *                       rather than through nesting — the DTD content model and
+   *                       the NOTATION attribute type, which are the document
+   *                       saying what an element MAY contain
+   *   inferred           the edge is a reading the analyzer supplies and the
+   *                       document does not state outright
+   *
+   * XML emitted no tier at all before this, so the lane's Matrix 1d cell was
+   * silent; the completeness gate's section D now pins four of the five.
+   */
+  static EVIDENCE_TIER = {
+    xml_element: "structural",
+    xml_attribute: "structural",
+    xml_namespace: "structural",
+    dtd_element_declaration: "structural",
+    dtd_attribute_declaration: "structural",
+    dtd_content_model: "usage_contextual",
+    dtd_notation_reference: "usage_contextual",
+    // NOT `structural`, and the containment ledger is what moved it. XML 1.0 §4.5
+    // writes the clause as "NDATA NotationName", naming a notation that the DTD
+    // declares ELSEWHERE — and necessarily EARLIER, so the notation's declaration is
+    // never inside the entity's. Measured over the full 11,464-file admitted
+    // population: 2 edges, `libxslt/tests/general/bug-21-.xml` (`<!ENTITY test SYSTEM
+    // "test.jpg" NDATA JPEG>` with `<!NOTATION JPEG …>` at 96-130 and the entity at
+    // 131-174) and `libxslt/tests/general/bug-52.xml`, and in both the target's span lies
+    // entirely BEFORE the source's. A `structural` tier is a claim that nesting was
+    // observed, and no nesting was; `usage_contextual` already defines this exact shape
+    // one row up — "a containment the document states through an attribute rather than
+    // through nesting" — and the DTD content model is its precedent. Two edges is not
+    // worth a new relationship type, and relabelling them `references` would be worse:
+    // `references` resolution has four classes and this construct is not one of them.
+    dtd_ndata_notation: "usage_contextual",
+    dtd_entity_declaration: "structural",
+    dtd_parameter_entity_declaration: "structural",
+    dtd_notation_declaration: "structural",
+    processing_instruction: "structural",
+    pseudo_attribute: "structural",
+    doctype_external_id: "import_based",
+    entity_external_id: "import_based",
+    parameter_entity_external_id: "import_based",
+    notation_external_id: "import_based",
+    processing_instruction_href: "import_based",
+    schema_location: "import_based",
+    attribute_qname_reference: "reference_qualified",
+    // An XSLT named template INVOKED by name. `reference_qualified` because the
+    // document names its target — that is what makes the call resolvable — and
+    // not `structural`, because the tree says nothing about which template an
+    // instruction invokes until the name is read.
+    xslt_named_template_call: "reference_qualified",
+    // XSD type derivation, `xs:extension`/`xs:restriction` `base=`. `structural`:
+    // the vocabulary element IS the declaration of the relation, so the fact needs
+    // nothing outside the file, exactly as a parent/child edge does.
+    xsd_derivation_base: "structural",
+    // XSLT 1.0 §5.5 competing template rules. `structural`, not `inferred`: both
+    // declarations and the three attributes that make them compete are read straight
+    // off the tree, and the only thing the spec contributes is WHICH of two colliding
+    // declarations wins — a direction, recorded in `metadata.derivation`, not a guess
+    // about whether the relation exists. Leaving this role unmapped let `addRelationship`
+    // label every one of these edges `inferred`, which is the tier the ontology census
+    // counts as heuristic: a deterministic parse fact filed as a guess, and the census
+    // row `tier inferred = 0` would have become false without anything changing in the
+    // analyzer's behaviour.
+    xslt_competing_template_rule: "structural",
+    // An entity use is reached through a NAME in the document's own DTD, not
+    // through a declared namespace prefix — but it is a reference to a
+    // declaration all the same, and `usage_contextual` would say the document is
+    // only *using* the entity, which understates it: `&logo;` in content means the
+    // element's value IS that entity's replacement text. `reference_qualified` is
+    // the same claim an XSLT named-template call makes.
+    entity_reference: "reference_qualified",
+    xslt_named_template_reference: "reference_qualified",
+    // An XInclude directive. `import_based` is the tier for a FILE inclusion
+    // directive (the same tier cpp's `#include`, fsharp's `#load` and erlang's
+    // `-include` carry): the clause names another FILE, and the fact
+    // needs nothing outside the file to be read — but it is not a symbol
+    // reference, because the target is a file, not a declaration.
+    xinclude_part: "import_based",
+    // XSLT's `<xsl:include href>` — the SAME inclusion contract in the stylesheet
+    // vocabulary (XSLT 1.0 §2.6.1: the included stylesheet's content is treated as
+    // if it were written at the include's position), so the same tier.
+    xslt_include_part: "import_based",
+    // XSD definition composition: `<xs:group ref="G"/>` / `<xs:attributeGroup ref="G"/>`
+    // inside a type composes G's definitions into THIS type with no base and no
+    // conformance declared. `reference_qualified` because the document names the
+    // composed definition — the same reading a QName reference gets — and the
+    // relation the edge asserts (composition into this type) is decided by the
+    // vocabulary construct, not inferred.
+    xsd_definition_composition: "reference_qualified",
+    // XSLT's `<xsl:import href>` — a MODULE import with import precedence
+    // (XSLT 1.0 §2.6.2), not a textual splice: the imported definitions are in
+    // scope but may be overridden by the importing stylesheet's own. That is the
+    // `imports` relation, and it shares `imports`' tier.
+    xslt_stylesheet_import: "import_based"
+  };
+  /**
+   * THE XINCLUDE NAMESPACE — the W3C XML Inclusions vocabulary (XInclude 1.0,
+   * https://www.w3.org/TR/xinclude/).
+   *
+   * This is the only XML construct that says "splice the named document's content
+   * INTO this one at this point". It is identified by NAMESPACE, never by the
+   * written prefix: `xi` is a convention, not syntax, and a document may bind the
+   * vocabulary to any prefix or to the default namespace. The analyzer already
+   * resolves the element's effective namespace from the document's own `xmlns`
+   * declarations (`rememberNamespaces`), so the test is on that URI.
+   */
+  static XINCLUDE_NAMESPACE = "http://www.w3.org/2001/XInclude";
+  static BUILTIN_NAMESPACE_URIS = /* @__PURE__ */ new Set([
+    "http://www.w3.org/2001/XMLSchema",
+    "http://www.w3.org/XML/1998/namespace"
+  ]);
+  /**
+   * The five entities XML declares in EVERY document (XML 1.0 §4.6, "Entity
+   * declarations"), whether or not a DTD mentions them.
+   *
+   * The same shape of knowledge as `BUILTIN_NAMESPACE_URIS` above and the
+   * spec-bound prefixes below it, and needed for the same reason: the grammar
+   * reports each of them as an `EntityRef`, and a pass with only "declared or
+   * not" answers has to call all of them undefined. A document containing
+   * `&lt;` is well-formed in every conforming parser, so `unresolved` on it is
+   * not a cautious reading — it is a false claim about the document.
+   *
+   * Deliberately exactly five. `&nbsp;`, `&mdash;` and the rest of the HTML
+   * entity set are NOT predefined; an XML document that uses one without
+   * declaring it really does reference something undefined, and that stays
+   * `unresolved`.
+   */
+  static PREDEFINED_ENTITIES = /* @__PURE__ */ new Set([
+    "lt",
+    "gt",
+    "amp",
+    "apos",
+    "quot"
+  ]);
+  /**
+   * The two prefixes the Namespaces specification binds in EVERY document,
+   * whether or not the document says so (XML Namespaces 1.0 §4, and the
+   * Namespaces in XML 1.1 §2.2 which makes it a namespace name rather than a
+   * reserved prefix). Neither may be declared to anything else: re-binding `xml`
+   * is an error, and `xmlns` is bound to the XMLNS namespace.
+   *
+   * This table exists because a well-formed document CANNOT supply them, so a
+   * resolver that only reads declarations can never resolve them. See M60 X8.
+   */
+  /**
+   * The XML Schema built-in DERIVED types, from Part 2's own list. Written out
+   * rather than derived, because the analyzer and the corpus oracle each keep
+   * their own copy ON PURPOSE: two implementations that share a constant cannot
+   * disagree, and a constant that cannot be disagreed with cannot find a defect.
+   */
+  static XSD_BUILTIN_TYPE_NAMES = /* @__PURE__ */ new Set([
+    "anyType",
+    "anySimpleType",
+    "string",
+    "boolean",
+    "decimal",
+    "float",
+    "double",
+    "duration",
+    "dateTime",
+    "time",
+    "date",
+    "gYearMonth",
+    "gYear",
+    "gMonthDay",
+    "gDay",
+    "gMonth",
+    "hexBinary",
+    "base64Binary",
+    "anyURI",
+    "QName",
+    "NOTATION",
+    "normalizedString",
+    "token",
+    "language",
+    "NMTOKEN",
+    "NMTOKENS",
+    "Name",
+    "NCName",
+    "ID",
+    "IDREF",
+    "IDREFS",
+    "ENTITY",
+    "ENTITIES",
+    "integer",
+    "nonPositiveInteger",
+    "negativeInteger",
+    "long",
+    "int",
+    "short",
+    "byte",
+    "nonNegativeInteger",
+    "unsignedLong",
+    "unsignedInt",
+    "unsignedShort",
+    "unsignedByte",
+    "positiveInteger",
+    "dateTimeStamp",
+    "dayTimeDuration",
+    "yearMonthDuration",
+    "lang",
+    "space",
+    "base",
+    "id"
+  ]);
+  static IMPLICIT_PREFIX_BINDINGS = {
+    xml: "http://www.w3.org/XML/1998/namespace",
+    xmlns: "http://www.w3.org/2000/xmlns/"
+  };
+  /**
+   * THE LANE'S OWN FILE VOCABULARY, as ONE set with two readers — the two halves of the imports
+   * file claim must not be able to disagree about what a file of this lane is.
+   *
+   * The router maps exactly these seven extensions to language `xml`
+   * (`src/ast/language-detection.ts:197`, the M60 XML lane comment above it), the incoming gate's
+   * lane definition admits exactly these (`script/m14/incoming-gate.ts` LANES_B). The POSITIVE half
+   * of the claim passes them to `fileClaimForTarget` as the admitted set; the NEGATIVE half requires
+   * a bare target to end in one of them before it will call the target a file. A second spelling of
+   * the list in the same file would be a second rule, and the copy that drifted would be the one
+   * that mattered.
+   */
+  static IMPORT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+    "xml",
+    "xsd",
+    "dtd",
+    "svg",
+    "xsl",
+    "xslt",
+    "rng"
+  ]);
+  /**
+   * Transient per-attribute context, set by the element branch before its
+   * attributes run. `bareNameReference` — the element is one that NAMES another
+   * declaration rather than being one (XSLT `call-template`, RelaxNG `ref`).
+   * `bareNameDeclarationElement` — the element DECLARES through `name`
+   * (RelaxNG `element`, `attribute`), so its `name` is a declaration and must not
+   * also become a reference to itself.
+   */
+  bareNameReference = false;
+  bareNameDeclarationElement = false;
+  /**
+   * The project's placeholder for an endpoint that could not be determined. Named
+   * here rather than inlined so the refusal that uses it and the census that checks
+   * it are reading the same string.
+   */
+  static PLACEHOLDER_LITERAL = "unknown";
+  /** `xsl:call-template`: its `name` attribute names a template it INVOKES. */
+  xsltCallElement = false;
+  /** An XSD `extension`/`restriction`: its `base` attribute names a SUPERtype. */
+  xsdDerivationElement = false;
+  derivationKind = "extension";
+  analyze(rootNode, content, filePath, context) {
+    this.bareNameReference = false;
+    this.bareNameDeclarationElement = false;
+    this.xsltCallElement = false;
+    this.xsdDerivationElement = false;
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const errors = [];
+    const seenRelationships = /* @__PURE__ */ new Map();
+    const publishedNames = /* @__PURE__ */ new Set();
+    const namespaceBindings = /* @__PURE__ */ new Map();
+    const bindingScopes = [];
+    const declaredNames = /* @__PURE__ */ new Set();
+    const importedNamespaces = /* @__PURE__ */ new Map();
+    const referenceCandidates = [];
+    const callCandidates = [];
+    const derivationCandidates = [];
+    const compositionCandidates = [];
+    const declaredTemplateNames = /* @__PURE__ */ new Set();
+    const competingTemplates = [];
+    const entityReferenceCandidates = [];
+    const parameterEntityReferences = [];
+    const shadowCandidates = [];
+    let errorNodes = 0;
+    let missingNodes = 0;
+    let documentElementName;
+    const publish = (symbol, identity) => {
+      symbols.push(symbol);
+      if (identity) publishedNames.add(identity);
+      return symbol;
+    };
+    const addRelationship = (source, target, type, metadata, targetNode) => {
+      if (!source || !target) return;
+      if (type === ASTEngine.RelationshipType.References) {
+        if (source === target) return;
+      }
+      const key = `${source}\0${type}\0${target}`;
+      const line = targetNode ? targetNode.startPosition.row + 1 : void 0;
+      const role = metadata.role;
+      const existing = seenRelationships.get(key);
+      if (existing) {
+        existing.metadata.occurrences = (existing.metadata.occurrences ?? 1) + 1;
+        if (role && role !== existing.metadata.role) {
+          const also = existing.metadata.alsoRoles ?? [];
+          if (!also.includes(role)) also.push(role);
+          existing.metadata.alsoRoles = also;
+          const tiers = existing.metadata.alsoRoleTiers ?? [];
+          if (!tiers.some((t) => t.role === role)) {
+            tiers.push({ role, tier: _RealXmlAnalyzer.EVIDENCE_TIER[role] ?? "inferred" });
+          }
+          existing.metadata.alsoRoleTiers = tiers;
+        }
+        const lines = existing.metadata.lines ?? (existing.line_number !== void 0 ? [existing.line_number] : []);
+        if (line !== void 0) {
+          if (!lines.includes(line)) lines.push(line);
+          if (existing.line_number === void 0 || line < existing.line_number) {
+            existing.line_number = line;
+            existing.metadata.line = line;
+          }
+        }
+        lines.sort((a, b) => a - b);
+        existing.metadata.lines = lines;
+        return;
+      }
+      const relationship = {
+        source,
+        target,
+        type,
+        confidence: 1,
+        line_number: line,
+        // M14 Matrix 1d: the tier is a property of the RULE that produced the
+        // edge, so it is stamped from a table keyed by that rule's role and an
+        // unrecognised role is `inferred` — which is the honest default, because
+        // a tier nobody can name is a reading the analyzer supplies rather than
+        // one the document states.
+        metadata: { ...metadata, occurrences: 1, evidenceClass: role && _RealXmlAnalyzer.EVIDENCE_TIER[role] || "inferred" }
+      };
+      seenRelationships.set(key, relationship);
+      relationships.push(relationship);
+    };
+    const ensureTargetSymbol = (name, ownerName, kind, node, metadata) => {
+      if (!name || !node) return name;
+      if (declaredNames.has(name)) return name;
+      const identity = ownerName ? `${ownerName}\0${name}` : name;
+      if (publishedNames.has(identity)) return name;
+      publish(
+        {
+          name,
+          kind,
+          range: this.nodeToRange(node),
+          visibility: "public",
+          ownerName,
+          ownerKind: ownerName ? ASTEngine.SymbolKind.Type : void 0,
+          qualifiedName: ownerName ? `${ownerName}.${name}` : name,
+          metadata: { ...metadata, nodeType: node.type }
+        },
+        identity
+      );
+      declaredNames.add(name);
+      return name;
+    };
+    const work = [{ node: rootNode }];
+    while (work.length > 0) {
+      const { node, ownerName, dtdName, bindDepth, nearestNamedDeclaration } = work.pop();
+      while (bindingScopes.length > (bindDepth ?? 0)) {
+        const scope = bindingScopes.pop();
+        namespaceBindings.clear();
+        for (const [k, v] of scope.outer) namespaceBindings.set(k, v);
+      }
+      if (node.isMissing) {
+        missingNodes++;
+        continue;
+      }
+      if (node.isError) errorNodes++;
+      if (node.type === "element") {
+        const tagNode = this.findDirectChild(node, "STag") || this.findDirectChild(node, "EmptyElemTag");
+        const nameNode = tagNode ? this.findDirectChild(tagNode, "Name") : null;
+        const name = nameNode?.text.trim();
+        if (name && tagNode) {
+          bindingScopes.push({ outer: new Map(namespaceBindings) });
+          this.rememberNamespaces(tagNode, namespaceBindings);
+          const colon = name.indexOf(":");
+          const prefix = colon >= 0 ? name.slice(0, colon) : "";
+          const localName = colon >= 0 ? name.slice(colon + 1) : name;
+          const effectiveNamespace = namespaceBindings.get(prefix) ?? (colon < 0 ? namespaceBindings.get("") : void 0);
+          const declaration = this.declaredNameOf(effectiveNamespace, localName, tagNode);
+          const declaredName = declaration?.name;
+          const symbolName = declaredName ?? name;
+          if (prefix.length > 0 && namespaceBindings.has(prefix)) {
+            addRelationship(symbolName, prefix, ASTEngine.RelationshipType.Uses, {
+              role: "xml_namespace_prefix_use",
+              namespaceUri: namespaceBindings.get(prefix),
+              resolvable: "in-document"
+            }, nameNode);
+          }
+          const isNamedVocabularyDeclaration = effectiveNamespace !== void 0 && _RealXmlAnalyzer.DECLARATION_VOCABULARIES[effectiveNamespace]?.has(localName) === true && declaredName !== void 0;
+          const namedDeclarationForChildren = isNamedVocabularyDeclaration ? symbolName : nearestNamedDeclaration;
+          const elementSymbol = {
+            name: symbolName,
+            kind: ASTEngine.SymbolKind.Class,
+            // M19 (master review, 2026-09-29): a VOCABULARY DECLARATION is written
+            // on its `name=` attribute, not on the tag that opens it, and the two
+            // are routinely on DIFFERENT LINES. Measured over the 2,500-file
+            // blast radius: 4 of 19,852 declarations reported the tag's line, so
+            // a search for the symbol landed on `<xsl:with-param` rather than on
+            // `name="content"` a line below. The symbol's range therefore starts
+            // at the ATTRIBUTE, while `elementRange` below keeps the structural
+            // span so a reader can still find the element itself. Before this the
+            // two readings shared one field and one of them had to be wrong.
+            //
+            // M60 (containment ledger, 2026-10-04): the ANCHOR is right about the
+            // line and wrong about the SPAN, and the span is what `contains` is made
+            // of. Anchoring the same-line case to the `name=` Attribute put the
+            // declaration's range INSIDE its own element, so
+            //
+            //   <define name="boolean">      symbol `boolean` @ name="boolean"
+            //     <choice>                   symbol `choice`  @ <choice>…</choice>
+            //
+            // produced the edge `boolean -contains-> choice` — which is TRUE — with a
+            // target that is not inside the source, and the attribute symbol `name`
+            // occupied the identical byte range as the declaration itself.
+            // Measured over 300 corpus files: 194 contains edges unverifiable by span
+            // nesting because two names shared one range, and 280 more whose source
+            // span did not enclose a child the source really does contain. Both are
+            // invisible to a resolution rate, which is 100 % on this type.
+            //
+            // So the all-on-one-line case anchors to the ELEMENT, and the reported LINE
+            // cannot move, because that is exactly the condition under which the
+            // element's row and the attribute's row are the same row. The other two
+            // shapes keep the Attribute / AttValue anchor and M19 exactly as measured —
+            // at the cost of leaving their containment unverifiable, which is 4 of
+            // 19,852 declarations and is declared rather than rounded away.
+            range: declaration ? this.nodeToRange(declaration.allOnOneLine ? node : declaration.nameNode) : this.nodeToRange(node),
+            visibility: "public",
+            ownerName,
+            ownerKind: ownerName ? ASTEngine.SymbolKind.Class : void 0,
+            qualifiedName: ownerName ? `${ownerName}.${symbolName}` : symbolName,
+            metadata: {
+              nodeType: "element",
+              isXmlElement: true,
+              tagName: name,
+              isSchemaConstruct: this.isSchemaConstruct(name),
+              // The DECLARED name, when the vocabulary puts it in the `name`
+              // attribute. `tagName` stays the tag, so the structural reading is
+              // carried rather than overwritten.
+              ...declaration ? { isVocabDeclaration: true, declaredName: declaration.name, declarationKind: localName, declaredByAttribute: declaration.attribute, namespaceUri: effectiveNamespace, elementRange: this.nodeToRange(node) } : {}
+            }
+          };
+          publish(elementSymbol, ownerName ? `${ownerName}\0${symbolName}` : symbolName);
+          declaredNames.add(symbolName);
+          if (documentElementName === void 0 && ownerName === void 0) documentElementName = symbolName;
+          const isXIncludeElement = effectiveNamespace === _RealXmlAnalyzer.XINCLUDE_NAMESPACE && localName === "include";
+          const isXsltIncludeElement = effectiveNamespace === "http://www.w3.org/1999/XSL/Transform" && localName === "include";
+          const isXsltImportElement = effectiveNamespace === "http://www.w3.org/1999/XSL/Transform" && localName === "import";
+          if (isXIncludeElement || isXsltIncludeElement) {
+            const hrefAttr = this.findDirectAttribute(tagNode, "href");
+            const hrefPath = (this.attributeValueOf(tagNode, "href") ?? "").trim();
+            if (hrefAttr && hrefPath.length > 0 && !this.isRemoteUri(hrefPath)) {
+              const partSymbol = _RealXmlAnalyzer.includedModuleStem(hrefPath);
+              if (partSymbol.length > 0) {
+                addRelationship(documentElementName ?? symbolName, partSymbol, ASTEngine.RelationshipType.PartOf, {
+                  // The VOCABULARY rides on the role, so a consumer can tell the two
+                  // inclusion channels apart without re-deriving namespace bindings.
+                  role: isXIncludeElement ? "xinclude_part" : "xslt_include_part",
+                  // Mandatory, per `src/ast/types.ts` — see the block above.
+                  partRole: "library",
+                  // THE PATH IS EVIDENCE, THE STEM IS THE TARGET. Keeping both is
+                  // what makes the difference checkable instead of inferred.
+                  partPath: hrefPath,
+                  partSymbol,
+                  // XInclude alone can spell a TEXT inclusion; XSLT's include is
+                  // always a parsed stylesheet, so the field is present only where
+                  // the vocabulary gives it a value.
+                  ...isXIncludeElement ? { parseMode: (this.attributeValueOf(tagNode, "parse") ?? "") === "text" ? "text" : "xml" } : {},
+                  // The written element, so the construct is identified on the row
+                  // without the consumer having to know the namespace URI.
+                  elementName: name,
+                  isFileInclusion: true,
+                  // A part is NOT an import (the contract keeps them distinct): the
+                  // included content does not create an import binding, it becomes
+                  // this document's content.
+                  isImport: false
+                }, this.findDirectChild(hrefAttr, "AttValue"));
+              }
+            }
+          } else if (isXsltImportElement) {
+            const hrefAttr = this.findDirectAttribute(tagNode, "href");
+            const hrefPath = (this.attributeValueOf(tagNode, "href") ?? "").trim();
+            if (hrefAttr && hrefPath.length > 0 && !this.isRemoteUri(hrefPath)) {
+              addRelationship(documentElementName ?? symbolName, hrefPath, ASTEngine.RelationshipType.Imports, {
+                role: "xslt_stylesheet_import",
+                attributeName: "href",
+                // A module import, and the row says so rather than leaving a consumer
+                // to infer it from the element name.
+                importKind: "stylesheet",
+                resolvable: this.importTargetClass(hrefPath)
+              }, this.findDirectChild(hrefAttr, "AttValue"));
+            }
+          }
+          if (declaration && effectiveNamespace === "http://www.w3.org/1999/XSL/Transform" && localName === "template") {
+            declaredTemplateNames.add(symbolName);
+          }
+          if (effectiveNamespace === "http://www.w3.org/1999/XSL/Transform" && localName === "template") {
+            const matchAttr = this.findDirectAttribute(tagNode, "match");
+            if (matchAttr) {
+              const matchValue = this.attributeValueOf(tagNode, "match") ?? "";
+              const modeValue = this.attributeValueOf(tagNode, "mode") ?? "";
+              const priorityValue = this.attributeValueOf(tagNode, "priority") ?? "";
+              competingTemplates.push({
+                key: `${matchValue}|${modeValue}|${priorityValue}`,
+                declaredName: declaration ? symbolName : "",
+                match: matchValue,
+                mode: modeValue,
+                priority: priorityValue,
+                node,
+                anchorNode: matchAttr,
+                ownerName
+              });
+            }
+          }
+          if (ownerName) {
+            addRelationship(ownerName, symbolName, ASTEngine.RelationshipType.Contains, {
+              role: "xml_element",
+              ...declaration ? { tagName: name, declarationKind: localName } : {}
+              // M60 requires the edge's line to be the line the TARGET NAME is
+              // written on, and `addRelationship` already takes that node for
+              // exactly this reason (M59.A7). This call site was passing the
+              // ELEMENT, so a multi-line declaration pointed one line too high.
+            }, declaration ? declaration.nameNode : node);
+          }
+          for (let i = 0; i < tagNode.namedChildCount; i++) {
+            const child = tagNode.namedChild(i);
+            if (!child || child.type !== "Attribute") continue;
+            this.extractAttribute(
+              child,
+              symbolName,
+              symbols,
+              addRelationship,
+              publishedNames,
+              declaredNames,
+              namespaceBindings,
+              referenceCandidates,
+              ensureTargetSymbol,
+              localName,
+              effectiveNamespace,
+              callCandidates,
+              derivationCandidates,
+              compositionCandidates,
+              ownerName,
+              nearestNamedDeclaration,
+              isNamedVocabularyDeclaration ? symbolName : void 0
+            );
+          }
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child && child !== tagNode) work.push({ node: child, ownerName: symbolName, dtdName, bindDepth: bindingScopes.length, nearestNamedDeclaration: namedDeclarationForChildren });
+          }
+          continue;
+        }
+      }
+      if (node.type === "doctypedecl") {
+        const nameNode = this.findDirectChild(node, "Name");
+        const positionedName = this.isPositionedDeclarationName(node, nameNode) ? nameNode.text.trim() : void 0;
+        const currentDtdName = positionedName || dtdName;
+        if (positionedName) {
+          publish(
+            {
+              name: positionedName,
+              kind: ASTEngine.SymbolKind.Type,
+              range: this.nodeToRange(node),
+              visibility: "public",
+              metadata: { nodeType: node.type, isDoctype: true, dtdName: positionedName }
+            },
+            positionedName
+          );
+          declaredNames.add(positionedName);
+        }
+        const externalId = this.findDirectChild(node, "ExternalID");
+        if (externalId && currentDtdName) {
+          this.extractExternalId(externalId, currentDtdName, "doctype_external_id", addRelationship, imports);
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child && child !== nameNode && child !== externalId) work.push({ node: child, ownerName, dtdName: currentDtdName });
+        }
+        continue;
+      }
+      if (node.type === "elementdecl") {
+        const nameNode = this.findDirectChild(node, "Name");
+        const name = nameNode?.text.trim();
+        if (name) {
+          publish(
+            {
+              name,
+              kind: ASTEngine.SymbolKind.Type,
+              range: this.nodeToRange(node),
+              visibility: "public",
+              ownerName: dtdName,
+              ownerKind: dtdName ? ASTEngine.SymbolKind.Type : void 0,
+              metadata: { nodeType: node.type, isDtdElementDeclaration: true, dtdName }
+            },
+            dtdName ? `${dtdName}\0${name}` : name
+          );
+          declaredNames.add(name);
+          if (dtdName) addRelationship(dtdName, name, ASTEngine.RelationshipType.Contains, { role: "dtd_element_declaration" }, nameNode);
+          const contentSpec = this.findDirectChild(node, "contentspec");
+          if (contentSpec) {
+            for (const member of this.descendantsOfType(contentSpec, "Name")) {
+              const memberName = member.text.trim();
+              if (!memberName) continue;
+              shadowCandidates.push({
+                name: memberName,
+                ownerName: dtdName,
+                node: member,
+                metadata: { isDtdContentModelMember: true, isDoctype: true, dtdName },
+                edge: { source: name, role: "dtd_content_model", dtdName }
+              });
+            }
+          }
+        }
+      }
+      if (node.type === "AttlistDecl") {
+        const elementName = this.findDirectChild(node, "Name")?.text.trim();
+        if (elementName) {
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const attDef = node.namedChild(i);
+            if (!attDef || attDef.type !== "AttDef") continue;
+            const attrNameNode = this.findDirectChild(attDef, "Name");
+            const attrName = attrNameNode?.text.trim();
+            if (!attrName) continue;
+            const defaultDecl = this.findDirectChild(attDef, "DefaultDecl");
+            const attrType = attDef.namedChildCount > 0 ? this.findFirstNamedChild(attDef, /* @__PURE__ */ new Set(["StringType", "TokenizedType", "Enumeration", "NotationType"])) : null;
+            publish(
+              {
+                name: attrName,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.nodeToRange(attDef),
+                visibility: "public",
+                ownerName: elementName,
+                ownerKind: ASTEngine.SymbolKind.Type,
+                metadata: {
+                  nodeType: "AttDef",
+                  isDtdAttributeDeclaration: true,
+                  dtdElement: elementName,
+                  attributeType: attrType?.text,
+                  defaultDeclaration: defaultDecl?.text
+                }
+              },
+              `${elementName}\0${attrName}`
+            );
+            addRelationship(elementName, attrName, ASTEngine.RelationshipType.Contains, { role: "dtd_attribute_declaration" }, attrNameNode);
+            if (defaultDecl) {
+              const stack = [defaultDecl];
+              while (stack.length > 0) {
+                const n = stack.pop();
+                if (n.type === "EntityRef") {
+                  const text = n.text.trim();
+                  if (text.length > 2 && text.startsWith("&") && text.endsWith(";")) {
+                    const ref = text.slice(1, -1);
+                    if (ref.length > 0) {
+                      entityReferenceCandidates.push({ ownerName: attrName, name: ref, node: n, textNode: n });
+                    }
+                  }
+                  continue;
+                }
+                for (let i2 = n.namedChildCount - 1; i2 >= 0; i2--) {
+                  const c = n.namedChild(i2);
+                  if (c) stack.push(c);
+                }
+              }
+            }
+            for (const notation of this.descendantsOfType(attDef, "NotationType")) {
+              for (const notationName of this.descendantsOfType(notation, "Name")) {
+                const target = notationName.text.trim();
+                if (!target) continue;
+                shadowCandidates.push({
+                  name: target,
+                  ownerName: dtdName,
+                  node: notationName,
+                  metadata: { isDtdNotation: true, dtdName },
+                  edge: { source: elementName, role: "dtd_notation_reference", dtdName }
+                });
+              }
+            }
+          }
+        }
+      }
+      if (node.type === "GEDecl" || node.type === "PEDecl" || node.type === "NotationDecl") {
+        const nameNode = this.findDirectChild(node, "Name");
+        const name = nameNode?.text.trim();
+        const isParameter = node.type === "PEDecl";
+        const isNotation = node.type === "NotationDecl";
+        if (name) {
+          {
+            publish(
+              {
+                name,
+                kind: ASTEngine.SymbolKind.Type,
+                range: this.nodeToRange(node),
+                visibility: "public",
+                ownerName: dtdName,
+                ownerKind: dtdName ? ASTEngine.SymbolKind.Type : void 0,
+                metadata: {
+                  nodeType: node.type,
+                  isDtdEntityDeclaration: true,
+                  isDtdParameterEntity: isParameter,
+                  isDtdNotationDeclaration: isNotation,
+                  dtdName
+                }
+              },
+              dtdName ? `${dtdName}\0${name}` : name
+            );
+          }
+          declaredNames.add(name);
+          if (dtdName) {
+            addRelationship(dtdName, name, ASTEngine.RelationshipType.Contains, {
+              role: isParameter ? "dtd_parameter_entity_declaration" : isNotation ? "dtd_notation_declaration" : "dtd_entity_declaration",
+              dtdName
+            }, nameNode);
+          }
+          const externalId = this.findDirectChild(node, "ExternalID");
+          if (externalId) {
+            this.extractExternalId(
+              externalId,
+              name,
+              isParameter ? "parameter_entity_external_id" : isNotation ? "notation_external_id" : "entity_external_id",
+              addRelationship,
+              imports
+            );
+          }
+          const ndata = this.findDirectChild(node, "NDataDecl");
+          const ndataName = ndata ? this.findDirectChild(ndata, "Name") : null;
+          if (ndataName) {
+            const target = ndataName.text.trim();
+            if (target) {
+              shadowCandidates.push({
+                name: target,
+                ownerName: dtdName,
+                node: ndataName,
+                metadata: { isDtdNotation: true, dtdName },
+                edge: { source: name, role: "dtd_ndata_notation", dtdName }
+              });
+            }
+          }
+          {
+            const value = this.findDirectChild(node, "EntityValue");
+            if (value) {
+              const stack = [value];
+              while (stack.length > 0) {
+                const n = stack.pop();
+                if (n.type === "EntityRef") {
+                  const text = n.text.trim();
+                  if (text.length > 2 && text.startsWith("&") && text.endsWith(";")) {
+                    const ref = text.slice(1, -1);
+                    if (ref.length > 0) {
+                      entityReferenceCandidates.push({ ownerName: name, name: ref, node: n, textNode: n });
+                    }
+                  }
+                  continue;
+                }
+                for (let i = n.namedChildCount - 1; i >= 0; i--) {
+                  const c = n.namedChild(i);
+                  if (c) stack.push(c);
+                }
+              }
+            }
+          }
+        }
+      }
+      if (node.type === "PI") {
+        const targetNode = this.findDirectChild(node, "PITarget");
+        const target = targetNode?.text.trim();
+        if (target && target.toLowerCase() !== "xml") {
+          publish(
+            {
+              name: target,
+              kind: ASTEngine.SymbolKind.Module,
+              range: this.nodeToRange(node),
+              visibility: "public",
+              ownerName,
+              ownerKind: ownerName ? ASTEngine.SymbolKind.Class : void 0,
+              metadata: { nodeType: node.type, isProcessingInstruction: true, target }
+            },
+            ownerName ? `${ownerName}\0${target}` : target
+          );
+          if (ownerName) addRelationship(ownerName, target, ASTEngine.RelationshipType.Contains, { role: "processing_instruction" }, targetNode);
+        }
+      }
+      if (node.type === "StyleSheetPI" || node.type === "XmlModelPI") {
+        const label = node.type === "StyleSheetPI" ? "xml-stylesheet" : "xml-model";
+        publish(
+          {
+            name: label,
+            kind: ASTEngine.SymbolKind.Module,
+            range: this.nodeToRange(node),
+            visibility: "public",
+            metadata: { nodeType: node.type, isProcessingInstruction: true, target: label, pseudoInstruction: true }
+          },
+          label
+        );
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const pseudo = node.namedChild(i);
+          if (!pseudo || pseudo.type !== "PseudoAtt") continue;
+          const pseudoNameNode = this.findDirectChild(pseudo, "Name");
+          const valueNode = this.findDirectChild(pseudo, "PseudoAttValue");
+          const attributeName = pseudoNameNode?.text.trim();
+          if (!attributeName) continue;
+          const value = valueNode ? this.unquote(valueNode.text).trim() : void 0;
+          if (attributeName === "href" && value) {
+            const targetClass = this.importTargetClass(value);
+            addRelationship(label, value, ASTEngine.RelationshipType.Imports, {
+              role: "processing_instruction_href",
+              attributeName,
+              resolvable: targetClass,
+              ...targetClass === "external" ? { isExternalTarget: true } : {}
+            }, valueNode);
+            imports.push({
+              module: value,
+              path: value,
+              importType: "xml-stylesheet",
+              range: this.nodeToRange(valueNode ?? pseudo),
+              metadata: { instruction: label, attributeName }
+            });
+          } else {
+            publish(
+              {
+                name: attributeName,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.nodeToRange(pseudo),
+                visibility: "public",
+                ownerName: label,
+                ownerKind: ASTEngine.SymbolKind.Module,
+                metadata: { nodeType: pseudo.type, isPseudoAttribute: true, value }
+              },
+              `${label}\0${attributeName}`
+            );
+            addRelationship(label, attributeName, ASTEngine.RelationshipType.Contains, { role: "pseudo_attribute" }, pseudoNameNode);
+          }
+        }
+      }
+      if (node.type === "EntityRef" && ownerName) {
+        const text = node.text.trim();
+        if (text.length > 2 && text.startsWith("&") && text.endsWith(";")) {
+          const name = text.slice(1, -1);
+          if (name.length > 0) entityReferenceCandidates.push({ ownerName: nearestNamedDeclaration ?? ownerName, name, node, textNode: node });
+        }
+      }
+      if (node.type === "PEReference") {
+        const text = node.text.trim();
+        if (text.length > 1 && text.startsWith("%")) {
+          const semi = text.indexOf(";");
+          if (semi > 1) {
+            const ref = text.slice(1, semi).trim();
+            const isValueForm = ref.length === 0 || _RealXmlAnalyzer.containsEcmaWhitespace(ref);
+            const inEntityValue = this.withinEntityValue(node);
+            if (!isValueForm && ref.length > 0) {
+              const ownerForRef = inEntityValue ? this.enclosingDeclaredName(node) ?? dtdName ?? "" : dtdName ?? "";
+              if (ownerForRef.length > 0) {
+                parameterEntityReferences.push({
+                  ownerName: ownerForRef,
+                  name: ref,
+                  node,
+                  textNode: node,
+                  recovery: !!this.withinErrorRegion(node)
+                });
+              }
+            }
+          }
+        }
+      }
+      const childDepth = bindDepth ?? 0;
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) work.push({ node: child, ownerName, dtdName, bindDepth: childDepth, nearestNamedDeclaration });
+      }
+    }
+    for (const candidate of shadowCandidates) {
+      ensureTargetSymbol(candidate.name, candidate.ownerName, ASTEngine.SymbolKind.Type, candidate.node, candidate.metadata);
+      addRelationship(candidate.edge.source, candidate.name, ASTEngine.RelationshipType.Contains, {
+        role: candidate.edge.role,
+        dtdName: candidate.edge.dtdName
+      }, candidate.node);
+    }
+    {
+      const IMPORT_ELEMENTS = /* @__PURE__ */ new Set(["import", "include", "import-schema"]);
+      const stack = [rootNode];
+      while (stack.length) {
+        const n = stack.pop();
+        for (let i = 0; i < n.childCount; i++) {
+          const c = n.child(i);
+          if (c) stack.push(c);
+        }
+        if (n.type !== "element") continue;
+        const tag = n.children.find((c) => c && (c.type === "STag" || c.type === "EmptyElemTag"));
+        if (!tag) continue;
+        const local = this.findDirectChild(tag, "Name")?.text.trim().split(":").pop() ?? "";
+        if (!IMPORT_ELEMENTS.has(local)) continue;
+        let nsUri;
+        let path2;
+        for (let i = 0; i < tag.namedChildCount; i++) {
+          const attr = tag.namedChild(i);
+          if (attr?.type !== "Attribute") continue;
+          const an = this.findDirectChild(attr, "Name")?.text.trim();
+          const av = this.findDirectChild(attr, "AttValue");
+          const value = av ? this.unquote(av.text).trim() : void 0;
+          if (!an || value === void 0) continue;
+          if (an === "namespace") nsUri = value;
+          else if (an === "schemaLocation") {
+            const parts = _RealXmlAnalyzer.splitOnWhitespace(value);
+            path2 = parts.length % 2 === 0 ? parts[parts.length - 1] : parts[0];
+          } else if (an === "href") path2 = value;
+        }
+        if (nsUri) importedNamespaces.set(nsUri, { path: path2, element: local });
+      }
+    }
+    for (const candidate of referenceCandidates) {
+      if (candidate.bareNameReference) {
+        if (!declaredNames.has(candidate.value)) continue;
+        addRelationship(candidate.ownerName, candidate.value, ASTEngine.RelationshipType.References, {
+          role: "xslt_named_template_reference",
+          attributeName: candidate.attributeName,
+          resolvable: "in-document"
+        }, candidate.valueNode);
+        continue;
+      }
+      const qname = this.asQName(candidate.value);
+      if (!qname) continue;
+      const resolvableInDocument = declaredNames.has(qname.local);
+      const isBuiltin = candidate.binding !== void 0 && _RealXmlAnalyzer.BUILTIN_NAMESPACE_URIS.has(candidate.binding);
+      const imported = !resolvableInDocument && !isBuiltin && candidate.binding !== void 0 ? importedNamespaces.get(candidate.binding) : void 0;
+      const ownerIsVocabulary = candidate.ownerNs !== void 0 && _RealXmlAnalyzer.DECLARATION_VOCABULARIES[candidate.ownerNs] !== void 0;
+      const isBareValue = qname.prefix.length === 0;
+      const unresolvedBareReference = !resolvableInDocument && !isBuiltin && !imported && isBareValue && ownerIsVocabulary;
+      if (!resolvableInDocument && !isBuiltin && !imported && !unresolvedBareReference) continue;
+      const ambiguousWithBuiltin = unresolvedBareReference && _RealXmlAnalyzer.XSD_BUILTIN_TYPE_NAMES.has(qname.local);
+      if (resolvableInDocument) {
+        ensureTargetSymbol(qname.local, void 0, ASTEngine.SymbolKind.Type, candidate.nameNode, { isReferencedDeclaration: true });
+      }
+      const claimsExternalTarget = isBuiltin || !resolvableInDocument && !unresolvedBareReference;
+      addRelationship(candidate.ownerName, qname.local, ASTEngine.RelationshipType.References, {
+        role: "attribute_qname_reference",
+        attributeName: candidate.attributeName,
+        qname: candidate.value,
+        prefix: qname.prefix,
+        namespaceUri: candidate.binding,
+        resolvable: isBuiltin ? "builtin" : resolvableInDocument ? "in-document" : unresolvedBareReference ? "unresolved" : "external",
+        ...claimsExternalTarget ? { isExternalTarget: true } : {},
+        // X13: the name is also a built-in, and this file cannot say whether the
+        // document means the built-in or a same-named type an `xs:include` brought
+        // in. Recorded so a consumer can see the ambiguity instead of inheriting
+        // whichever reading the graph happened to take.
+        ...ambiguousWithBuiltin ? { ambiguousWithBuiltin: true } : {},
+        // where the name actually lives, so a consumer can follow it rather than
+        // having to guess from the namespace alone
+        ...imported ? { importedFrom: imported.path, importedBy: imported.element } : {}
+      }, candidate.valueNode);
+    }
+    for (const cand of callCandidates) {
+      if (!declaredTemplateNames.has(cand.templateName)) continue;
+      addRelationship(cand.ownerName, cand.templateName, ASTEngine.RelationshipType.Calls, {
+        role: "xslt_named_template_call",
+        attributeName: "name",
+        templateName: cand.templateName,
+        // A name resolved against the stylesheet's own declarations, which is what
+        // makes this edge different from a mention. XSLT 2.0 §6.1.3 adds
+        // `xsl:use-when`/`use-unless` to conditional dispatch, and neither can change
+        // WHICH template is invoked.
+        resolvable: "in-document"
+      }, cand.textNode);
+    }
+    {
+      const byKey = /* @__PURE__ */ new Map();
+      for (const t of competingTemplates) {
+        const arr = byKey.get(t.key) ?? [];
+        arr.push(t);
+        byKey.set(t.key, arr);
+      }
+      for (const group of byKey.values()) {
+        if (group.length < 2) continue;
+        const declared = group.map((t) => t.declaredName);
+        const useDeclaredNames = declared.every((d) => d.length > 0) && new Set(declared).size === declared.length;
+        const identityOf = (t, index) => {
+          if (useDeclaredNames) return t.declaredName;
+          const derived = `xsl:template[match=${t.match}|mode=${t.mode}|priority=${t.priority}]#${index}`;
+          ensureTargetSymbol(derived, t.ownerName, ASTEngine.SymbolKind.Class, t.anchorNode, {
+            nodeType: "element",
+            tagName: "xsl:template",
+            isXmlElement: true,
+            // Marked, so a consumer can tell a derived identity from a declared one
+            // instead of inferring it from the punctuation.
+            derivedTemplateIdentity: true,
+            // The `name` attribute is carried here because a colliding pair usually
+            // shares one, or has none: dropping it would lose the only name the
+            // document actually wrote.
+            ...t.declaredName.length > 0 ? { declaredName: t.declaredName } : {},
+            templateMatch: t.match,
+            templateMode: t.mode,
+            templatePriority: t.priority,
+            templateOccurrenceInGroup: index
+          });
+          return derived;
+        };
+        const identities = group.map(identityOf);
+        for (let i = 1; i < group.length; i++) {
+          const winner = group[i];
+          const source = identities[i];
+          const target = identities[i - 1];
+          if (source.length === 0 || target.length === 0 || source === target) continue;
+          addRelationship(source, target, ASTEngine.RelationshipType.Overrides, {
+            role: "xslt_competing_template_rule",
+            // The three attributes §5.5 compares, carried so a consumer can re-derive
+            // the collision instead of trusting the edge.
+            templateMatch: winner.match,
+            templateMode: winner.mode,
+            templatePriority: winner.priority,
+            derivation: "xslt-5.5-later-template-replaces-earlier",
+            resolvable: "in-document",
+            ...winner.declaredName.length > 0 ? { declaredName: winner.declaredName } : {}
+          }, winner.anchorNode);
+        }
+      }
+    }
+    for (const cand of derivationCandidates) {
+      const qname = this.asQName(cand.value);
+      if (!qname) continue;
+      const resolvableInDocument = declaredNames.has(qname.local);
+      const isBuiltin = cand.binding !== void 0 && _RealXmlAnalyzer.BUILTIN_NAMESPACE_URIS.has(cand.binding);
+      const imported = !resolvableInDocument && !isBuiltin && cand.binding !== void 0 ? importedNamespaces.get(cand.binding) : void 0;
+      const ownerIsVocabulary = cand.ownerNs !== void 0 && _RealXmlAnalyzer.DECLARATION_VOCABULARIES[cand.ownerNs] !== void 0;
+      const isBareValue = qname.prefix.length === 0;
+      const unresolvedBare = !resolvableInDocument && !isBuiltin && !imported && isBareValue && ownerIsVocabulary;
+      if (!resolvableInDocument && !isBuiltin && !imported && !unresolvedBare) continue;
+      if (resolvableInDocument) {
+        ensureTargetSymbol(qname.local, void 0, ASTEngine.SymbolKind.Type, cand.nameNode, { isReferencedDeclaration: true });
+      }
+      const claimsExternalTarget = isBuiltin || !resolvableInDocument && !unresolvedBare;
+      addRelationship(cand.ownerName, qname.local, ASTEngine.RelationshipType.Extends, {
+        role: "xsd_derivation_base",
+        attributeName: "base",
+        qname: cand.value,
+        prefix: qname.prefix,
+        namespaceUri: cand.binding,
+        // WHICH derivation, because XSD has two and they narrow in opposite
+        // directions: `extension` keeps everything the base admits and adds to it,
+        // `restriction` admits a subset. The edge is the same subtype relation in
+        // both cases and this is what tells a consumer which way.
+        derivation: cand.kind,
+        resolvable: isBuiltin ? "builtin" : resolvableInDocument ? "in-document" : unresolvedBare ? "unresolved" : "external",
+        ...claimsExternalTarget ? { isExternalTarget: true } : {},
+        ...unresolvedBare && _RealXmlAnalyzer.XSD_BUILTIN_TYPE_NAMES.has(qname.local) ? { ambiguousWithBuiltin: true } : {},
+        ...imported ? { importedFrom: imported.path, importedBy: imported.element } : {}
+      }, cand.valueNode);
+    }
+    for (const cand of compositionCandidates) {
+      const qname = this.asQName(cand.value);
+      if (!qname) continue;
+      const resolvableInDocument = declaredNames.has(qname.local);
+      const isBuiltin = cand.binding !== void 0 && _RealXmlAnalyzer.BUILTIN_NAMESPACE_URIS.has(cand.binding);
+      const imported = !resolvableInDocument && !isBuiltin && cand.binding !== void 0 ? importedNamespaces.get(cand.binding) : void 0;
+      if (!resolvableInDocument && !isBuiltin && !imported) continue;
+      if (resolvableInDocument) {
+        ensureTargetSymbol(qname.local, void 0, ASTEngine.SymbolKind.Type, cand.nameNode, { isReferencedDeclaration: true });
+      }
+      addRelationship(cand.ownerName, qname.local, ASTEngine.RelationshipType.MixesIn, {
+        role: "xsd_definition_composition",
+        attributeName: "ref",
+        qname: cand.value,
+        prefix: qname.prefix,
+        namespaceUri: cand.binding,
+        // WHICH carrier, because the two constructs compose different things: a group
+        // composes a content model, an attributeGroup composes attribute declarations.
+        // A consumer filtering on the kind does not have to re-derive it from the tag.
+        composedKind: cand.kind,
+        resolvable: isBuiltin ? "builtin" : resolvableInDocument ? "in-document" : "external",
+        ...isBuiltin || !resolvableInDocument ? { isExternalTarget: true } : {},
+        ...imported ? { importedFrom: imported.path, importedBy: imported.element } : {}
+      }, cand.valueNode);
+    }
+    for (const cand of entityReferenceCandidates) {
+      const declared = declaredNames.has(cand.name);
+      const builtin = _RealXmlAnalyzer.PREDEFINED_ENTITIES.has(cand.name);
+      addRelationship(cand.ownerName, cand.name, ASTEngine.RelationshipType.References, {
+        role: "entity_reference",
+        entityName: cand.name,
+        resolvable: declared ? "in-document" : builtin ? "builtin" : "unresolved",
+        ...declared || builtin ? {} : { danglingEntityReference: true },
+        // `builtin` IS the external claim here: the five predefined entities are not declarations
+        // of this population (or of any document), and a bare identifier is verified by
+        // `verifyExternalClaim` exactly when the key space does not declare it. `unresolved`
+        // (a dangling entity reference) is deliberately NOT marked — the analyzer has not
+        // measured that it is outside the population, only that this file does not declare it.
+        ...builtin && !declared ? { isExternalTarget: true } : {}
+      }, cand.textNode);
+    }
+    for (const cand of parameterEntityReferences) {
+      const declared = declaredNames.has(cand.name);
+      addRelationship(cand.ownerName, cand.name, ASTEngine.RelationshipType.References, {
+        role: "parameter_entity_reference",
+        entityName: cand.name,
+        isParameterEntity: true,
+        resolvable: declared ? "in-document" : "unresolved",
+        // Kept and LABELLED rather than dropped, which is the recovery-labelling
+        // contract `xml/recovery-labelling` already pins for symbols and edges out
+        // of a damaged file. libxml2's `test/errors/*` is a corpus of deliberately
+        // malformed documents; a parameter reference recovered out of one is a claim
+        // the bytes make that no processor would honour, and saying so is more
+        // useful than silence.
+        ...cand.recovery ? { recovery: true, reasonCode: "parameter-entity-reference-in-damaged-region" } : {},
+        ...declared ? {} : { danglingEntityReference: true }
+      }, cand.textNode);
+    }
+    const hasSyntaxErrors = errorNodes > 0 || missingNodes > 0;
+    if (hasSyntaxErrors) {
+      for (const symbol of symbols) symbol.metadata.syntaxErrors = true;
+      for (const relationship of relationships) relationship.metadata.syntaxErrors = true;
+    }
+    {
+      const isPlaceholder = (name) => name === _RealXmlAnalyzer.PLACEHOLDER_LITERAL;
+      const keptSymbols = symbols.filter((s) => !isPlaceholder(String(s.name ?? "")));
+      const keptRelationships = relationships.filter((x) => !isPlaceholder(String(x.source ?? "")) && !isPlaceholder(String(x.target ?? "")));
+      const droppedSymbols = symbols.length - keptSymbols.length;
+      const droppedRelationships = relationships.length - keptRelationships.length;
+      if (droppedSymbols > 0 || droppedRelationships > 0) {
+        this.qualifySameFileTier(keptSymbols, keptRelationships);
+        this.attachFileClaims(keptRelationships, filePath, context);
+        return {
+          language: "xml",
+          symbols: keptSymbols,
+          relationships: keptRelationships,
+          imports,
+          exports: [],
+          errors,
+          metadata: {
+            complexity: keptSymbols.length + keptRelationships.length,
+            linesOfCode: content.split("\n").length,
+            cyclomaticComplexity: 1,
+            patterns: [],
+            framework: "XML",
+            errorNodes,
+            missingNodes,
+            syntaxErrors: hasSyntaxErrors,
+            placeholderLiteralRefusals: droppedSymbols + droppedRelationships
+          }
+        };
+      }
+    }
+    this.qualifySameFileTier(symbols, relationships);
+    this.attachFileClaims(relationships, filePath, context);
+    return {
+      language: "xml",
+      symbols,
+      relationships,
+      imports,
+      exports: [],
+      errors,
+      metadata: {
+        complexity: symbols.length + relationships.length,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: 1,
+        patterns: [],
+        framework: "XML",
+        errorNodes,
+        missingNodes,
+        syntaxErrors: hasSyntaxErrors
+      }
+    };
+  }
+  /**
+   * `<!DOCTYPE a PUBLIC "-//X//DTD A//EN" "a.dtd">` spans lines: `PUBLIC` and the
+   * public id are on one, the SYSTEM path on another. The edge target is the
+   * path, so the edge's line is the LITERAL's line (M59.A7 / #825) — passing the
+   * `ExternalID` node instead points the edge at the `SYSTEM` keyword's line,
+   * which is the line of no name in the edge.
+   *
+   * A `SystemLiteral` is REQUIRED and a `PubidLiteral` is not a substitute. The two are
+   * different things and only one of them is a file: `SYSTEM "graphic.gif"` names a path
+   * a parser opens, `PUBLIC "GIF"` names a symbolic identifier a parser matches against a
+   * catalogue. This read was `systemLiteral || pubidLiteral`, so the second stood in for
+   * the first and a public identifier became an edge target — the fabricated
+   * `GIF -imports-> GIF` in `libxslt/tests/general/bug-52.xml`, at `confidence: 1`, on a
+   * tier table that maps `notation_external_id` to `import_based`.
+   *
+   * The invariant lives HERE rather than only at the one caller that broke it, because
+   * this is the single point where the target string is created: any future caller that
+   * hands this a `PublicID` now gets nothing instead of an edge, which is the correct
+   * outcome for a node that carries no file. Measured by
+   * `validation/m14/fixtures/xml/public-id-census.mts` — 298 system-literal nodes and 298
+   * `externalIdKind: "system"` edges agree exactly, so nothing legitimate is lost.
+   */
+  extractExternalId(externalId, owner, role, addRelationship, imports) {
+    const literal = this.findDirectChild(externalId, "SystemLiteral");
+    if (!literal) return;
+    const path2 = this.unquote(literal.text);
+    if (!path2) return;
+    imports.push({
+      module: path2,
+      path: path2,
+      importType: "xml-doctype",
+      range: this.nodeToRange(literal),
+      metadata: { isDtdExternalId: true, role, systemId: true }
+    });
+    const targetClass = this.importTargetClass(path2);
+    addRelationship(owner, path2, ASTEngine.RelationshipType.Imports, {
+      role,
+      externalIdKind: "system",
+      resolvable: targetClass,
+      // A DOCTYPE whose SYSTEM identifier is a URI names a DTD outside this project — the largest
+      // single group of this lane's unresolved edges is exactly this shape
+      // (`http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd`). Path-like, so the owner check
+      // returns externalUnverified and can never refute; a relative `file` path is left unmarked.
+      ...targetClass === "external" ? { isExternalTarget: true } : {}
+    }, literal);
+  }
+  /**
+   * A correctly-parsed declaration's name is its FIRST named child. If it is
+   * not, the node is a recovery shape and any `Name` beneath it may be a
+   * fragment of a construct the parser did not understand — publishing it would
+   * put a name in the graph that is not a declaration. The pre-repair grammar
+   * produced exactly this for a conditional section: the DTD's name came out as
+   * the literal text `INCLUDE`.
+   */
+  isPositionedDeclarationName(node, nameNode) {
+    if (!nameNode) return false;
+    const firstNamed = node.namedChild(0);
+    return Boolean(firstNamed) && firstNamed.id === nameNode.id;
+  }
+  /** Reads the `xmlns` / `xmlns:prefix` attributes of a tag into the binding map. */
+  rememberNamespaces(tagNode, bindings) {
+    for (let i = 0; i < tagNode.namedChildCount; i++) {
+      const child = tagNode.namedChild(i);
+      if (!child || child.type !== "Attribute") continue;
+      const attributeName = this.findDirectChild(child, "Name")?.text.trim();
+      if (attributeName !== "xmlns" && !attributeName?.startsWith("xmlns:")) continue;
+      const valueNode = this.findDirectChild(child, "AttValue");
+      if (!valueNode) continue;
+      const prefix = attributeName === "xmlns" ? "" : attributeName.slice(6);
+      if (attributeName !== "xmlns" && prefix.length === 0) continue;
+      bindings.set(prefix, this.unquote(valueNode.text));
+    }
+  }
+  extractAttribute(node, ownerName, symbols, addRelationship, publishedNames, declaredNames, namespaceBindings, referenceCandidates, ensureTargetSymbol, ownerLocalName, ownerNamespace, callCandidates, derivationCandidates, compositionCandidates, elementOwnerName, nearestNamedDeclaration, selfNamedDeclaration) {
+    const ownerNs = ownerNamespace;
+    const namedRefs = ownerNamespace ? _RealXmlAnalyzer.NAMED_REFERENCE_ELEMENTS[ownerNamespace] : void 0;
+    this.bareNameReference = namedRefs ? namedRefs.has(ownerLocalName) : false;
+    this.xsltCallElement = ownerNamespace === "http://www.w3.org/1999/XSL/Transform" && _RealXmlAnalyzer.XSLT_CALL_ELEMENTS.has(ownerLocalName);
+    this.xsdDerivationElement = ownerNamespace === "http://www.w3.org/2001/XMLSchema" && (ownerLocalName === "extension" || ownerLocalName === "restriction");
+    this.derivationKind = ownerLocalName === "extension" ? "extension" : "restriction";
+    this.bareNameDeclarationElement = ownerNamespace === "http://relaxng.org/ns/structure/1.0" && (ownerLocalName === "element" || ownerLocalName === "attribute" || ownerLocalName === "define");
+    const nameNode = this.findDirectChild(node, "Name");
+    const valueNode = this.findDirectChild(node, "AttValue");
+    const attributeName = nameNode?.text.trim();
+    if (!attributeName) return;
+    const value = valueNode ? this.unquote(valueNode.text) : void 0;
+    const isNamespace = attributeName === "xmlns" || attributeName.startsWith("xmlns:");
+    const namespacePrefix = attributeName === "xmlns" ? "default" : attributeName.slice("xmlns:".length);
+    if (!attributeName) return;
+    if (isNamespace && namespacePrefix.length === 0) return;
+    const colon = isNamespace ? -1 : attributeName.indexOf(":");
+    const attributePrefix = colon > 0 ? attributeName.slice(0, colon) : void 0;
+    const attributeLocalName = colon > 0 ? attributeName.slice(colon + 1) : attributeName;
+    if (colon > 0 && attributeLocalName.length === 0) return;
+    const name = isNamespace ? namespacePrefix : attributeLocalName;
+    const kind = isNamespace ? ASTEngine.SymbolKind.Namespace : ASTEngine.SymbolKind.Property;
+    if (attributePrefix && namespaceBindings.has(attributePrefix)) {
+      addRelationship(ownerName, attributePrefix, ASTEngine.RelationshipType.Uses, {
+        role: "xml_namespace_prefix_use",
+        namespaceUri: namespaceBindings.get(attributePrefix),
+        resolvable: "in-document"
+      }, nameNode);
+    }
+    symbols.push({
+      name,
+      kind,
+      range: this.nodeToRange(node),
+      visibility: "public",
+      ownerName,
+      ownerKind: ASTEngine.SymbolKind.Class,
+      // M60: an attribute is a declaration OWNED BY the element it is written on,
+      // and `pool-worker.ts:930` defaults `qualifiedName` to the bare name when the
+      // analyzer leaves it unset. So `svg/@fill` and `path/@fill` were both
+      // published under the single key `fill` and the store could not tell two
+      // declarations of two elements apart (`parallel-indexer.ts:3038` writes
+      // `symbol.qualifiedName || symbol.name`). Measured on the 600-file draw
+      // `099e7a868f7b73ee`: 83,454 `property` symbols and 1,002 `namespace` symbols
+      // carried a qualified name equal to their bare name.
+      //
+      // The same expression already used for elements at `:790` and `:920`, so this
+      // is one convention in one analyzer rather than a second identity scheme.
+      //
+      // WHAT IT DOES NOT FIX, stated rather than implied: two instances of the SAME
+      // tag (`<path fill>` twice) still publish `path.fill` twice, because a
+      // qualified name is unique within a scope and the distinguishing information
+      // — ancestry and position — is not in the published name. Measured residual
+      // for this edit: 2,195 of 14,081 ambiguous edges repaired, 11,886 left
+      // (`validation/m14/measurements/xml/qname-population-after-d1.json`).
+      qualifiedName: ownerName ? `${ownerName}.${name}` : name,
+      metadata: {
+        nodeType: node.type,
+        isXmlAttribute: !isNamespace,
+        isXmlNamespace: isNamespace,
+        // The name AS WRITTEN, prefix included. The symbol's `name` is the local
+        // part, so this is the only place the prefix survives in the analyzer's
+        // output — see the comment on `attributeLocalName` above.
+        attributeName,
+        attributeLocalName,
+        value,
+        namespacePrefix: isNamespace ? namespacePrefix : attributePrefix,
+        namespaceUri: isNamespace ? value : void 0
+      }
+    });
+    if (!publishedNames.has(`${ownerName}\0${name}`)) publishedNames.add(`${ownerName}\0${name}`);
+    addRelationship(ownerName, name, ASTEngine.RelationshipType.Contains, {
+      role: isNamespace ? "xml_namespace" : "xml_attribute",
+      value,
+      // M59 (#825): the name as WRITTEN. For `xmlns="…"` the edge's target is the
+      // synthesised element name `default` (the default namespace has no written
+      // prefix), which appears nowhere in the source — so a source check on the
+      // target is unfixable by construction. Carrying `xmlns` (or `xmlns:pfx`)
+      // lets the claim be checked against what is actually on the line.
+      attributeName
+    }, nameNode);
+    if (isNamespace || value === void 0) return;
+    if (attributeName === "schemaLocation") {
+      const parts = _RealXmlAnalyzer.splitOnWhitespace(value);
+      const paired = parts.length % 2 === 0 && parts.length >= 2;
+      let emitted = 0;
+      for (let i = paired ? 1 : 0; i < parts.length; i += paired ? 2 : 1) {
+        const target = parts[i];
+        if (!target || this.isRemoteUri(target)) continue;
+        addRelationship(ownerName, target, ASTEngine.RelationshipType.Imports, {
+          role: "schema_location",
+          attributeName,
+          namespace: paired ? parts[i - 1] : void 0,
+          resolvable: this.importTargetClass(target)
+        }, valueNode);
+        emitted++;
+      }
+      if (emitted > 0) {
+        const last = symbols[symbols.length - 1];
+        if (last && last.name === attributeName && last.ownerName === ownerName) {
+          last.metadata.schemaLocationTargets = parts.filter((_x, i) => paired ? i % 2 === 1 : true);
+        }
+        return;
+      }
+    }
+    if (this.bareNameReference) {
+      if (!nameNode || !valueNode) return;
+      referenceCandidates.push({
+        ownerName,
+        attributeName,
+        value,
+        nameNode,
+        valueNode,
+        binding: void 0,
+        ownerNs,
+        bareNameReference: true
+      });
+      return;
+    }
+    if (this.xsltCallElement && attributeName === "name" && valueNode) {
+      const colon2 = value.indexOf(":");
+      const local = colon2 >= 0 ? value.slice(colon2 + 1) : value;
+      if (local.length > 0 && local.length <= 256 && nearestNamedDeclaration) {
+        callCandidates.push({ ownerName: nearestNamedDeclaration, templateName: local, valueNode: node, textNode: valueNode });
+      }
+      return;
+    }
+    const collapsed = _RealXmlAnalyzer.collapseWhitespace(value);
+    const qname = this.asQName(collapsed);
+    if (!qname || !nameNode || !valueNode) return;
+    if (!qname.prefix && !_RealXmlAnalyzer.REFERENCE_ATTRIBUTES.has(attributeName)) return;
+    if (!qname.prefix && this.bareNameDeclarationElement) return;
+    const declared = namespaceBindings.get(qname.prefix);
+    const binding = declared ?? _RealXmlAnalyzer.IMPLICIT_PREFIX_BINDINGS[qname.prefix];
+    if (this.xsdDerivationElement && attributeName === "base") {
+      derivationCandidates.push({
+        // `nearestNamedDeclaration`, NOT `ownerName`. `ownerName` is the derivation
+        // ELEMENT's own symbol, which for `<xs:restriction>` is the tag text — measured at
+        // 438 of 438 corpus edges naming a vocabulary constructor instead of a declared
+        // type. See the NEAREST NAMED SCHEMA DECLARATION block in the walk above.
+        ownerName: nearestNamedDeclaration ?? "",
+        value: collapsed,
+        binding,
+        ownerNs,
+        kind: this.derivationKind,
+        valueNode,
+        nameNode
+      });
+      return;
+    }
+    if (attributeName === "ref" && ownerNs === "http://www.w3.org/2001/XMLSchema" && (ownerLocalName === "group" || ownerLocalName === "attributeGroup")) {
+      compositionCandidates.push({
+        // Same rule as derivation: the composed-INTO type is the nearest named
+        // declaration above the carrier — the carrier itself is `xs:group`, a vocabulary
+        // tag no document declares. `selfNamedDeclaration` is undefined here in practice
+        // (a composing group/attributeGroup has no `name=` of its own), and the nearest
+        // named ancestor is the type or nesting group the definitions become part of.
+        ownerName: selfNamedDeclaration ?? nearestNamedDeclaration ?? ownerName,
+        value: collapsed,
+        binding,
+        kind: ownerLocalName,
+        valueNode,
+        nameNode
+      });
+      return;
+    }
+    referenceCandidates.push({
+      // THE SOURCE OF A REFERENCE EDGE. This is the third edge type to need it, and the
+      // defect is the same one the other two had: `ownerName` is the element's OWN symbol,
+      // which is its declared name when the vocabulary writes one on `name=` and its TAG
+      // TEXT when it does not. A tag text is not an entity a document declares.
+      //
+      // From FSharp.Data/docs/data/po.xsd, verbatim:
+      //
+      //   "xs:element" -> "comment"   (role=attribute_qname_reference)
+      //
+      // `<xs:element ref="comment" minOccurs="0"/>` sits inside
+      // `<xs:complexType name="PurchaseOrderType">`. The reference is made BY that type's
+      // content model, so the source is `PurchaseOrderType`; the analyzer published
+      // `xs:element`, which is the schema vocabulary's word for a type CONSTRUCTOR and a
+      // symbol no document declares. Measured at 1,066 of 10,411 `references` edges on the
+      // gate's own sample — see `docs/analyzers/xml.md`.
+      //
+      // The rule, and it is deliberately two lines rather than one:
+      //
+      //   self declared      the carrier HAS a name of its own, so the reference belongs
+      //                      to that declaration — `<xs:element name="e" type="T"/>` is
+      //                      `e -> T`, and this branch leaves those edges exactly as they
+      //                      were. It is also why `nearestNamedDeclaration` must not be
+      //                      consulted here: for that element the enclosing scope is not
+      //                      the declarer.
+      //   nearest, else tag  the carrier has NO name, so the declarer is the nearest
+      //                      named ancestor, and the tag is kept when there is none. That
+      //                      fallback is the difference between this fix and the
+      //                      `extends` fix, which has no fallback at all and refuses
+      //                      instead: `references` is emitted for carriers in EVERY
+      //                      vocabulary — Spring, SVG, WSDL, DocBook and application XML —
+      //                      and most of them have no named schema ancestor, so refusing
+      //                      would delete real edges rather than re-base them. It cannot
+      //                      fabricate, because it is the value that was there before.
+      ownerName: selfNamedDeclaration ?? nearestNamedDeclaration ?? ownerName,
+      attributeName,
+      // The COLLAPSED value, not the raw one. The deferred pass re-parses
+      // `candidate.value` with `asQName`, so storing the raw text meant the
+      // facet was applied once for the push-site check and then thrown away —
+      // the candidate passed the collapsed test here and failed the raw one
+      // there, and the edge was refused exactly as before. One transformation,
+      // at the point the value enters the queue, and both readers see the same
+      // string. It also makes `metadata.qname` the reading the spec defines
+      // rather than the bytes a human typed.
+      value: collapsed,
+      nameNode,
+      valueNode,
+      binding,
+      ownerNs
+    });
+  }
+  /**
+   * A QName is `NCName` or `NCName ':' NCName` with NOTHING else in the value.
+   * Written as a character scan rather than a regular expression: the lane's rule
+   * is that no regular expression does syntax work, and this is a syntax
+   * decision about an attribute value.
+   */
+  asQName(value) {
+    if (!value || value.length > 256) return null;
+    let colon = -1;
+    for (let i = 0; i < value.length; i++) {
+      if (value[i] === ":") {
+        if (colon >= 0) return null;
+        colon = i;
+      }
+    }
+    const prefix = colon < 0 ? "" : value.slice(0, colon);
+    const local = colon < 0 ? value : value.slice(colon + 1);
+    if (!this.isNcName(local)) return null;
+    if (colon >= 0 && !this.isNcName(prefix)) return null;
+    return { prefix, local };
+  }
+  /** XML `NCName` — the character set the grammar's own `Name` rule accepts. */
+  isNcName(text) {
+    if (text.length === 0) return false;
+    for (let i = 0; i < text.length; i++) {
+      const c = text[i];
+      const alpha = c >= "A" && c <= "Z" || c >= "a" && c <= "z";
+      const ok = i === 0 ? alpha || c === "_" : alpha || c >= "0" && c <= "9" || c === "_" || c === "." || c === "-" || c === ":";
+      if (!ok) return false;
+    }
+    return true;
+  }
+  /** A URI with a scheme or an authority is not a repository-relative file path. */
+  isRemoteUri(target) {
+    for (let i = 0; i < target.length; i++) {
+      const c = target[i];
+      if (c === "/" || c === "\\" || c === ".") return false;
+      if (c === ":") return true;
+    }
+    return false;
+  }
+  /**
+   * WHAT KIND OF THING an `imports` target is, so the edge carries a class a consumer
+   * can count instead of reading as a dangling name.
+   *
+   * `imports` is the only relationship type this analyzer emits whose target is not a
+   * symbol, and until this existed the type reported 0 % resolution with nothing on the
+   * edge to say why — which is the state the round brief's cause C calls "silently
+   * unresolved". Measured on the census draw `3bd539410d1a9189` by
+   * `validation/m14/fixtures/xml/imports-target-classes.mts`: 263 edges, 84 distinct
+   * targets, **0 of 263 carrying any class**. The same probe splits them 153 path-shaped,
+   * 107 scheme-bearing, 3 in-document fragments.
+   *
+   * Three classes, and each is a claim this function can actually keep:
+   *
+   *   `in-document` — the target starts with `#`, so it names a location in THIS file.
+   *     The one `imports` shape whose target can resolve to a symbol here.
+   *   `external`    — `isRemoteUri`, the SAME test `schemaLocation` already applies, so
+   *     this file does not grow a second notion of "remote" that disagrees with the
+   *     first. Outside the corpus by construction.
+   *   `file`        — a path. **Not a claim that the file exists.** The analyzer is a
+   *     per-file pure unit and does no filesystem access, so existence is a corpus
+   *     question it cannot answer; the probe answers it for one draw and the honest
+   *     split of the 153 is 130 admitting as xml, 21 present nowhere, 2 present but not
+   *     admitted. A consumer that needs that split must ask the corpus, not the edge.
+   *
+   * `file` is a new member of the vocabulary `references` and `extends` already use
+   * (`in-document` / `builtin` / `external` / `unresolved`); nothing outside this file
+   * switches on it, which was checked rather than assumed.
+   */
+  importTargetClass(target) {
+    if (target.startsWith("#")) return "in-document";
+    return this.isRemoteUri(target) ? "external" : "file";
+  }
+  /**
+   * WHICH ATTRIBUTE carries a declaration's name, where `name` is not it.
+   *
+   * XSLT 1.0 §7.1 gives `xsl:output` no `name` at all: the output method IS its
+   * name, written `method="html"`. That is the only such case measured across
+   * the four vocabularies, and it is a table rather than a branch so that the
+   * next one is a DECLARATION in the same place as the first, and so the
+   * completeness gate can see that the attribute vocabulary is not silently
+   * assumed to be `{name}`.
+   */
+  /**
+   * Declared EMPTY, and that emptiness is the finding.
+   *
+   * This used to read `{ output: "method" }`, on the theory that XSLT
+   * `xsl:output` names something. It does not: `method` names the output METHOD
+   * (`xml`, `html`, `text`) and nothing else. So `<xsl:output method="xml"/>`
+   * was published as a symbol called **`xml`**, marked `isVocabDeclaration`,
+   * with `method`/`encoding`/`indent` hung off it as its attributes — and the
+   * element's real name, `xsl:output`, appeared nowhere in the graph.
+   *
+   * That is the M60.R10 defect class in MIRROR IMAGE. R10 is publishing a VALUE
+   * where a NAME belongs, into a `contains` target; this was taking a value
+   * where a NAME belongs and calling the element IT. The comment on
+   * REFERENCE_ATTRIBUTES above spends two paragraphs refusing to publish
+   * `unbounded` and `Normal` as names, and then the declared-name table handed
+   * `xml` to the graph in the very next screen. The corpus paid for it in
+   * bug-128.xml and bug-92.xml, where `contains xsl:stylesheet -> xsl:output`
+   * was missing and the element had been renamed to its own configuration.
+   *
+   * XSLT 2.0 does give `xsl:output` a `name`, for stylesheets that declare
+   * several outputs — and `name` is already this function's default, so the
+   * correct table is the empty one. `xsl:output` in XSLT 1.0, which is what
+   * these files are, has no name at all and is correctly published under its
+   * written name: it is an instruction, not a declaration.
+   */
+  static DECLARATION_NAME_ATTRIBUTE = {};
+  /**
+   * The DECLARED NAME of an element, when its vocabulary puts the name in an
+   * attribute — and ONLY then.
+   *
+   * Returns null for every other element, which is the common case: a document's
+   * elements are named by their tag, and an attribute that happens to be spelled
+   * `name` is data. An ANONYMOUS inline declaration (`<xs:complexType>` with no
+   * `name` inside an `<xs:element>`) is also null, and correctly so: an inline
+   * type has no name, and publishing the tag for it is the honest reading.
+   *
+   * `nameNode` is the node the NAME ITSELF is written on, which is the AttValue
+   * when the value is on a different line from the attribute keyword and the
+   * whole Attribute otherwise. It is not the same node in both cases, and
+   * picking the Attribute unconditionally was the whole of M19:
+   *
+   *     <xsd:element name=
+   *         "InvalidModificationFault"
+   *
+   * (cxf/wsn/wsdl/rp-2.xsd) — the Attribute starts on 233, where the line reads
+   * `<xsd:element name=` and carries no part of the name; the AttValue is on
+   * 234. Anchoring to the Attribute reported 233, so a search for the name
+   * landed one line above the string that spells it.
+   *
+   * `allOnOneLine` says which of the shapes this declaration is, because the shapes
+   * want DIFFERENT spans even where two of them agree on the line. See the call site:
+   * when all three share a line the SYMBOL anchors to the whole element, and the
+   * difference is containment rather than cosmetics.
+   */
+  declaredNameOf(namespaceUri, localName, tagNode) {
+    if (!namespaceUri) return null;
+    const declaring = _RealXmlAnalyzer.DECLARATION_VOCABULARIES[namespaceUri];
+    if (!declaring || !declaring.has(localName)) return null;
+    const attribute = _RealXmlAnalyzer.DECLARATION_NAME_ATTRIBUTE[localName] ?? "name";
+    for (let i = 0; i < tagNode.namedChildCount; i++) {
+      const node = tagNode.namedChild(i);
+      if (node?.type !== "Attribute") continue;
+      const attrNameNode = this.findDirectChild(node, "Name");
+      if (attrNameNode?.text.trim() !== attribute) continue;
+      const valueNode = this.findDirectChild(node, "AttValue");
+      if (!valueNode) return null;
+      const value = this.unquote(valueNode.text).trim();
+      if (value.length === 0 || value.length > 256) return null;
+      const anchor = valueNode.startPosition.row !== node.startPosition.row ? valueNode : node;
+      return {
+        name: value,
+        attribute,
+        nameNode: anchor,
+        // The switch the call site needs is "are the TAG, the ATTRIBUTE and the VALUE
+        // all on ONE line". Either half alone is wrong, and the M19 fixture
+        // `xml/xsd-declared-name-lines` fails on each of them in turn:
+        //
+        //   tag 27 / attribute 28 / value 28   `<xsd:attribute` + `name="X"` on 28
+        //        — attribute and value share a line, the tag does not. Testing the
+        //          value's row alone anchors to the element and reports 27.
+        //   tag 23 / attribute 23 / value 24   `<xsd:element name=` + `"X"` on 24
+        //        — tag and attribute share a line, the value does not. Testing the
+        //          attribute's row alone anchors to the element and reports 23.
+        //
+        // All three on one line is the only shape where the element's row and the
+        // attribute's row are the same row, which is the whole reason the element
+        // anchor is line-safe.
+        allOnOneLine: node.startPosition.row === tagNode.startPosition.row && valueNode.startPosition.row === node.startPosition.row
+      };
+    }
+    return null;
+  }
+  /**
+   * Splits on runs of whitespace as a CHAR WALK, never a regex.
+   *
+   * `schemaLocation` is the one attribute whose value is a token list rather than
+   * a single name, and tokenising it is the only place this analyzer needs to cut
+   * a value into words. `\s` was doing that job and it was the analyzer's last
+   * regex — which made this doc's "zero regex usages" claim false and left the
+   * machine census carrying that line as `needs_review` with an empty
+   * justification. The census and the doc disagreed and the census was right.
+   *
+   * The character set is spelled out rather than borrowed from `\s` so the
+   * behaviour is pinned to a stated set — space, tab, LF, CR, the XML `S`
+   * production — instead of to a regex dialect.
+   */
+  /**
+   * XML Schema's `collapse` whiteSpace facet, as a char walk.
+   *
+   * Every run of space/tab/LF/CR becomes ONE space, and the ends are trimmed.
+   * This is the transformation the `collapse` facet defines, and it is NOT the
+   * same as trimming: `"a  b"` collapses to `"a b"` rather than `"ab"`. Applied to
+   * a QName-typed attribute value before the value is read as a name — see the
+   * call site in the reference pass for why that matters and why an interior
+   * space must still be refused afterwards.
+   */
+  static collapseWhitespace(text) {
+    const out = [];
+    let pendingSpace = false;
+    let sawAny = false;
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === 32 || c === 9 || c === 10 || c === 13) {
+        if (sawAny) pendingSpace = true;
+        continue;
+      }
+      if (pendingSpace) {
+        out.push(" ");
+        pendingSpace = false;
+      }
+      out.push(text[i]);
+      sawAny = true;
+    }
+    return out.join("");
+  }
+  static splitOnWhitespace(text) {
+    const parts = [];
+    let start = -1;
+    for (let i = 0; i <= text.length; i++) {
+      const c = i < text.length ? text.charCodeAt(i) : 32;
+      if (c === 32 || c === 9 || c === 10 || c === 13) {
+        if (start >= 0) {
+          parts.push(text.slice(start, i));
+          start = -1;
+        }
+      } else if (start < 0) {
+        start = i;
+      }
+    }
+    return parts;
+  }
+  /**
+   * Does `text` contain any code point JavaScript's `\s` matches?
+   *
+   * This is the analyzer's LAST regular expression, deleted. It stood at the
+   * `PEReference` branch as `/\s/.test(ref)` — the predicate separating a parameter
+   * entity REFERENCE (`%name;`) from the VALUE form (`% name '...'`) — and the doc
+   * already claimed zero regex usages while the machine census carried that line as
+   * unremoved. The census and the doc disagreed and the census was right.
+   *
+   * ## Why the class is spelled out and NOT narrowed to XML's own `S`
+   *
+   * The obvious replacement is {@link splitOnWhitespace}, since XML 1.0 §2.3 `S` is
+   * `[ \t\r\n]` and that is the only whitespace a document may use BETWEEN tokens.
+   * Narrowing to it is a behaviour change, and it was measured rather than assumed:
+   * `validation/m14/fixtures/xml/pereference-shape-probe.mts` runs the deleted
+   * predicate (`\s`), the narrowed one (`S`) and a `Name`-child lookup over every
+   * `PEReference` node obtainable from the corpus, the lane's fixtures and eight
+   * synthetic shapes.
+   *
+   *   - corpus: 0 nodes. The branch is not exercised by the fixture corpus
+   *     at all, so no corpus number can decide this. The 22 admitted files whose
+   *     text contains `<!ENTITY %` are bare `.dtd` fragments, which this grammar
+   *     cannot root (no `document`), and the one admitted `.xml` — libxslt's
+   *     `tests/xmlspec/REC-xml-20001006.xml` — carries its `<!ENTITY %` inside
+   *     `CDSect`/`CDATA`, i.e. documentation ABOUT parameter entities.
+   *   - fixtures: 4 nodes, `\s` and `S` agree on 4 of 4.
+   *   - synthetic: 7 nodes, `\s` and `S` agree on 6 of 7. The one disagreement is
+   *     `%p<U+00A0>e;`, where `\s` drops it and `S` publishes a symbol named
+   *     `p<U+00A0>e` — a name no XML parser would accept, since `Name` is
+   *     `[a-zA-Z_][a-zA-Z0-9_:.·-]*`. On that single node the wider class is the
+   *     better answer, so this keeps it.
+   *
+   * ## Why the code points are listed rather than inherited
+   *
+   * The set is ECMAScript's `WhiteSpace` and `LineTerminator` productions, written
+   * out so the behaviour is pinned to a stated list rather than to a dialect. It is
+   * 25 code points and `isEcmaWhitespace` is total over them, which is what makes
+   * this a replacement rather than an approximation: for any string, the answer is
+   * identical to the deleted expression's, because both ask the same per-character
+   * question and a character class is a per-character question.
+   *
+   * A narrower class WOULD be defensible here on XML grounds, and is recorded as a
+   * limitation rather than shipped, because shipping it would change one measured
+   * verdict on a shape the corpus cannot produce, which is the trade this lane has
+   * no evidence to make.
+   */
+  static containsEcmaWhitespace(text) {
+    for (let i = 0; i < text.length; i++) {
+      if (_RealXmlAnalyzer.isEcmaWhitespace(text.charCodeAt(i))) return true;
+    }
+    return false;
+  }
+  /** ECMAScript `\s`: `WhiteSpace` + `LineTerminator`. 25 code points, total. */
+  static isEcmaWhitespace(c) {
+    if (c === 32 || c === 9 || c === 10 || c === 13) return true;
+    if (c === 11 || c === 12) return true;
+    if (c === 160) return true;
+    if (c === 5760) return true;
+    if (c >= 8192 && c <= 8202) return true;
+    if (c === 8232 || c === 8233) return true;
+    if (c === 8239 || c === 8287) return true;
+    if (c === 12288) return true;
+    if (c === 65279) return true;
+    return false;
+  }
+  isSchemaConstruct(name) {
+    const separator = name.lastIndexOf(":");
+    const localName = separator >= 0 ? name.slice(separator + 1) : name;
+    switch (localName) {
+      case "schema":
+      case "element":
+      case "attribute":
+      case "complexType":
+      case "simpleType":
+      case "sequence":
+      case "choice":
+      case "all":
+      case "group":
+      case "attributeGroup":
+      case "notation":
+      case "import":
+      case "include":
+      case "redefine":
+      case "annotation":
+      case "documentation":
+      case "appinfo":
+      case "any":
+      case "anyAttribute":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * The DECLARATION a node sits inside, for a reference inside replacement text.
+   *
+   * `<!ENTITY % shared "… %other; …">` makes `shared` depend on `other`, and the
+   * owner of that use is `shared` — not the DOCTYPE, and not an element. Same
+   * reasoning as the `GEDecl` EntityValue case, reached by walking up to the
+   * nearest declaration rather than by descending into it, because the reference
+   * may be nested inside arbitrary markup in the replacement text.
+   */
+  enclosingDeclaredName(node) {
+    let cur = node.parent;
+    let depth = 0;
+    while (cur && depth < 12) {
+      if (cur.type === "GEDecl" || cur.type === "PEDecl" || cur.type === "NotationDecl") {
+        const name = this.findDirectChild(cur, "Name")?.text.trim();
+        return name && name.length > 0 ? name : null;
+      }
+      cur = cur.parent;
+      depth++;
+    }
+    return null;
+  }
+  /**
+   * Is this node inside a region the PARSER could not read?
+   *
+   * Walks up rather than asking the file: `errorNodes` is a whole-file count and
+   * would label every edge in a partly-damaged document, which is the opposite of
+   * what `recovery` is for. libxml2's `test/errors/*` is a corpus of
+   * deliberately malformed documents whose only purpose is to be malformed, and
+   * their parameter references are assertions about bytes no processor would accept.
+   */
+  /**
+   * Is this node inside an entity's replacement text?
+   *
+   * Walks UP, deliberately: the question is about a node's POSITION, and asking
+   * the node itself for an `EntityValue` child cannot answer it. See the call site
+   * for what the first version got wrong.
+   */
+  withinEntityValue(node) {
+    let cur = node.parent;
+    let depth = 0;
+    while (cur && depth < 12) {
+      if (cur.type === "EntityValue") return true;
+      if (cur.type === "GEDecl" || cur.type === "PEDecl" || cur.type === "NotationDecl") return false;
+      cur = cur.parent;
+      depth++;
+    }
+    return false;
+  }
+  withinErrorRegion(node) {
+    let cur = node;
+    let depth = 0;
+    while (cur && depth < 24) {
+      if (cur.type === "ERROR") return true;
+      if (cur.isMissing) return true;
+      cur = cur.parent;
+      depth++;
+    }
+    return false;
+  }
+  findDirectChild(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === type) return child;
+    }
+    return null;
+  }
+  /**
+   * THE INCLUDED DOCUMENT'S MODULE STEM — the `part_of` target, for BOTH inclusion
+   * vocabularies this analyzer reads: XInclude's `<xi:include href>` and XSLT's
+   * `<xsl:include href>`.
+   *
+   * `part_of`'s contract allows "the part's file OR its module symbol", and this
+   * analyzer emits the SYMBOL because that is the only half the arbiter can bind: a
+   * PATH target resolved 0 of 4,612 `part_of` edges (100% unresolved) in cpp's
+   * measurement, because targets are resolved against SYMBOL NAMES. The path is kept
+   * on the row as `metadata.partPath`; this is the symbol-shaped spelling of the same
+   * fact.
+   *
+   * An href is a URI reference (RFC 3986): a `#fragment` selects a part of the
+   * target, and a `?query` is not part of a file name, so both are cut BEFORE the
+   * basename is taken — otherwise `intro.xml#sec2` would yield `xml#sec2`. The
+   * directory segments are dropped and the extension is dropped, so
+   * `sections/intro.xml` and `../shared/intro.xml` both name the module `intro`,
+   * which is what a consumer sees. A dot at position 0 (`.hidden`) is not an
+   * extension separator, so that name is kept whole.
+   *
+   * PURE CHARACTER SCAN, never a pattern: the analyzer's no-regex rule is a
+   * committed gate, and this is string arithmetic on a path, not a shape search.
+   */
+  static includedModuleStem(href) {
+    let end = href.length;
+    const hash = href.indexOf("#");
+    if (hash >= 0 && hash < end) end = hash;
+    const query = href.indexOf("?");
+    if (query >= 0 && query < end) end = query;
+    const pathOnly = href.slice(0, end);
+    const slash = pathOnly.lastIndexOf("/");
+    const base = slash >= 0 ? pathOnly.slice(slash + 1) : pathOnly;
+    const dot = base.lastIndexOf(".");
+    const stem = dot > 0 ? base.slice(0, dot) : base;
+    return stem.trim();
+  }
+  /**
+   * A named `Attribute` child of a tag node, by attribute name.
+   *
+   * Read off the TREE rather than off the tag's text: an attribute name is a `Name`
+   * child inside an `Attribute` node, and three sibling attributes on one tag differ
+   * only in which of their own `Name` children says `match`. Splitting the tag's text
+   * would have to re-tokenise, and would match an attribute NAME that appears inside
+   * another attribute's VALUE.
+   */
+  findDirectAttribute(tagNode, attrName) {
+    for (let i = 0; i < tagNode.namedChildCount; i++) {
+      const attr = tagNode.namedChild(i);
+      if (attr?.type !== "Attribute") continue;
+      const nameNode = this.findDirectChild(attr, "Name");
+      const text = nameNode?.text.trim();
+      if (text === attrName) return attr;
+    }
+    return null;
+  }
+  /**
+   * An attribute's value, unquoted and with the XML Schema `collapse` facet applied.
+   *
+   * `unquote` rather than a pattern, for the reason the rest of this analyzer spells
+   * out: an `AttValue` is `"…"` or `'…'` in the tree, and only the quote characters
+   * need removing. Returns `null` for an attribute written with no value, which is a
+   * different thing from an empty value and must not collapse to `""`.
+   */
+  attributeValueOf(tagNode, attrName) {
+    const attr = this.findDirectAttribute(tagNode, attrName);
+    if (!attr) return null;
+    const valueNode = this.findDirectChild(attr, "AttValue");
+    if (!valueNode) return null;
+    return _RealXmlAnalyzer.collapseWhitespace(this.unquote(valueNode.text.trim()));
+  }
+  findFirstNamedChild(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && types.has(child.type)) return child;
+    }
+    return null;
+  }
+  descendantsOfType(node, type) {
+    const out = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      for (let i = 0; i < current.namedChildCount; i++) {
+        const child = current.namedChild(i);
+        if (!child) continue;
+        if (child.type === type) out.push(child);
+        stack.push(child);
+      }
+    }
+    return out;
+  }
+  /**
+   * THE SAME-FILE TIER — a BOUNDED fix for 366 edges of this lane's ~9,131 residual, and not a fix for
+   * the lane. Sized from a POPULATION-scope run of the lane's own `ambiguity-split.mts`
+   * (`validation/m14/fixtures/xml/measurements/ambiguity-split-population.txt`): the same-file bucket (B1)
+   * totals 1,798 across every type — references 189 · extends 173 · calls 4 · overrides 0, plus 1,432
+   * `contains` which production ALREADY binds through `containsLike` and which is therefore not part of
+   * the residual. So the tier reaches 366, and the commit that lands it says exactly that, because the
+   * next reader would otherwise inherit a 600-file draw's 279 as the lane's shape — which is how the
+   * assignment that produced this file's measurement was written in the first place.
+   *
+   * THE RULE, and why it cannot be wrong: the lane ALREADY computes a two-part identity
+   * (`qualifiedName = ownerName + "." + name`, `:780` and `:934`) and then hands the graph the BARE name,
+   * because `addRelationship` takes two strings. `src/ast/parallel-indexer.ts:3435-3437` already looks up
+   * `name === target` and then `qualifiedName === target`. So emitting the qualified form is readable to
+   * the store WITHOUT changing the store. An edge is qualified only when the file declares its target
+   * under EXACTLY ONE owner — `set.size === 1` — so there is no choice to make and no preference to
+   * invent, which is the difference between a tier and a guess. Zero owners leaves it bare (nothing to
+   * name) and two or more leaves it bare (still ambiguous, and the tier does not pretend otherwise).
+   *
+   * The BARE name is preserved as `metadata.bareTarget`, so nothing is lost and a consumer that matched
+   * the old spelling can still see it.
+   */
+  /**
+   * THE FILE CLAIM — the ~466-edge lever, taken through infrastructure that ALREADY EXISTS.
+   *
+   * The lane's own note above the DOCTYPE emission says a file claim "REFUTES when no candidate is an
+   * admitted file, and `extFAIL` must stay 0" — and that is true of an UNGUARDED claim. It is not true of
+   * `fileClaimForTarget` (`src/ast/file-claim.ts:137`), whose whole contract is the opposite: it returns
+   * the project-relative path ONLY when a candidate is CONFIRMED, and null otherwise, "because an
+   * unconfirmed claim is what REFUTES". Two lanes already use it in production — `real-clean-analyzer.ts`
+   * and `real-graphql-analyzer.ts` — and `resolveImportTargets` (`src/ast/import-resolution.ts:382`) is
+   * wired into the indexer at `parallel-indexer.ts:5015` and `:5561`. So this is a USE of a channel rather
+   * than a file model to build.
+   *
+   * WHAT IT DOES TO THE COLUMNS: the arbiter's `projectFile` branch is the one claim it can CHECK against
+   * the project's own file list (`verifyFileClaim`), so a confirmed claim moves an edge out of
+   * `unresolved` and into `extOK` — a claim the project VERIFIES, which is what clause 1 asks for and is
+   * a RESOLUTION in the owner's standard rather than a ruling. An edge whose path cannot be confirmed is
+   * left exactly as it was: no claim, no refutation, extFAIL stays zero.
+   *
+   * ── THE NEGATIVE HALF OF THE SAME CLAIM, WHICH WAS THE UNSTATED HOLE ────────────────────────────
+   *
+   * The file claim above can only ever say "the file IS here". When the file is not here the edge said
+   * NOTHING checkable, and the incoming gate counted it as `unresolved` — this lane's largest unresolved
+   * class: **60 of its 72 whole-population unresolved edges (83.3 %), all of them `imports`** (39
+   * `schemaLocation` paths + 21 external-ID `SYSTEM` paths; measured at HEAD `fb93f6f18`, recorded in
+   * `validation/m14/verification/XML-FIX.md` §2.2). The analyzer already computes the reason —
+   * `importTargetClass` returns `resolvable: "file"` for exactly this shape (`:2780`) — and then
+   * publishes it on a key the gate does not read. That is the fleet-wide cause (a) of
+   * `RESIDUAL-CLASSIFICATION-41-LANES.md:20-34`, present on this lane.
+   *
+   * So the negative half is published as `sourcePathClaim`, the claim kind the arbiter ALREADY verifies
+   * (`SOURCE_PATH_CLAIM_KEY`, `script/m14/incoming-rule.ts:321-337`, `classifyEdge`'s inverted-polarity
+   * branch): *nothing the project ADMITS resolves to this written source string*. No new channel, no new
+   * marker spelling, no claim the project cannot check.
+   *
+   * WHY THIS CAN NEVER REFUTE, which is the property `extFAIL` 0 depends on: the gate's verdict for this
+   * claim is a pure function of `facts.files` (the admitted-file list), and `facts.files` is a SUBSET of
+   * the files that exist on disk. Before attaching, every spelling the gate's `sourcePathCandidates`
+   * tests — plus separator-normalised variants of them — is checked against the filesystem under the
+   * project root (`isFileAbsentFromProject`). If ANY candidate exists as a regular file, the claim is NOT
+   * attached and the edge is left exactly as it was. So "claim attached" implies "no candidate can be in
+   * `facts.files`" implies "the gate cannot refute it" — by construction, not by measurement luck.
+   *
+   * AND THE SHAPE GUARD IS NOT THE BARE-NAME LAUNDERING HOLE THE CLAIM'S OWN RULE WARNS ABOUT: the claim
+   * is attached only to an `imports` target the LANE classified `resolvable: "file"`, and only when it is
+   * spelled as a path (a separator) or ends in one of THIS LANE's seven admitted file extensions.
+   * `imports` targets are created from `SystemLiteral`/`schemaLocation` attribute text — a file reference
+   * by construction, never a declaration name — and a target ending in `.dtd`/`.xsd`/… cannot be a
+   * published symbol in this lane's key space in any ordinary document. What is refused is the bare word
+   * with no file spelling (`SYSTEM "foo"`), which is exactly where the "could also name a declaration"
+   * risk the claim's contract names actually lives.
+   */
+  attachFileClaims(relationships, filePath, context) {
+    const projectRoot = typeof context?.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
+    if (projectRoot === null) return;
+    for (const rel of relationships) {
+      if (String(rel.type ?? "") !== ASTEngine.RelationshipType.Imports) continue;
+      const md = rel.metadata ?? {};
+      if (typeof md.importProjectFile === "string") continue;
+      const written = String(rel.target ?? "");
+      if (written.length === 0) continue;
+      const claim = fileClaimForTarget({
+        projectRoot,
+        filePath,
+        written,
+        admittedExtensions: [..._RealXmlAnalyzer.IMPORT_FILE_EXTENSIONS]
+      });
+      if (claim !== null) {
+        md.importProjectFile = claim;
+        rel.metadata = md;
+        continue;
+      }
+      if (md.resolvable !== "file") continue;
+      if (!this.isPathShapedImportTarget(written)) continue;
+      if (!this.isFileAbsentFromProject(projectRoot, written)) continue;
+      md.sourcePathClaim = [written];
+      rel.metadata = md;
+    }
+  }
+  /**
+   * IS THIS `imports` TARGET SPELLED AS A FILE? — the guard for the negative file claim.
+   *
+   * A target with a path separator is a path. A target with no separator is a FILE only when it
+   * carries a file EXTENSION this lane admits — the vocabulary comes from `IMPORT_FILE_EXTENSIONS`,
+   * the same set the positive file claim is checked against, so the two halves of the claim cannot
+   * disagree about what a file of this lane is. A bare word with no file spelling (`SYSTEM "foo"`)
+   * is refused, because that is the one shape that could also be a declaration name.
+   */
+  isPathShapedImportTarget(written) {
+    if (written.includes("/") || written.includes("\\")) return true;
+    const dot = written.lastIndexOf(".");
+    if (dot <= 0 || dot === written.length - 1) return false;
+    return _RealXmlAnalyzer.IMPORT_FILE_EXTENSIONS.has(written.slice(dot + 1).toLowerCase());
+  }
+  /**
+   * NO SPELLING OF THIS TARGET IS A FILE UNDER THE PROJECT ROOT — the proof that the negative file
+   * claim cannot be refuted by the arbiter.
+   *
+   * The candidate arithmetic MIRRORS the gate's `sourcePathCandidates` (`incoming-rule.ts:344-353`:
+   * the written string, `./`-stripped, `../`-stripped, the dot-segment-joined path, the basename)
+   * and is a SUPERSET of it (separator normalisation is added), so a spelling the gate would test can
+   * never be missing here. A superset is the safe direction: a candidate this guard sees but the gate
+   * does not can only make the guard refuse a claim (the edge stays unresolved, never refuted).
+   *
+   * It is a REFUSAL, never a resolution: it returns true only when nothing was found, and its only
+   * effect is to suppress a claim.
+   *
+   * PURE CHARACTER SCANS, no patterns. Each of the three normalisations below is a shape test on a
+   * FIXED PREFIX or a single character, which is what a pattern would be doing too — only a pattern
+   * reaches back into the source text to do it, and this analyzer's no-regex rule is a committed
+   * gate (script/m14/no-regex-gate.sh). The three replacements are behaviour-identical to the
+   * patterns they replace, stated here so the equivalence is checkable: every backslash becomes a
+   * slash; a leading `./` is dropped; a leading `../` is dropped (and `./../x` therefore becomes
+   * `../x`, exactly as `.replace(/^\.\//, "")` did).
+   */
+  isFileAbsentFromProject(projectRoot, written) {
+    const trimmed = written.trim();
+    let normalised = "";
+    for (const ch of trimmed) normalised += ch === "\\" ? "/" : ch;
+    const segments = normalised.split("/").filter((s) => s.length > 0 && s !== "." && s !== "..");
+    const candidates = /* @__PURE__ */ new Set([
+      trimmed,
+      normalised,
+      normalised.startsWith("./") ? normalised.slice(2) : normalised,
+      normalised.startsWith("../") ? normalised.slice(3) : normalised,
+      segments.join("/"),
+      segments.length > 0 ? segments[segments.length - 1] : ""
+    ]);
+    for (const candidate of candidates) {
+      if (candidate.length === 0 || candidate.startsWith("/")) continue;
+      if (candidate === ".." || candidate.startsWith("../")) continue;
+      try {
+        if (statSync(path.join(projectRoot, candidate)).isFile()) return false;
+      } catch {
+      }
+    }
+    return true;
+  }
+  qualifySameFileTier(symbols, relationships) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const sym of symbols) {
+      const n = String(sym.name ?? "");
+      const q = String(sym.qualifiedName ?? "");
+      if (n.length === 0 || q.length === 0 || q === n) continue;
+      let set = byName.get(n);
+      if (!set) byName.set(n, set = /* @__PURE__ */ new Set());
+      set.add(q);
+    }
+    const TIER_TYPES = /* @__PURE__ */ new Set(["references", "extends", "calls", "uses", "overrides"]);
+    for (const rel of relationships) {
+      if (!TIER_TYPES.has(String(rel.type ?? ""))) continue;
+      const target = String(rel.target ?? "");
+      const qs = byName.get(target);
+      if (qs === void 0 || qs.size !== 1) continue;
+      const md = rel.metadata ?? {};
+      md.bareTarget = target;
+      rel.metadata = md;
+      rel.target = [...qs][0];
+    }
+  }
+  unquote(text) {
+    if (text.length >= 2) {
+      const first = text[0];
+      const last = text[text.length - 1];
+      if ((first === '"' || first === "'") && first === last) return text.slice(1, -1);
+    }
+    return text;
+  }
+  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
+    };
+  }
+};
+export {
+  RealXmlAnalyzer
+};