@descryy/runtime-identity-grounding 0.3.0 → 0.4.1

package/dist/fiber-probe.js

@@ -2,58 +2,38 @@
  * The page-side half: reads React's fiber bookkeeping off a real DOM node
  * and returns **raw facts only**.
  *
- * ## Read-only, and why that matters here
+ * Read-only, unlike `frontend-initiator-capture.ts` which concedes it
+ * wraps `window.fetch`. This module defines one function on `window` and
+ * reads properties React already put on DOM nodes and fiber objects —
+ * nothing wrapped, nothing patched, no application code path changes shape
+ * (same observation-only guarantee `Collector` states for attach mode).
  *
- * `frontend-initiator-capture.ts` (`@descryy/runtime-browser`) had to open
- * its own module comment by conceding that it *writes* — it wraps
- * `window.fetch` and adds a header to real outgoing requests, which is a
- * real observable side effect on the application under test. This module
- * has no such concession to make. It defines one function on `window` and
- * reads properties React already put on DOM nodes and on its own fiber
- * objects. Nothing is wrapped, nothing is patched, no application code path
- * changes shape because Descry is attached. That is the same
- * observation-only guarantee `Collector` states for attach mode
- * (`ATTACH_MODE_SCOPE_DISCLOSURE`), and it holds here without needing an
- * exception.
+ * Injected via `page.addInitScript` with a string body, the same mechanism
+ * `frontend-initiator-capture.ts` uses — no transpilation step needed. A
+ * string rather than a typed function because this repo's
+ * `tsconfig.base.json` has no DOM library, so `document`/`window` don't
+ * exist as types here; it keeps the "runs here" vs "runs there" boundary
+ * visible.
  *
- * ## Injected through the existing seam, not a second one
+ * `addInitScript` doesn't reach an already-loaded document — call
+ * `install()` before navigating, or a page reports `probe-not-installed`.
  *
