@ui-manifest-json/core 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export * from './types/dom.js';
+export * from './types/source.js';
+export * from './types/uncapturable.js';
 export * from './types/component.js';
 export * from './types/route.js';
 export * from './types/provenance.js';
@@ -7,6 +9,7 @@ export * from './types/manifest.js';
 export { resolveFullPaths } from './full-path.js';
 export { collectRepoProvenance, generatorProvenance } from './provenance.js';
 export type { CollectProvenanceOptions } from './provenance.js';
+export { collapseDom, enrichDom, controlTypeFor, selectorCandidatesFor, testidOf, TESTID_ATTRS } from './semantics.js';
 export { resolveRouteDependencyTree } from './resolve-tree.js';
 export type { MatchFn } from './resolve-tree.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,YAAY,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,YAAY,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,qBAAqB,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACvH,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -1,4 +1,6 @@
 export * from './types/dom.js';
+export * from './types/source.js';
+export * from './types/uncapturable.js';
 export * from './types/component.js';
 export * from './types/route.js';
 export * from './types/provenance.js';
@@ -6,4 +8,5 @@ export * from './types/dependency-graph.js';
 export * from './types/manifest.js';
 export { resolveFullPaths } from './full-path.js';
 export { collectRepoProvenance, generatorProvenance } from './provenance.js';
+export { collapseDom, enrichDom, controlTypeFor, selectorCandidatesFor, testidOf, TESTID_ATTRS } from './semantics.js';
 export { resolveRouteDependencyTree } from './resolve-tree.js';

package/dist/semantics.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The pass that turns a raw parse tree into something a consumer can JOIN against a live DOM.
+ *
+ * Framework-agnostic on purpose: both extractors produce the same `DomNode` union, and every rule
+ * here reads only that union. Angular's parser and React's differ entirely in how they find a
+ * conditional; by the time a tree reaches this module the conditional is a `TemplateNode` either
+ * way.
+ *
+ * Three things happen here, and each removes work a consumer would otherwise have to do — wrongly,
+ * and once per consumer:
+ *
+ * **Static text is folded into its element.** A `<button>Sign In</button>` parses as an element
+ * with a text child. Keyed on its own, that button has no handle at all: no id, no name, no
+ * testid — which describes most buttons in most apps. Folding the text up is what makes it
+ * addressable. An interpolation is deliberately NOT folded: a key built from `{{ user.name }}`
+ * changes with the test data.
+ *
+ * **Ancestry is denormalized.** Every structural branch between the root and an element is copied
+ * onto that element as `conditionChain`. This is what lets the tree drop presentational wrappers
+ * without losing anything, and it is what turns "why is this field not on the page?" from a
+ * repository search into a field read.
+ *
+ * **Handles are enumerated, and their absence is reported.** `tokenStability: "none"` on a control
+ * means the source offers no stable way to address it. With a file and a line attached, that is
+ * the single most actionable line this whole format produces: *add a `data-testid` here*.
+ */
+import type { ControlType, DomNode, ElementNode, SelectorCandidate } from './types/dom.js';
+/**
+ * Drop presentational wrappers, splicing their children into their place.
+ *
+ * Safe only because `conditionChain` is denormalized onto every element: nothing downstream needs
+ * the ancestors this removes. Run BEFORE enrichment so text folding and uniqueness both see the
+ * final tree. Returns how many nodes went, because a consumer must be able to tell that the tree
+ * it is reading is not the DOM.
+ */
+export declare function collapseDom(nodes: DomNode[]): {
+    dom: DomNode[];
+    collapsed: number;
+};
+/** The attribute names a test-id may be spelled with, in the order a consumer should prefer. */
+export declare const TESTID_ATTRS: readonly ["data-testid", "data-test-id", "data-test", "data-qa", "data-cy"];
+export declare function testidOf(attrs: Record<string, string>): string | undefined;
+/**
+ * What a person can DO with this element.
+ *
+ * Driven off the tag and `type` rather than the role attribute, because the role is usually
+ * absent and the tag almost never is. `<input type="submit">` is a BUTTON — it is spelled as an
+ * input but it submits, and treating it as a textbox is how a submit control ends up expected to
+ * accept typing.
+ */
+export declare function controlTypeFor(el: string, attrs: Record<string, string>): ControlType | undefined;
+/** Every handle the SOURCE offers for this element, best first. Audit material, not a locator. */
+export declare function selectorCandidatesFor(node: ElementNode, staticText?: string): SelectorCandidate[];
+/**
+ * Walk a parsed tree and enrich every element in place.
+ *
+ * Returns every element it visited, in template order, so the caller can run whole-template passes
+ * (uniqueness) without walking again. Order is template order because two elements sharing a
+ * handle should collide in a stable order rather than whichever the walk happened to reach first.
+ */
+export declare function enrichDom(nodes: DomNode[]): ElementNode[];
+//# sourceMappingURL=semantics.d.ts.map