- * `page.addInitScript` with a string body — exactly the mechanism
- * `frontend-initiator-capture.ts` already uses, for the same reason it
- * gives: the script runs as written in the page's own JS engine and needs
- * no transpilation step of its own. It is a string rather than a typed
- * function because this repo's `tsconfig.base.json` compiles with `lib:
- * ["ES2023"]` and no DOM library at all, so `document` and `window` do not
- * exist as types in this package. Writing the page code as a string is not
- * a shortcut around that; it is the same choice the sibling module made,
- * and it keeps the boundary between "runs here" and "runs there" visible.
- *
- * `addInitScript` does not reach a document that has already loaded. Call
- * `install()` before navigating, like every other collector in
- * `@descryy/runtime-browser` — a page navigated first reports
- * `probe-not-installed`, by name, rather than silently returning nothing.
- *
- * ## Raw facts only — no decisions
- *
- * Everything this returns is a JSON-serialisable transcript of what was on
- * the fiber. Deciding what it *means* (is this a production build? does
- * this owner stack point at authored source?) happens in Node, in
- * `identity-grounding.ts`, where it can be unit-tested without a browser
- * and where the source-map machinery this repo already owns is reachable.
- * The page-side script cannot resolve a source map and must not try.
+ * Raw facts only, no decisions: everything returned is a JSON-serialisable
+ * transcript. Deciding what it *means* happens in Node
+ * (`identity-grounding.ts`), unit-testable without a browser. The
+ * page-side script cannot resolve a source map and must not try.
  */
 /** The single global this installs. One name, one function, no other footprint on the page. */
 export const IDENTITY_GROUNDING_BINDING = "__descryIdentityGrounding";
 /**
  * The two key prefixes React has used to hang a fiber off a host DOM node:
- * `__reactFiber$` since React 17, `__reactInternalInstance$` before that.
- * Both are checked because both are cheap to check and a wrong "not React"
- * answer on a React 16 page would be a silent, permanent blind spot.
+ * `__reactFiber$` since React 17, `__reactInternalInstance$` before. Both
+ * checked because both are cheap and a wrong "not React" on a React 16 page
+ * would be a silent, permanent blind spot.
  *
- * Measured present as `__reactFiber$<random>` on React 18.3.1 and 19.2.8
- * alike; `__reactInternalInstance$` is carried on the documented shape of
- * React 16 and is **not** covered by this repo's fixtures, which is stated
- * here rather than implied by the code.
+ * Measured present as `__reactFiber$<random>` on React 18.3.1 and 19.2.8;
+ * `__reactInternalInstance$` matches React 16's documented shape but is
+ * NOT covered by this repo's fixtures.
  */
 export const FIBER_KEY_PREFIXES = ["__reactFiber$", "__reactInternalInstance$"];
 export function createIdentityGroundingProbe() {
@@ -67,22 +47,15 @@ export function createIdentityGroundingProbe() {
     };
 }
 /**
- * The call side, also a string — and a **self-invoking** one, with the
- * selector serialised into it rather than passed as an `evaluate` argument.
- *
- * Measured, not stylistic: Playwright's string form of `page.evaluate`
- * evaluates the text as an expression, and passing a separate `arg`
- * alongside a string body returned `undefined` here rather than calling the
- * function expression with it. A self-invoking expression has one
- * unambiguous meaning in both directions, and `JSON.stringify` on the
- * selector is the same escaping this file already uses for the binding
- * name, so a selector containing quotes cannot break out of the string.
+ * The call side, also a string — **self-invoking**, with the selector
+ * serialised into it rather than passed as an `evaluate` argument. Measured,
+ * not stylistic: a separate `arg` alongside a string body returned
+ * `undefined` here instead of calling the expression with it.
+ * `JSON.stringify` on the selector prevents a quote from breaking out.
  *
- * The `probe-not-installed` branch lives here rather than in the injected
- * script for the obvious reason that a script which never ran cannot report
- * that it never ran. This is the only place that distinction can be drawn,
- * and drawing it is what keeps "Descry was not attached to this document"
- * from being reported as "this page is not React".
+ * The `probe-not-installed` branch lives here, not in the injected script —
+ * a script that never ran can't report that it never ran. This is the only
+ * place that distinction can be drawn.
  */
 function probeCallSource(selector) {
     return `(() => {
@@ -93,34 +66,23 @@ function probeCallSource(selector) {
   return grounding.probe(${JSON.stringify(selector)});
 })()`;
 }
-/** Cap on the key list carried by a `no-fiber` result. A `<div>` has few own keys; a pathological one should not become an unbounded payload. */
+/** Cap on the key list carried by a `no-fiber` result — a pathological element shouldn't become an unbounded payload. */
 const MAX_REPORTED_OWN_KEYS = 32;
 /**
  * The injected reader.
  *
- * ## Why component detection reads the *type shape* and not `fiber.tag`
- *
- * The obvious implementation is a set of numeric fiber tags —
- * `0 = FunctionComponent`, `1 = ClassComponent`, `11 = ForwardRef` and so
- * on. That table is a private React implementation detail with no
- * compatibility guarantee across majors, and this module has to work
- * against at least two majors whose fiber internals already differ in the
- * ways this package exists to handle. A table that is wrong on some future
- * React does not fail loudly — it silently classifies a real component as
- * "not a component" and the answer degrades to a refusal nobody can
- * explain.
- *
- * `fiber.type` is far more stable and is directly observable: a string is a
- * host element, a function is a function or class component, an object with
- * a `render` is a `forwardRef`, an object with a `type` is a `memo`. That
- * is what is used. `tag` is still reported, verbatim, for audit.
- *
- * ## Everything degrades to null, nothing throws
+ * Component detection reads the *type shape*, not `fiber.tag` — the
+ * obvious numeric-tag table (`0 = FunctionComponent`, ...) is a private
+ * React implementation detail with no cross-major guarantee, and a table
+ * wrong on some future React silently misclassifies a component as "not a
+ * component" rather than failing loudly. `fiber.type` is stable and
+ * observable instead: a string is a host element, a function a
+ * function/class component, an object with `render` a `forwardRef`, an
+ * object with `type` a `memo`. `tag` is still reported verbatim for audit.
  *
- * A property access that finds an unexpected shape yields `null`, and the
- * whole probe body is wrapped so that a genuinely unexpected page cannot
- * turn a read-only observation into a page error the application would
- * then have to survive.
+ * Everything degrades to null, nothing throws — an unexpected shape yields
+ * `null`, and the whole probe body is wrapped so a read-only observation
+ * can't become a page error the app has to survive.
  */
 function probeScriptSource() {
     return `(() => {
@@ -214,9 +176,8 @@ function probeScriptSource() {
       try {
         element = document.querySelector(selector);
       } catch (_error) {
-        // An invalid selector is the caller's mistake, and it is not a
-        // statement about the page. Reported as "matched nothing", which is
-        // what actually happened here.
+        // An invalid selector is the caller's mistake, not a statement
+        // about the page — reported as "matched nothing".
         return { status: "element-not-found", selector: selector };
       }
       if (element === null) return { status: "element-not-found", selector: selector };

package/dist/fiber-probe.js.map

@@ -1 +1 @@
-{"version":3,"file":"fiber-probe.js","sourceRoot":"","sources":["../src/fiber-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAMH,+FAA+F;AAC/F,MAAM,CAAC,MAAM,0BAA0B,GAAG,2BAA2B,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,eAAe,EAAE,0BAA0B,CAAU,CAAC;AAuDzF,MAAM,UAAU,4BAA4B;IAC1C,OAAO;QACL,KAAK,CAAC,OAAO,CAAC,IAAU;YACtB,MAAM,IAAI,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,KAAK,CAAC,IAAU,EAAE,QAAgB;YAChC,OAAO,IAAI,CAAC,QAAQ,CAAgB,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,eAAe,CAAC,QAAgB;IACvC,OAAO;6BACoB,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;2BAI5C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;KAC9C,CAAC;AACN,CAAC;AAED,iJAAiJ;AACjJ,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAS,iBAAiB;IACxB,OAAO;+BACsB,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoFtD,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA6BF,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2BlE,CAAC;AACP,CAAC"}
+{"version":3,"file":"fiber-probe.js","sourceRoot":"","sources":["../src/fiber-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH,+FAA+F;AAC/F,MAAM,CAAC,MAAM,0BAA0B,GAAG,2BAA2B,CAAC;AAEtE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,eAAe,EAAE,0BAA0B,CAAU,CAAC;AAuDzF,MAAM,UAAU,4BAA4B;IAC1C,OAAO;QACL,KAAK,CAAC,OAAO,CAAC,IAAU;YACtB,MAAM,IAAI,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,KAAK,CAAC,IAAU,EAAE,QAAgB;YAChC,OAAO,IAAI,CAAC,QAAQ,CAAgB,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,eAAe,CAAC,QAAgB;IACvC,OAAO;6BACoB,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;2BAI5C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;KAC9C,CAAC;AACN,CAAC;AAED,yHAAyH;AACzH,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC;;;;;;;;;;;;;;;GAeG;AACH,SAAS,iBAAiB;IACxB,OAAO;+BACsB,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoFtD,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA4BF,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2BlE,CAAC;AACP,CAAC"}

package/dist/graph-join.d.ts

@@ -1,61 +1,30 @@
 /**
- * The join to `descry-core`'s graph — as a **hand-off**, not a second
- * resolver.
+ * The join to `descry-core`'s graph — a **hand-off**, not a second
+ * resolver. `resolveSymbolNode` already does the whole job of turning
+ * `{ file, symbolName, line }` into a `FUNCTION`/`CLASS` node — refusing
+ * ambiguity, checking the line against the node's range, translating path
+ * languages, requiring `repo` since there's no honest default. This
+ * function's entire contract: hand it exactly that input, or hand it
+ * nothing.
  *
- * `@descryy/runtime-graph-correlator`'s `resolveSymbolNode` already does the
- * whole job of turning `{ file, symbolName, line }` into a `FUNCTION`/
- * `CLASS` node, and everything hard about that job is in the parts this
- * function must not duplicate: refusing ambiguity instead of ranking
- * candidates, checking the claimed line against the node's own range and
- * reporting `line-mismatch` distinctly, translating between the absolute /
- * repo-relative / relative-to-launch-cwd path languages, and requiring
- * `repo` because `FUNCTION` is repo-scoped and there is no honest default.
- * A copy of any of that here would be a copy that drifts.
+ * No new node type, no new edge type — resolves to a `FUNCTION`/`CLASS`
+ * node an adapter already produced. `descry-core`'s frozen 15/15 vocabulary
+ * is untouched.
  *
- * So this function's entire contract is: hand `resolveSymbolNode` exactly
- * the input it asks for, or hand it nothing.
- *
- * ## No new node type, no new edge type
- *
- * The component resolves to a `FUNCTION` or `CLASS` node that an adapter
- * already produced — `descry-core`'s frozen 15 node types and 15 edge types
- * are untouched. There is no `COMPONENT_INSTANCE`, no `RENDERS` edge, and
- * nothing here asks for one. (`COMPONENT` is already one of the 15, and a
- * React component that an adapter emitted as one is found by the same
- * name+file lookup.)
- *
- * ## Why a compiled location is withheld rather than passed through
- *
- * `resolveSymbolNode` would take a bundle path quite happily and report
- * `not-found` for it, which reads to a consumer as *"that component is not
- * in the graph"* — the exact misleading refusal `symbol.ts`'s own header
- * describes and fixed for absolute paths. A React 19 answer with
- * `authoredSource: false` names `dist/dev.js`, a file no adapter ever
- * indexed and never will. Withholding it keeps the honest statement —
- * *"we know the component, we could not reach authored source"* — inside
- * `ElementIdentity`, where the capability status explains it, instead of
- * laundering it into a graph miss.
+ * A compiled location is withheld rather than passed through:
+ * `resolveSymbolNode` would report `not-found` for a bundle path, reading
+ * as "not in the graph" — the exact misleading refusal `symbol.ts` fixed
+ * for absolute paths. Withholding it keeps the honest statement ("we know
+ * the component, couldn't reach authored source") inside `ElementIdentity`,
+ * not laundered into a graph miss.
  */
 import type { ElementIdentity } from "./element-identity.ts";
-/**
- * Structurally `resolveSymbolNode`'s own `location` parameter. Deliberately
- * declared with `line` optional rather than nullable, because that is the
- * shape that function accepts; `graph-join.test.ts` asserts the
- * compatibility against the real signature at compile time, so a change on
- * either side breaks the build rather than being discovered at runtime.
- */
+/** Structurally `resolveSymbolNode`'s own `location` parameter — `line` optional, not nullable, matching that function's shape. `graph-join.test.ts` asserts the compatibility at compile time. */
 export interface GraphSymbolLocation {
     readonly file: string;
     readonly symbolName: string;
     readonly line?: number;
 }
-/**
- * The graph lookup this identity supports, or `null` when it supports none.
- *
- * `null` for every outcome except a `grounded` one that reached authored
- * source with a real file — including `component-only`, which knows the
- * component's name and nothing about where it lives, and including a
- * `grounded` answer whose location is compiled output.
- */
+/** The graph lookup this identity supports, or `null` when it supports none — only a `grounded` outcome with authored source and a real file. */
 export declare function symbolLocationForGraph(identity: ElementIdentity): GraphSymbolLocation | null;
 //# sourceMappingURL=graph-join.d.ts.map

package/dist/graph-join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph-join.d.ts","sourceRoot":"","sources":["../src/graph-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,mBAAmB,GAAG,IAAI,CAU5F"}
+{"version":3,"file":"graph-join.d.ts","sourceRoot":"","sources":["../src/graph-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,mMAAmM;AACnM,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,iJAAiJ;AACjJ,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,mBAAmB,GAAG,IAAI,CAU5F"}

package/dist/graph-join.js

@@ -1,49 +1,24 @@
 /**
- * The join to `descry-core`'s graph — as a **hand-off**, not a second
- * resolver.
+ * The join to `descry-core`'s graph — a **hand-off**, not a second
+ * resolver. `resolveSymbolNode` already does the whole job of turning
+ * `{ file, symbolName, line }` into a `FUNCTION`/`CLASS` node — refusing
+ * ambiguity, checking the line against the node's range, translating path
+ * languages, requiring `repo` since there's no honest default. This
+ * function's entire contract: hand it exactly that input, or hand it
+ * nothing.
  *
- * `@descryy/runtime-graph-correlator`'s `resolveSymbolNode` already does the
- * whole job of turning `{ file, symbolName, line }` into a `FUNCTION`/
- * `CLASS` node, and everything hard about that job is in the parts this
- * function must not duplicate: refusing ambiguity instead of ranking
- * candidates, checking the claimed line against the node's own range and
- * reporting `line-mismatch` distinctly, translating between the absolute /
- * repo-relative / relative-to-launch-cwd path languages, and requiring
- * `repo` because `FUNCTION` is repo-scoped and there is no honest default.
- * A copy of any of that here would be a copy that drifts.
+ * No new node type, no new edge type — resolves to a `FUNCTION`/`CLASS`
+ * node an adapter already produced. `descry-core`'s frozen 15/15 vocabulary
+ * is untouched.
  *
- * So this function's entire contract is: hand `resolveSymbolNode` exactly
- * the input it asks for, or hand it nothing.
- *
- * ## No new node type, no new edge type
- *
- * The component resolves to a `FUNCTION` or `CLASS` node that an adapter
- * already produced — `descry-core`'s frozen 15 node types and 15 edge types
- * are untouched. There is no `COMPONENT_INSTANCE`, no `RENDERS` edge, and
- * nothing here asks for one. (`COMPONENT` is already one of the 15, and a
- * React component that an adapter emitted as one is found by the same
- * name+file lookup.)
- *
- * ## Why a compiled location is withheld rather than passed through
- *
- * `resolveSymbolNode` would take a bundle path quite happily and report
- * `not-found` for it, which reads to a consumer as *"that component is not
- * in the graph"* — the exact misleading refusal `symbol.ts`'s own header
- * describes and fixed for absolute paths. A React 19 answer with
- * `authoredSource: false` names `dist/dev.js`, a file no adapter ever
- * indexed and never will. Withholding it keeps the honest statement —
- * *"we know the component, we could not reach authored source"* — inside
- * `ElementIdentity`, where the capability status explains it, instead of
- * laundering it into a graph miss.
- */
-/**
- * The graph lookup this identity supports, or `null` when it supports none.
- *
- * `null` for every outcome except a `grounded` one that reached authored
- * source with a real file — including `component-only`, which knows the
- * component's name and nothing about where it lives, and including a
- * `grounded` answer whose location is compiled output.
+ * A compiled location is withheld rather than passed through:
+ * `resolveSymbolNode` would report `not-found` for a bundle path, reading
+ * as "not in the graph" — the exact misleading refusal `symbol.ts` fixed
+ * for absolute paths. Withholding it keeps the honest statement ("we know
+ * the component, couldn't reach authored source") inside `ElementIdentity`,
+ * not laundered into a graph miss.
  */
+/** The graph lookup this identity supports, or `null` when it supports none — only a `grounded` outcome with authored source and a real file. */
 export function symbolLocationForGraph(identity) {
     if (identity.outcome !== "grounded")
         return null;

package/dist/graph-join.js.map

@@ -1 +1 @@
-{"version":3,"file":"graph-join.js","sourceRoot":"","sources":["../src/graph-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAiBH;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAAyB;IAC9D,IAAI,QAAQ,CAAC,OAAO,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC;IACjD,IAAI,CAAC,QAAQ,CAAC,cAAc;QAAE,OAAO,IAAI,CAAC;IAE1C,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC;IAC/C,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAE/B,OAAO,IAAI,KAAK,IAAI;QAClB,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE;QAC/C,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;AAC1D,CAAC"}
+{"version":3,"file":"graph-join.js","sourceRoot":"","sources":["../src/graph-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAWH,iJAAiJ;AACjJ,MAAM,UAAU,sBAAsB,CAAC,QAAyB;IAC9D,IAAI,QAAQ,CAAC,OAAO,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC;IACjD,IAAI,CAAC,QAAQ,CAAC,cAAc;QAAE,OAAO,IAAI,CAAC;IAE1C,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC;IAC/C,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAE/B,OAAO,IAAI,KAAK,IAAI;QAClB,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE;QAC/C,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;AAC1D,CAAC"}

package/dist/identity-grounder.d.ts

@@ -1,9 +1,7 @@
 /**
  * The composed, page-driving surface — install once, then ask about a
- * selector.
- *
- * Everything hard here is a composition of parts this repo already owns,
- * deliberately:
+ * selector. Everything hard here is a composition of parts this repo
+ * already owns:
  *
  * | step | owner |
  * | --- | --- |
@@ -14,22 +12,15 @@
  * | source map, staleness, `reliability` | `createNodeSourceLocationResolver` (same) |
  * | decide what may be claimed | `identity-grounding.ts` (this package) |
  *
- * The only genuinely new machinery in this package is the fiber read and
- * the decision table. A second source-map resolver, a second stack parser
- * or a second URL-rewriting rule here would each be a copy that holds in
- * one place — this repo has measured that drift and says so in
- * `graph-correlator/src/symbol.ts` and `fixture-apps/roots.ts` alike.
- *
- * ## `resolveSourceRoot` is what makes the React 19 path work at all
+ * Only the fiber read and the decision table are genuinely new here — a
+ * second copy of any of the rest would be a copy that drifts.
  *
- * A React 19 owner stack names the bundle by its **browser URL**
- * (`http://127.0.0.1:41369/dev.js:21714:62`). `createNodeSourceLocation-
- * Resolver` resolves source maps from **disk**. `resolveSourceRoot` is the
- * existing bridge between those two coordinate systems
- * (`CollectorContext.resolveSourceRoot`, RT-023/RT-029), and without one
- * the React 19 path degrades honestly: the stack still parses, the frame
- * still names a position, and the answer comes back with
- * `authoredSource: false` and a `degraded` capability rather than a
+ * `resolveSourceRoot` is what makes the React 19 path work: a React 19
+ * owner stack names the bundle by browser URL
+ * (`http://127.0.0.1:41369/dev.js:21714:62`), but source maps resolve from
+ * disk. Without a resolver (`CollectorContext.resolveSourceRoot`,
+ * RT-023/RT-029), the path degrades honestly — the stack still parses, but
+ * the answer comes back `authoredSource: false` and `degraded`, never a
  * fabricated authored file. React 18 needs none of this — its location is
  * already authored, on the fiber.
  */
@@ -37,21 +28,11 @@ import type { SourceRootResolver } from "@descryy/runtime-contracts";
 import type { Page } from "playwright-core";
 import type { ElementIdentity } from "./element-identity.ts";
 export interface IdentityGrounderOptions {
-    /**
-     * Joins a browser origin to the on-disk directory it is served from, so a
-     * React 19 owner stack's compiled frames can be mapped back to authored
-     * source. Absent is a supported configuration, not a misconfiguration —
-     * see this module's header.
-     */
+    /** Joins a browser origin to the on-disk directory it's served from, so React 19's compiled frames map back to authored source. Absent is supported, not a misconfiguration. */
     readonly resolveSourceRoot?: SourceRootResolver;
 }
 export interface IdentityGrounder {
-    /**
-     * Installs the page-side reader into every document this page loads from
-     * this point forward. **Call before navigating** — `page.addInitScript`
-     * does not reach a document that is already loaded, and a page navigated
-     * first reports `probe-not-installed` by name.
-     */
+    /** Installs the page-side reader into every document this page loads from now on. Call before navigating — a page navigated first reports `probe-not-installed`. */
     install(page: Page): Promise<void>;
     /** Resolves one on-screen element to the component that produced it, and to that component's file and line where those can be established. Never throws for a routine unavailability; refuses by name instead. */
     ground(page: Page, selector: string): Promise<ElementIdentity>;

package/dist/identity-grounder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identity-grounder.d.ts","sourceRoot":"","sources":["../src/identity-grounder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,4BAA4B,CAAC;AAGjF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;CACjD;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,kNAAkN;IAClN,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAChE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,uBAA4B,GAAG,gBAAgB,CAyB9F"}
+{"version":3,"file":"identity-grounder.d.ts","sourceRoot":"","sources":["../src/identity-grounder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,4BAA4B,CAAC;AAGjF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,MAAM,WAAW,uBAAuB;IACtC,gLAAgL;IAChL,QAAQ,CAAC,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;CACjD;AAED,MAAM,WAAW,gBAAgB;IAC/B,oKAAoK;IACpK,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,kNAAkN;IAClN,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAChE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,uBAA4B,GAAG,gBAAgB,CAqB9F"}

package/dist/identity-grounder.js

@@ -1,9 +1,7 @@
 /**
  * The composed, page-driving surface — install once, then ask about a
- * selector.
- *
- * Everything hard here is a composition of parts this repo already owns,
- * deliberately:
+ * selector. Everything hard here is a composition of parts this repo
+ * already owns:
  *
  * | step | owner |
  * | --- | --- |
@@ -14,22 +12,15 @@
  * | source map, staleness, `reliability` | `createNodeSourceLocationResolver` (same) |
  * | decide what may be claimed | `identity-grounding.ts` (this package) |
  *
- * The only genuinely new machinery in this package is the fiber read and
- * the decision table. A second source-map resolver, a second stack parser
- * or a second URL-rewriting rule here would each be a copy that holds in
- * one place — this repo has measured that drift and says so in
- * `graph-correlator/src/symbol.ts` and `fixture-apps/roots.ts` alike.
- *
- * ## `resolveSourceRoot` is what makes the React 19 path work at all
+ * Only the fiber read and the decision table are genuinely new here — a
+ * second copy of any of the rest would be a copy that drifts.
  *
- * A React 19 owner stack names the bundle by its **browser URL**
- * (`http://127.0.0.1:41369/dev.js:21714:62`). `createNodeSourceLocation-
- * Resolver` resolves source maps from **disk**. `resolveSourceRoot` is the
- * existing bridge between those two coordinate systems
- * (`CollectorContext.resolveSourceRoot`, RT-023/RT-029), and without one
- * the React 19 path degrades honestly: the stack still parses, the frame
- * still names a position, and the answer comes back with
- * `authoredSource: false` and a `degraded` capability rather than a
+ * `resolveSourceRoot` is what makes the React 19 path work: a React 19
+ * owner stack names the bundle by browser URL
+ * (`http://127.0.0.1:41369/dev.js:21714:62`), but source maps resolve from
+ * disk. Without a resolver (`CollectorContext.resolveSourceRoot`,
+ * RT-023/RT-029), the path degrades honestly — the stack still parses, but
+ * the answer comes back `authoredSource: false` and `degraded`, never a
  * fabricated authored file. React 18 needs none of this — its location is
  * already authored, on the fiber.
  */
@@ -41,13 +32,9 @@ export function createIdentityGrounder(options = {}) {
     const probe = createIdentityGroundingProbe();
     const parser = createV8StackTraceParser(createNodeSourceLocationResolver());
     const resolveOwnerStack = (rawStackText) => {
-        // Rewritten before parsing, not after -- `script-url-mapping.ts`'s own
-        // reasoning, reused rather than re-argued: the parser and its resolver
-        // already know how to turn `at f (/abs/path.js:12:5)` into a resolved
-        // location, and rewriting the text first lets all of that apply
-        // unchanged. An unmapped URL is left exactly as the browser reported
-        // it, which then resolves as a compiled location rather than a
-        // fabricated file.
+        // Rewritten before parsing, not after, so the parser/resolver's
+        // existing path handling applies unchanged. An unmapped URL is left as
+        // the browser reported it, resolving as compiled rather than fabricated.
         const rewritten = rewriteScriptUrls(rawStackText, options.resolveSourceRoot);
         return parser.parse(rewritten.text);
     };

package/dist/identity-grounder.js.map

@@ -1 +1 @@
-{"version":3,"file":"identity-grounder.js","sourceRoot":"","sources":["../src/identity-grounder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,gCAAgC,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAIjH,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,eAAe,EAA2B,MAAM,yBAAyB,CAAC;AAwBnF,MAAM,UAAU,sBAAsB,CAAC,UAAmC,EAAE;IAC1E,MAAM,KAAK,GAAG,4BAA4B,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAG,wBAAwB,CAAC,gCAAgC,EAAE,CAAC,CAAC;IAE5E,MAAM,iBAAiB,GAAuB,CAAC,YAAoB,EAA8B,EAAE;QACjG,uEAAuE;QACvE,uEAAuE;QACvE,sEAAsE;QACtE,gEAAgE;QAChE,qEAAqE;QACrE,+DAA+D;QAC/D,mBAAmB;QACnB,MAAM,SAAS,GAAG,iBAAiB,CAAC,YAAY,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC7E,OAAO,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC;IAEF,OAAO;QACL,OAAO,CAAC,IAAU;YAChB,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,IAAU,EAAE,QAAgB;YACvC,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC9C,OAAO,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,iBAAiB,CAAC,CAAC;QAC3D,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"identity-grounder.js","sourceRoot":"","sources":["../src/identity-grounder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,gCAAgC,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAIjH,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,eAAe,EAA2B,MAAM,yBAAyB,CAAC;AAcnF,MAAM,UAAU,sBAAsB,CAAC,UAAmC,EAAE;IAC1E,MAAM,KAAK,GAAG,4BAA4B,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAG,wBAAwB,CAAC,gCAAgC,EAAE,CAAC,CAAC;IAE5E,MAAM,iBAAiB,GAAuB,CAAC,YAAoB,EAA8B,EAAE;QACjG,gEAAgE;QAChE,uEAAuE;QACvE,yEAAyE;QACzE,MAAM,SAAS,GAAG,iBAAiB,CAAC,YAAY,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC7E,OAAO,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC;IAEF,OAAO;QACL,OAAO,CAAC,IAAU;YAChB,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,IAAU,EAAE,QAAgB;YACvC,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC9C,OAAO,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,iBAAiB,CAAC,CAAC;QAC3D,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/identity-grounding.d.ts

@@ -1,53 +1,34 @@
 /**
  * The decision layer: raw fiber facts in, one `ElementIdentity` out.
  *
- * Pure with respect to the browser — it never touches a `Page`. Everything
- * it needs from the page arrives as a `RawFiberProbe`, and the one piece of
- * machinery it cannot own (turning a React 19 owner stack into a resolved
- * `StackTrace`, which needs source-map resolution and filesystem access) is
- * injected as `OwnerStackResolver`. That split is what lets every refusal
- * branch below be exercised as a plain unit test, with no Chromium and no
- * fixture app, while the fixture apps prove the two mechanisms end to end.
+ * Pure with respect to the browser — never touches a `Page`. The one piece
+ * of machinery it can't own (turning a React 19 owner stack into a resolved
+ * `StackTrace`) is injected as `OwnerStackResolver`, so every refusal
+ * branch below is a plain unit test, no Chromium needed.
  *
- * ## What this cannot do, stated once, in the place that decides it
+ * What this cannot do, decided here: a production React build (no
+ * `_debug*` survives, refused as `react-debug-fields-absent`); anything
+ * that isn't React (no fiber key — a scope boundary, not a gap, refused as
+ * "not React" rather than "unknown"); a React 19 bundle with no source map
+ * (reported with `authoredSource: false` and `degraded`, never dressed up);
+ * an anonymous component (refused — no symbol to look up, no name to act on).
  *
- * - **A production React build.** No `_debug*` field survives, and the
- *   component name on the fiber is minified. Refused by name
- *   (`react-debug-fields-absent`); see that value's own documentation.
- * - **Anything that is not React.** No fiber key, no answer. There is no
- *   Vue/Svelte/Angular/Solid path here — not a gap in this module, a scope
- *   boundary, and the refusal says "not React" rather than "unknown".
- * - **A React 19 bundle with no source map.** The owner stack still names a
- *   real position, in compiled output. Reported with
- *   `authoredSource: false` and a `degraded` capability, never dressed up
- *   as the file a developer wrote.
- * - **An anonymous component.** Refused: there is no symbol for
- *   `resolveSymbolNode` to look up and no name for a reader to act on.
- *
- * ## Owner versus renderer
- *
- * `component` is read from `_debugOwner` — the component whose render
- * *created* this element — because that is the component the source
- * location belongs to. `renderedBy` is the nearest component in the fiber
- * `return` chain, which is where the element ended up. They differ whenever
- * an element is created in one component and passed to another as
- * `children`; the fixture app renders that case deliberately. Both are
- * reported and neither is reconciled into the other.
+ * `component` is read from `_debugOwner` — whose render *created* the
+ * element, matching the source location. `renderedBy` is the nearest
+ * component in the `return` chain — where it ended up. They differ when an
+ * element is created in one component and passed to another as `children`
+ * (the fixture app renders this on purpose); both are reported, neither
+ * reconciled.
  */
 import { type StackTrace } from "@descryy/runtime-contracts";
 import { type ElementIdentity } from "./element-identity.ts";
 import type { RawFiberProbe } from "./fiber-probe.ts";
 /**
  * Turns React 19's raw `_debugStack` text into a resolved `StackTrace`, or
- * `null` when the text is not a V8 stack at all.
- *
- * Injected rather than constructed here because the real implementation is
- * a composition of three things this repo already owns and this package
- * must not re-own: `@descryy/runtime-browser`'s `rewriteScriptUrls` (browser
- * URL to on-disk path), and `@descryy/runtime-adapter-typescript`'s
- * `createV8StackTraceParser` plus `createNodeSourceLocationResolver`
- * (parsing, source-map resolution and the `reliability` classification —
- * including staleness detection). `identity-grounder.ts` wires them.
+ * `null` when it's not a V8 stack at all. Injected rather than constructed
+ * here, since the real implementation composes three things this package
+ * must not re-own: `rewriteScriptUrls`, `createV8StackTraceParser`, and
+ * `createNodeSourceLocationResolver`. `identity-grounder.ts` wires them.
  */
 export type OwnerStackResolver = (rawStackText: string) => Promise<StackTrace | null>;
 export declare function groundFromProbe(probe: RawFiberProbe, selector: string, resolveOwnerStack: OwnerStackResolver | null): Promise<ElementIdentity>;

package/dist/identity-grounding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identity-grounding.d.ts","sourceRoot":"","sources":["../src/identity-grounding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAA6C,KAAK,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAExG,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAA0B,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAG9E;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;AAOtF,wBAAsB,eAAe,CACnC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,kBAAkB,GAAG,IAAI,GAC3C,OAAO,CAAC,eAAe,CAAC,CA4N1B"}
+{"version":3,"file":"identity-grounding.d.ts","sourceRoot":"","sources":["../src/identity-grounding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAA6C,KAAK,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAExG,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAA0B,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAG9E;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;AAOtF,wBAAsB,eAAe,CACnC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,kBAAkB,GAAG,IAAI,GAC3C,OAAO,CAAC,eAAe,CAAC,CAyN1B"}