package/dist/semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../src/semantics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EACK,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EACpE,MAAM,gBAAgB,CAAC;AAoCxB;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG;IAAE,GAAG,EAAE,OAAO,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CA4BnF;AAED,gGAAgG;AAChG,eAAO,MAAM,YAAY,6EAA8E,CAAC;AAExG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS,CAM1E;AAKD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,WAAW,GAAG,SAAS,CAwBjG;AAUD,kGAAkG;AAClG,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAejG;AA2FD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,WAAW,EAAE,CAqEzD"}

package/dist/semantics.js

@@ -0,0 +1,325 @@
+/** Attributes that make an element addressable, and so make it worth keeping. */
+const MEANINGFUL_ATTRS = [
+    'id', 'name', 'placeholder', 'role', 'title', 'href', 'src', 'type', 'value', 'for',
+    'routerLink', 'formControlName', 'formGroupName', 'formArrayName',
+];
+/**
+ * A node that exists only to position other nodes.
+ *
+ * The rule is narrow on purpose. A `div` holding nothing but a class and OTHER ELEMENTS is
+ * layout; a `div` holding text is the text's element, and dropping it would leave the text with
+ * nothing to hang on — including, decisively, nothing for a `conditionChain` to be attached to.
+ * `<div class="error-message">{{ errorMessage }}</div>` under an `*ngIf` is the whole answer to
+ * "why is this not on the page?", and it looks exactly like a wrapper until you notice it wraps
+ * no element.
+ */
+function isPresentationalWrapper(node) {
+    const tag = node.el.toLowerCase();
+    if (tag !== 'div' && tag !== 'span')
+        return false;
+    if (node.el.includes('-'))
+        return false;
+    if (node.events.length || node.props.length)
+        return false;
+    if (node.refs?.length)
+        return false;
+    for (const key of Object.keys(node.attrs)) {
+        if (key === 'class' || key === 'style')
+            continue;
+        if (key.startsWith('aria-') || key.startsWith('data-'))
+            return false;
+        if (MEANINGFUL_ATTRS.includes(key))
+            return false;
+        return false;
+    }
+    // It must wrap at least one ELEMENT, and carry no text of its own.
+    const hasElementChild = node.children.some(c => c.type === 'element' || c.type === 'template');
+    const hasOwnText = node.children.some(c => c.type === 'text' || c.type === 'interpolation');
+    return hasElementChild && !hasOwnText;
+}
+/**
+ * Drop presentational wrappers, splicing their children into their place.
+ *
+ * Safe only because `conditionChain` is denormalized onto every element: nothing downstream needs
+ * the ancestors this removes. Run BEFORE enrichment so text folding and uniqueness both see the
+ * final tree. Returns how many nodes went, because a consumer must be able to tell that the tree
+ * it is reading is not the DOM.
+ */
+export function collapseDom(nodes) {
+    let collapsed = 0;
+    const rewrite = (list) => {
+        const out = [];
+        for (const node of list) {
+            if (node.type === 'template') {
+                node.children = rewrite(node.children);
+                for (const branch of node.branches ?? [])
+                    branch.children = rewrite(branch.children);
+                out.push(node);
+                continue;
+            }
+            if (node.type !== 'element') {
+                out.push(node);
+                continue;
+            }
+            node.children = rewrite(node.children);
+            if (isPresentationalWrapper(node)) {
+                collapsed += 1;
+                out.push(...node.children);
+                continue;
+            }
+            out.push(node);
+        }
+        return out;
+    };
+    return { dom: rewrite(nodes), collapsed };
+}
+/** The attribute names a test-id may be spelled with, in the order a consumer should prefer. */
+export const TESTID_ATTRS = ['data-testid', 'data-test-id', 'data-test', 'data-qa', 'data-cy'];
+export function testidOf(attrs) {
+    for (const name of TESTID_ATTRS) {
+        const value = attrs[name];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+/** Tags that are interactive by nature, so an element bearing one is a control even with no role. */
+const CONTROL_TAGS = new Set(['input', 'select', 'textarea', 'button', 'a', 'option']);
+/**
+ * What a person can DO with this element.
+ *
+ * Driven off the tag and `type` rather than the role attribute, because the role is usually
+ * absent and the tag almost never is. `<input type="submit">` is a BUTTON — it is spelled as an
+ * input but it submits, and treating it as a textbox is how a submit control ends up expected to
+ * accept typing.
+ */
+export function controlTypeFor(el, attrs) {
+    const tag = el.toLowerCase();
+    const type = (attrs.type ?? '').toLowerCase();
+    if (tag === 'a')
+        return 'link';
+    if (tag === 'button')
+        return 'button';
+    if (tag === 'textarea')
+        return 'textbox';
+    if (tag === 'select')
+        return attrs.multiple !== undefined ? 'listbox' : 'combobox';
+    if (tag === 'input') {
+        if (type === 'checkbox')
+            return 'checkbox';
+        if (type === 'radio')
+            return 'radio';
+        if (type === 'file')
+            return 'fileinput';
+        if (type === 'range')
+            return 'slider';
+        if (type === 'date' || type === 'datetime-local' || type === 'month' || type === 'week')
+            return 'datepicker';
+        // submit/button/reset/image are buttons wearing an input's tag.
+        if (type === 'submit' || type === 'button' || type === 'reset' || type === 'image')
+            return 'button';
+        return 'textbox';
+    }
+    const role = (attrs.role ?? '').toLowerCase();
+    if (role === 'button' || role === 'link' || role === 'checkbox' || role === 'radio'
+        || role === 'combobox' || role === 'listbox' || role === 'textbox' || role === 'tab'
+        || role === 'grid' || role === 'slider') {
+        return role;
+    }
+    return undefined;
+}
+function isControl(node) {
+    const tag = node.el.toLowerCase();
+    if (CONTROL_TAGS.has(tag))
+        return true;
+    if (node.attrs.role)
+        return true;
+    // A custom element wired to a click is a control however it is spelled.
+    return node.events.some(e => e.kind !== 'twoWayWriteback');
+}
+/** Every handle the SOURCE offers for this element, best first. Audit material, not a locator. */
+export function selectorCandidatesFor(node, staticText) {
+    const out = [];
+    const { attrs } = node;
+    const tag = node.el.toLowerCase();
+    const push = (by, value) => out.push({ by, value, unique: false, uniqueScope: 'template' });
+    const testid = testidOf(attrs);
+    if (testid)
+        push('testid', `[data-testid="${testid}"]`);
+    if (attrs.id)
+        push('id', `#${attrs.id}`);
+    if (attrs.name)
+        push('name', `${tag}[name="${attrs.name}"]`);
+    if (attrs['aria-label'])
+        push('aria', `${tag}[aria-label="${attrs['aria-label']}"]`);
+    if (attrs.placeholder)
+        push('placeholder', `${tag}[placeholder="${attrs.placeholder}"]`);
+    if (staticText)
+        push('text', staticText);
+    return out;
+}
+/**
+ * Mark which candidates are unique WITHIN THIS TEMPLATE.
+ *
+ * Scoped to the template and labelled as such, because that is the only claim a static pass can
+ * honestly make: one page is composed of a shell plus a route component, so a value unique in its
+ * own file can still collide once rendered. Saying `uniqueScope: "template"` is the difference
+ * between a weaker claim and a wrong one.
+ */
+function markUniqueness(elements) {
+    const counts = new Map();
+    for (const el of elements) {
+        for (const c of el.selectorCandidates ?? []) {
+            counts.set(`${c.by} ${c.value}`, (counts.get(`${c.by} ${c.value}`) ?? 0) + 1);
+        }
+    }
+    for (const el of elements) {
+        for (const c of el.selectorCandidates ?? []) {
+            c.unique = counts.get(`${c.by} ${c.value}`) === 1;
+        }
+    }
+}
+/**
+ * Does this element carry a stable handle, an expression-derived one, or none at all?
+ *
+ * `none` is the interesting answer and the reason this field exists: reported with a file and a
+ * line it becomes an actionable finding, where the same element simply missing from a join reads
+ * as noise.
+ */
+function tokenStabilityFor(node, staticText) {
+    const { attrs } = node;
+    if (testidOf(attrs) || attrs.id || attrs.name || attrs['aria-label'] || attrs.placeholder || staticText) {
+        return 'static';
+    }
+    const dynamic = node.props.find(p => p.name === 'id' || p.name === 'attr.id' || p.name === 'name' || p.name === 'attr.name'
+        || TESTID_ATTRS.some(t => p.name === t || p.name === `attr.${t}`));
+    if (dynamic)
+        return 'dynamic';
+    return isControl(node) ? 'none' : undefined;
+}
+/** The literal prefix of a dynamic handle, e.g. `[attr.id]="'tx-' + tx.id"`. */
+function tokenTemplateFor(node) {
+    const dynamic = node.props.find(p => p.name === 'id' || p.name === 'attr.id'
+        || TESTID_ATTRS.some(t => p.name === t || p.name === `attr.${t}`));
+    if (!dynamic)
+        return undefined;
+    const literal = /^\s*['"]([^'"]+)['"]\s*\+/.exec(dynamic.expr);
+    return literal ? `${literal[1]}{{*}}` : undefined;
+}
+/**
+ * An accessible name, and ONLY when the source actually declares one.
+ *
+ * Deliberately not falling back to `staticText`, which is the obvious version and is wrong. A
+ * consumer keys an element on the best handle it has, and an accessible name outranks raw text —
+ * so synthesising one from a caption turns `<button>Sign In</button>` into an `aria:Sign In` key,
+ * while a browser recording the same button (it has no `aria-label`) produces a `text:Sign In`
+ * one. The two never join, and they fail to join on exactly the elements whose only handle is
+ * their caption. `staticText` carries the caption; let the consumer decide what it is worth.
+ */
+function accessibleNameFor(node) {
+    return node.attrs['aria-label'] || node.attrs.title || undefined;
+}
+function isTruthyAttr(value) {
+    return value !== undefined && value !== 'false';
+}
+/** The gate a `TemplateNode` represents, as one link in a chain. */
+function linkFor(node, branch) {
+    return {
+        directive: node.structural,
+        expr: node.condition ?? '',
+        ...(branch ? { branch } : {}),
+        ...(node.source ? { source: node.source } : {}),
+    };
+}
+/** `@for`'s condition is written `item of items; track id` — split it back apart. */
+function repeatPartsOf(condition) {
+    if (!condition)
+        return {};
+    const match = /^\s*(\S+)\s+of\s+([^;]+?)\s*(?:;\s*track\s+(.+))?\s*$/.exec(condition);
+    if (!match)
+        return { over: condition.trim() || undefined };
+    return { varName: match[1], over: match[2]?.trim(), trackBy: match[3]?.trim() };
+}
+/**
+ * Walk a parsed tree and enrich every element in place.
+ *
+ * Returns every element it visited, in template order, so the caller can run whole-template passes
+ * (uniqueness) without walking again. Order is template order because two elements sharing a
+ * handle should collide in a stable order rather than whichever the walk happened to reach first.
+ */
+export function enrichDom(nodes) {
+    const seen = [];
+    const walk = (list, chain, repeat) => {
+        for (const node of list) {
+            if (node.type === 'template') {
+                const t = node;
+                const isFor = t.structural === '@for' || t.structural === '*ngFor' || t.structural === '.map()';
+                const parts = isFor ? repeatPartsOf(t.condition) : {};
+                const nextRepeat = isFor ? { ...parts, on: true } : repeat;
+                // The primary branch's children hang off `children`; every other branch off `branches`.
+                // `branches[0]` IS `children` for an @if/@switch, so walking both would visit the primary
+                // twice and give its elements a duplicated chain link.
+                walk(t.children, [...chain, linkFor(t)], nextRepeat);
+                for (const branch of (t.branches ?? []).slice(1)) {
+                    walk(branch.children, [...chain, linkFor(t, branch.label)], nextRepeat);
+                }
+                continue;
+            }
+            if (node.type !== 'element')
+                continue;
+            const el = node;
+            const staticParts = [];
+            let hasDynamicText = false;
+            for (const child of el.children) {
+                if (child.type === 'text' && child.value.trim())
+                    staticParts.push(child.value.trim());
+                if (child.type === 'interpolation')
+                    hasDynamicText = true;
+            }
+            const staticText = staticParts.join(' ').trim() || undefined;
+            if (staticText)
+                el.staticText = staticText;
+            if (hasDynamicText)
+                el.hasDynamicText = true;
+            const controlType = controlTypeFor(el.el, el.attrs);
+            if (controlType)
+                el.controlType = controlType;
+            const accessibleName = accessibleNameFor(el);
+            if (accessibleName)
+                el.accessibleName = accessibleName;
+            if (el.attrs.role)
+                el.role = el.attrs.role;
+            if (isTruthyAttr(el.attrs.required))
+                el.required = true;
+            if (el.el.includes('-'))
+                el.sourceRepresentation = el.el;
+            const stability = tokenStabilityFor(el, staticText);
+            if (stability)
+                el.tokenStability = stability;
+            const template = stability === 'dynamic' ? tokenTemplateFor(el) : undefined;
+            if (template)
+                el.tokenTemplate = template;
+            const candidates = selectorCandidatesFor(el, staticText);
+            if (candidates.length)
+                el.selectorCandidates = candidates;
+            if (chain.length) {
+                el.conditional = true;
+                el.conditionChain = chain;
+            }
+            if (repeat.on) {
+                el.repeated = true;
+                if (repeat.over)
+                    el.repeatOver = repeat.over;
+                if (repeat.varName)
+                    el.repeatVar = repeat.varName;
+                if (repeat.trackBy)
+                    el.repeatTrackBy = repeat.trackBy;
+            }
+            seen.push(el);
+            walk(el.children, chain, repeat);
+        }
+    };
+    walk(nodes, [], { on: false });
+    markUniqueness(seen);
+    return seen;
+}

package/dist/types/component.d.ts

@@ -1,4 +1,5 @@
 import type { DomNode } from './dom.js';
+import type { SourcePointer } from './source.js';
 export type PropertyBindingKind = 'decorator' | 'signal';
 /** An Angular @Input()/@Output() or input()/output() signal. */
 export interface PropertyBinding {
@@ -21,6 +22,15 @@ export interface ComponentNode {
     className: string;
     /** Repo-relative path to the file the component is defined in. */
     filePath: string;
+    /** The class declaration, with lines. `filePath` says which file; this says where in it. */
+    source?: SourcePointer;
+    /** The TEMPLATE, which for an external `templateUrl` is a different file entirely — and is
+     *  where every element's own pointer lands. Without this a consumer reading a component's
+     *  location gets the `.ts`, and every element in it points somewhere else. */
+    template?: {
+        source: SourcePointer;
+        inline: boolean;
+    };
     /** Angular only. */
     selector?: string;
     /** Angular only. */

package/dist/types/component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/types/component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEzD,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;AAE9D,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oDAAoD;IACpD,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,oDAAoD;IACpD,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,oDAAoD;IACpD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,iFAAiF;IACjF,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;CACjB"}
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/types/component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEzD,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;AAE9D,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB;;kFAE8E;IAC9E,QAAQ,CAAC,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IACtD,oBAAoB;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oDAAoD;IACpD,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,oDAAoD;IACpD,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,oDAAoD;IACpD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,iFAAiF;IACjF,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;CACjB"}

package/dist/types/dom.d.ts

@@ -9,6 +9,7 @@
  *   control-flow detection) rather than a grammar built for the purpose. Best-effort — the
  *   underlying JS could always route around the pattern in a way that isn't detected.
  */
+import type { SourcePointer } from './source.js';
 export type Extraction = 'compiler' | 'heuristic';
 export interface BaseNode {
     extraction: Extraction;
@@ -17,6 +18,17 @@ export interface BaseNode {
 export interface BoundExpr {
     name: string;
     expr: string;
+    /**
+     * What kind of binding this is.
+     *
+     * `[(ngModel)]` desugars into a property AND an event, and in v2 the write-back was
+     * indistinguishable from a real handler — so a consumer counting handlers got 20 where the app
+     * had 7, and every two-way-bound input looked interactive twice. `twoWayWriteback` marks the
+     * generated half.
+     */
+    kind?: 'dom' | 'output' | 'twoWay' | 'twoWayWriteback';
+    /** Where the handler METHOD is declared — the `.ts` file, not the template. */
+    handler?: SourcePointer;
 }
 /**
  * `Child` is generic so the resolved dependency-graph tree (packages/core/src/types/
@@ -36,7 +48,61 @@ export interface ElementNode<Child = DomNode> extends BaseNode {
     /** Template reference variables (#ref). Angular only. */
     refs?: string[];
     children: Child[];
+    /** Where this element is written. */
+    source?: SourcePointer;
+    /** STATIC child text only, folded from `TextNode` children and trimmed. An interpolation is
+     *  never text: a key built from one changes with the test data. */
+    staticText?: string;
+    /** True when any child was an interpolation — so "no staticText" can be told apart from
+     *  "the text is dynamic". */
+    hasDynamicText?: boolean;
+    /** `static`: a stable handle exists. `dynamic`: a token-bearing attribute is an expression
+     *  (`[attr.id]="'tx-' + tx.id"`), and `tokenTemplate` carries the literal prefix. `none`: this
+     *  control has no stable handle at all — which is the most actionable thing this file says. */
+    tokenStability?: 'static' | 'dynamic' | 'none';
+    tokenTemplate?: string;
+    controlType?: ControlType;
+    /** The tag as WRITTEN, when it differs from what renders (`mat-select` -> a listbox). */
+    sourceRepresentation?: string;
+    role?: string;
+    accessibleName?: string;
+    required?: boolean;
+    /** True when any ancestor is a structural branch. */
+    conditional?: boolean;
+    /** Every gate between the template root and this element, outermost first. */
+    conditionChain?: ConditionLink[];
+    repeated?: boolean;
+    repeatOver?: string;
+    repeatVar?: string;
+    repeatTrackBy?: string;
+    /**
+     * Handles the SOURCE offers for this element — audit material, never a locator to drive.
+     *
+     * `unique` computed within one template is a weaker claim than a live DOM's uniqueness: the
+     * shell and the route component both render into one page, so a token unique in its own file
+     * can still collide once composed. `uniqueScope` says which claim is being made.
+     */
+    selectorCandidates?: SelectorCandidate[];
 }
+/** One structural gate, as written in the template. */
+export interface ConditionLink {
+    /** `*ngIf`, `@if`, `@for`, `@switch`, `@defer`, ... */
+    directive: string;
+    /** The guiding expression. Free text with no grammar — treat it as data. */
+    expr: string;
+    /** Which branch of a multi-branch construct this element sits in (`if`, `else if`, `else`,
+     *  a `@switch` case label, `empty`, `placeholder`). */
+    branch?: string;
+    source?: SourcePointer;
+}
+export interface SelectorCandidate {
+    by: 'testid' | 'id' | 'name' | 'aria' | 'role' | 'placeholder' | 'text' | 'css';
+    value: string;
+    unique: boolean;
+    uniqueScope: 'template' | 'route';
+}
+/** What a person can DO with this element, independent of how it is spelled. */
+export type ControlType = 'textbox' | 'combobox' | 'listbox' | 'checkbox' | 'radio' | 'button' | 'link' | 'datepicker' | 'fileinput' | 'slider' | 'grid' | 'tab' | 'other';
 export interface TextNode extends BaseNode {
     type: 'text';
     value: string;
@@ -61,6 +127,7 @@ export interface TemplateNode<Child = DomNode> extends BaseNode {
     branches?: TemplateBranch<Child>[];
     /** The primary/consequent branch's children, kept so every DomNode has a `children` array. */
     children: Child[];
+    source?: SourcePointer;
 }
 export type DomNode = ElementNode | TextNode | InterpolationNode | TemplateNode;
 //# sourceMappingURL=dom.d.ts.map

package/dist/types/dom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/types/dom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAElD,MAAM,WAAW,QAAQ;IACvB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,mHAAmH;AACnH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,QAAQ;IAC5D,IAAI,EAAE,SAAS,CAAC;IAChB,sFAAsF;IACtF,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,wEAAwE;IACxE,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,qDAAqD;IACrD,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,KAAK,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,QAAS,SAAQ,QAAQ;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAkB,SAAQ,QAAQ;IACjD,IAAI,EAAE,eAAe,CAAC;IACtB,8FAA8F;IAC9F,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,QAAQ,GACR,KAAK,GACL,MAAM,GACN,SAAS,GACT,QAAQ,GACR,SAAS,GACT,IAAI,GACJ,QAAQ,CAAC;AAEb,MAAM,WAAW,cAAc,CAAC,KAAK,GAAG,OAAO;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,KAAK,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,YAAY,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,QAAQ;IAC7D,IAAI,EAAE,UAAU,CAAC;IACjB,UAAU,EAAE,cAAc,CAAC;IAC3B,iGAAiG;IACjG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;IACnC,8FAA8F;IAC9F,QAAQ,EAAE,KAAK,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,QAAQ,GAAG,iBAAiB,GAAG,YAAY,CAAC"}
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/types/dom.ts"],"names":[],"mappings":"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"}

package/dist/types/manifest.d.ts

@@ -1,7 +1,9 @@
 import type { ComponentNode } from './component.js';
 import type { RouteNode } from './route.js';
 import type { RouteDependencyTree } from './dependency-graph.js';
-import type { AppIdentity, Coverage, CoverageScope, Provenance } from './provenance.js';
+import type { AppIdentity, Coverage, CoverageScope, GeneratorProvenance, Provenance, RepoProvenance } from './provenance.js';
+import type { Uncapturable } from './uncapturable.js';
+import type { SourcePointer } from './source.js';
 /**
  * Bumped to "2.0" for the `app` block, whose two fields are REQUIRED — see `AppIdentity`. A
  * consumer needs exactly one field to test to know whether the routes it is about to read can be
@@ -16,16 +18,78 @@ export interface UiManifest {
      *  against a real URL, silently. See {@link AppIdentity}. */
     app: AppIdentity;
     /** Which commit, which extractor, which passes. Non-diffable — ignore it when diffing, the same
-     *  as `generatedAt`. */
+     *  as `generatedAt`.
+     *
+     *  Kept alongside the top-level `repo`/`generator` below rather than replaced by them: a
+     *  consumer written against the first 2.0 release reads this block, and breaking it would make
+     *  a field addition into a coordinated release. The two are the same objects. */
     provenance: Provenance;
+    /**
+     * The same `provenance.repo` / `provenance.generator`, lifted to the top level.
+     *
+     * Both spellings exist on purpose. Nesting keeps the non-diffable data in one block a
+     * `jq 'del(.provenance)'` can drop whole; lifting is what consumers that require these fields
+     * read. `repo.remoteUrl` and `repo.appRoot` are optional on the nested copy (they are absent
+     * outside a git tree, which is information) and REQUIRED here — outside a git tree this pair is
+     * simply not emitted, so "present but hollow" never occurs.
+     */
+    repo?: RepoProvenance & {
+        remoteUrl: string;
+        appRoot: string;
+    };
+    generator?: GeneratorProvenance & {
+        generatedAt: string;
+    };
     /** Whether a missing route means "deleted" or "not looked at". See {@link Coverage}. */
     coverage: Coverage;
     coverageScope?: CoverageScope;
     /** ISO timestamp of generation. Not diff-relevant on its own — consumers diffing two
      *  manifests should ignore this field, since it changes on every run even with no UI change. */
     generatedAt: string;
+    /**
+     * Whether presentational nodes were dropped.
+     *
+     * `"semantic"` means the tree is NOT the DOM: a wrapper carrying nothing but a class, with no
+     * events, no props and no handle, is folded away and its static text folded into its parent.
+     * That is a large reduction with no loss to any join, precisely because `conditionChain` is
+     * denormalized onto each element — nothing downstream needs the ancestors that were dropped.
+     */
+    nodePolicy?: 'semantic' | 'verbatim';
+    /** How many nodes `nodePolicy` removed, so a consumer knows the tree is not the DOM. */
+    collapsedNodeCount?: number;
     routes: RouteNode[];
+    /**
+     * Wildcard routes.
+     *
+     * Kept out of `routes[]` because a `**` matches every URL and so identifies none: given a page
+     * key it would fold every unmatched screen onto one node, which is worse than a miss.
+     */
+    fallbacks?: {
+        pattern: string;
+        redirectTo?: string;
+        source?: SourcePointer;
+    }[];
     components: ComponentNode[];
+    /**
+     * Which components render under each route — the shell above the router outlet included.
+     *
+     * References, never DOM: the elements live in `components[]` and are resolved once. Without
+     * this a consumer keying elements by page attributes the shell's navigation to no page at
+     * all, and "where is the sign-out button on this screen" answers "this screen has none".
+     */
+    routeTrees?: {
+        routePath: string;
+        rootComponent: string;
+        nodes: {
+            component: string;
+            via?: SourcePointer;
+            conditional: boolean;
+            repeated: boolean;
+            children: unknown[];
+        }[];
+    }[];
+    /** What the extractor could not statically resolve. See {@link Uncapturable}. */
+    uncapturable?: Uncapturable[];
     /** Present only when the extractor was run with dependency-graph resolution enabled. */
     dependencyGraph?: RouteDependencyTree[];
     /** Soft-failure notices, e.g. "routing pattern unresolved for src/App.tsx". Never used in

package/dist/types/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/types/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAExF;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAC;AAEpC,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAE5C,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,OAAO,cAAc,CAAC;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB;iEAC6D;IAC7D,GAAG,EAAE,WAAW,CAAC;IACjB;4BACwB;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,wFAAwF;IACxF,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;oGACgG;IAChG,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,wFAAwF;IACxF,eAAe,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACxC;mGAC+F;IAC/F,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/types/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EACV,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAE,mBAAmB,EAAE,UAAU,EAAE,cAAc,EACtF,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAC;AAEpC,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAE5C,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,OAAO,cAAc,CAAC;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB;iEAC6D;IAC7D,GAAG,EAAE,WAAW,CAAC;IACjB;;;;;qFAKiF;IACjF,UAAU,EAAE,UAAU,CAAC;IACvB;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,cAAc,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,SAAS,CAAC,EAAE,mBAAmB,GAAG;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,wFAAwF;IACxF,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;oGACgG;IAChG,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACrC,wFAAwF;IACxF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB;;;;;OAKG;IACH,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,aAAa,CAAA;KAAE,EAAE,CAAC;IAC/E,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,aAAa,CAAC;YAAC,WAAW,EAAE,OAAO,CAAC;YAAC,QAAQ,EAAE,OAAO,CAAC;YAChF,QAAQ,EAAE,OAAO,EAAE,CAAA;SAAE,EAAE,CAAC;KAClC,EAAE,CAAC;IACJ,iFAAiF;IACjF,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC;IAC9B,wFAAwF;IACxF,eAAe,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACxC;mGAC+F;IAC/F,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB"}

package/dist/types/route.d.ts

@@ -1,6 +1,21 @@
+import type { SourcePointer } from './source.js';
+/**
+ * One guard on a route.
+ *
+ * v2 emitted a bare name. A name cannot be opened, so "what gates this route?" was answerable
+ * only as far as "something called authGuard" — and the follow-up, which is the one that matters
+ * when a test cannot reach a screen, needed a repository search to answer.
+ */
+export interface RouteGuard {
+    name: string;
+    kind: 'function' | 'class';
+    source?: SourcePointer;
+}
 export interface RouteGuards {
-    canActivate?: string[];
-    canDeactivate?: string[];
+    canActivate?: RouteGuard[];
+    canActivateChild?: RouteGuard[];
+    canDeactivate?: RouteGuard[];
+    canMatch?: RouteGuard[];
 }
 export type ReactRoutingPattern = 'jsx-routes' | 'router-config' | 'file-based';
 export interface RouteNode {
@@ -23,10 +38,20 @@ export interface RouteNode {
     component?: {
         module: string;
         export: string;
+        source?: SourcePointer;
+    };
+    loadComponent?: {
+        module: string;
+        export: string;
+        source?: SourcePointer;
     };
     redirectTo?: string;
     pathMatch?: string;
     guards?: RouteGuards;
+    /** Query parameters this route reads. */
+    queryParamKeys?: string[];
+    /** Where the route object literal is written. */
+    source?: SourcePointer;
     children?: RouteNode[];
     /** React only, set at the tree root: which detection strategy produced this tree. */
     routingPattern?: ReactRoutingPattern;

package/dist/types/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/types/route.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,CAAC;AAEhF,MAAM,WAAW,SAAS;IACxB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,SAAS,CAAC,EAAE;QACV,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAC;IACvB,qFAAqF;IACrF,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/types/route.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC;IAC3B,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,UAAU,EAAE,CAAC;IAChC,aAAa,CAAC,EAAE,UAAU,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAC;CACzB;AAED,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,CAAC;AAEhF,MAAM,WAAW,SAAS;IACxB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,SAAS,CAAC,EAAE;QACV,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,aAAa,CAAC;KACxB,CAAC;IACF,aAAa,CAAC,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,aAAa,CAAC;KACxB,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,yCAAyC;IACzC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAC;IACvB,qFAAqF;IACrF,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC"}

package/dist/types/source.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where in the repository a thing is declared.
+ *
+ * v2 emitted routes, components and elements but never said *where they came from*, so every
+ * "where is this declared?" answer a consumer could give was "somewhere in this file" — and for a
+ * 400-line template that is not an answer, it is a re-read. Line numbers are the single biggest
+ * thing this block adds, and they cost nothing to produce: Angular's `parseTemplate()` and the
+ * TypeScript AST both carry positions on every node already.
+ *
+ * `blobOid` is the quietly valuable field. A git blob sha survives a rename, so a pointer stays
+ * resolvable after a refactor that a path alone would strand. Absent until the extractor is asked
+ * to shell out to git per file, which it is not today.
+ */
+export interface SourcePointer {
+    /** Repo-relative, forward slashes, no `..` segment. Relative to the repository root — NOT to
+     *  `repo.appRoot` — so a consumer can hand it to a repository API without re-joining anything. */
+    path: string;
+    /** A class, method or guard name. An identifier, never free text. */
+    symbol?: string;
+    /** 1-based, like an editor shows and unlike every parser that produces it. */
+    startLine?: number;
+    endLine?: number;
+    blobOid?: string;
+}
+//# sourceMappingURL=source.d.ts.map

package/dist/types/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/types/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B;sGACkG;IAClG,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/types/source.js

@@ -0,0 +1 @@
+export {};

package/dist/types/uncapturable.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What the extractor could NOT statically resolve.
+ *
+ * This is not optional bookkeeping. When a consumer sees an element at runtime that no manifest
+ * declares, there are two causes — the manifest is stale, or the app injects that DOM — and they
+ * need opposite actions. This list is the only thing that tells them apart. Without it, every such
+ * finding is undiagnosable and a manifest covering 70% of an app looks complete.
+ *
+ * `diagnostics[]` is still emitted alongside and still carries the same notices as free text; this
+ * is the same information given a shape a consumer can branch on.
+ */
+export type UncapturableKind = 'dynamicComponentOutlet' | 'innerHTML' | 'runtimeRoute' | 'unresolvedLazyChunk' | 'thirdPartyWebComponent' | 'iframe' | 'dynamicSelector' | 'unresolvedApiUrl' | 'templateParseError' | 'unsupportedTemplateNode';
+export interface Uncapturable {
+    kind: UncapturableKind;
+    /** The component (or route) whose extraction is incomplete because of this. */
+    affects?: string;
+    /** Free text, for a person. */
+    detail?: string;
+    source?: import('./source.js').SourcePointer;
+}
+//# sourceMappingURL=uncapturable.d.ts.map

package/dist/types/uncapturable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncapturable.d.ts","sourceRoot":"","sources":["../../src/types/uncapturable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GACxB,wBAAwB,GACxB,WAAW,GACX,cAAc,GACd,qBAAqB,GACrB,wBAAwB,GACxB,QAAQ,GACR,iBAAiB,GACjB,kBAAkB,GAClB,oBAAoB,GACpB,yBAAyB,CAAC;AAE9B,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,gBAAgB,CAAC;IACvB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,aAAa,EAAE,aAAa,CAAC;CAC9C"}

package/dist/types/uncapturable.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ui-manifest-json/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Shared JSON schema types and framework-agnostic helpers for ui-manifest extractors.",
   "keywords": [
     "ui-manifest",