cgraphx 2.0.2 → 2.0.3

package/dist/core/code/shared/scope-resolution/registries/method-registry.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * `MethodRegistry` — scope-aware lookup for method / function / constructor
+ * dispatch (RFC §4.4; Ring 2 SHARED #917).
+ *
+ * Thin wrapper over `lookupCore`, specialized for callable kinds:
+ *
+ *   - `acceptedKinds` = Method / Function / Constructor.
+ *   - `useReceiverTypeBinding` is **true** — the type-binding + MRO walk
+ *     (Step 2) is the primary evidence path for receiver-dispatched calls.
+ *   - `callsite.arity` flows through to `provider.arityCompatibility`
+ *     when provided. When the provider is absent, arity evidence is
+ *     `unknown` (neutral signal).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMethodRegistry = buildMethodRegistry;
+const lookup_core_js_1 = require("./lookup-core.js");
+const context_js_1 = require("./context.js");
+function buildMethodRegistry(ctx) {
+    return {
+        lookup(name, scope, options = {}) {
+            const params = {
+                acceptedKinds: context_js_1.METHOD_KINDS,
+                useReceiverTypeBinding: true,
+                ownerScopedContributor: options.ownerScopedContributor ?? null,
+                ...(options.callsite !== undefined ? { callsite: options.callsite } : {}),
+                ...(options.explicitReceiver !== undefined
+                    ? { explicitReceiver: options.explicitReceiver }
+                    : {}),
+            };
+            return (0, lookup_core_js_1.lookupCore)(name, scope, params, ctx);
+        },
+    };
+}

package/dist/core/code/shared/scope-resolution/registries/tie-breaks.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * `compareByConfidenceWithTiebreaks` — the RFC §4.2 Step 7 total order
+ * over `Resolution` candidates (Ring 2 SHARED #917).
+ *
+ * Primary key is confidence (DESC). Remaining ties within `CONFIDENCE_EPSILON`
+ * fall through a deterministic cascade so the same inputs always produce
+ * the same winner, independent of insertion order.
+ *
+ * Tie-break cascade (per RFC Appendix B):
+ *
+ *   1. confidence DESC                       (primary)
+ *   2. scope depth ASC                       (nearer lexical scope wins)
+ *   3. MRO depth ASC                         (nearer class in hierarchy wins)
+ *   4. `ORIGIN_PRIORITY` ASC                 (local > import > … > global-name)
+ *   5. DefId.localeCompare                   (final deterministic tiebreaker)
+ *
+ * The per-candidate inputs needed beyond `Resolution.confidence` —
+ * `scopeDepth`, `mroDepth`, `origin` — are supplied via a sidecar
+ * `TieBreakKey` so the comparator stays pure and `Resolution` itself
+ * doesn't need to carry book-keeping fields.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIDENCE_EPSILON = void 0;
+exports.compareByConfidenceWithTiebreaks = compareByConfidenceWithTiebreaks;
+const origin_priority_js_1 = require("../origin-priority.js");
+exports.CONFIDENCE_EPSILON = 0.001;
+/**
+ * Pure comparator suitable for `Array.prototype.sort`. Return value follows
+ * the JavaScript convention: negative → `a` wins, positive → `b` wins.
+ *
+ * **Important:** `keys` is keyed by `Resolution.def.nodeId`, not by array
+ * index — stable across reorderings. Missing keys fall back to neutral
+ * values (`scopeDepth: 0`, `mroDepth: 0`, `origin: 'local'`), which means
+ * the tie-break degrades gracefully to defId-lexicographic ordering when
+ * side-info is unavailable. That keeps the total order deterministic
+ * even on malformed inputs.
+ */
+function compareByConfidenceWithTiebreaks(a, b, keys) {
+    // Primary: confidence DESC, treating values within epsilon as equal.
+    const delta = b.confidence - a.confidence;
+    if (Math.abs(delta) >= exports.CONFIDENCE_EPSILON)
+        return delta < 0 ? -1 : 1;
+    const ka = keys.get(a.def.nodeId) ?? DEFAULT_KEY;
+    const kb = keys.get(b.def.nodeId) ?? DEFAULT_KEY;
+    // Secondary: scope depth ASC.
+    if (ka.scopeDepth !== kb.scopeDepth)
+        return ka.scopeDepth - kb.scopeDepth;
+    // Tertiary: MRO depth ASC.
+    if (ka.mroDepth !== kb.mroDepth)
+        return ka.mroDepth - kb.mroDepth;
+    // Quaternary: ORIGIN_PRIORITY ASC.
+    const po = origin_priority_js_1.ORIGIN_PRIORITY[ka.origin] - origin_priority_js_1.ORIGIN_PRIORITY[kb.origin];
+    if (po !== 0)
+        return po;
+    // Final: DefId lexicographic, locale-aware for deterministic cross-platform output.
+    return a.def.nodeId.localeCompare(b.def.nodeId);
+}
+const DEFAULT_KEY = Object.freeze({
+    scopeDepth: 0,
+    mroDepth: 0,
+    origin: 'local',
+});

package/dist/core/code/shared/scope-resolution/resolve-type-ref.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * `resolveTypeRef` — strict single-return resolver for `TypeRef`s
+ * (RFC §4.6; Ring 2 SHARED #916).
+ *
+ * Narrower contract than `Registry.lookup`: no name-only global fallback, no
+ * confidence ranking, no arity check. Used by `Registry.lookup` Step 2 (type-
+ * binding propagation) and by any caller that wants the single best type-
+ * target for an annotation without paying for the full evidence pipeline.
+ *
+ * **Algorithm (strict).** Walk the scope chain from `ref.declaredAtScope`:
+ *
+ *   1. At each scope, inspect `bindings.get(ref.rawName)`:
+ *      - If one of the bindings is a **type-kind** def with a **strict origin**
+ *        (`'local' | 'import' | 'namespace' | 'reexport'`), return it.
+ *      - If any binding for this name exists at this scope but none qualifies
+ *        (e.g., a local variable named `User` shadows an outer import of class
+ *        `User`), return `null`. The nearer binding shadows; we do NOT fall
+ *        through to the global qualified-name index.
+ *      - Otherwise continue to the parent scope.
+ *   2. If the raw name is a dotted path (e.g., `'models.User'`) and the scope
+ *      walk produced no match, consult `QualifiedNameIndex.byQualifiedName`.
+ *      Only accept **exactly one** type-kind hit — anything ambiguous returns
+ *      `null` rather than a guess.
+ *   3. Return `null`.
+ *
+ * **What `'strict' origins' means.** `'wildcard'` is intentionally excluded.
+ * A wildcard-expanded name (`from x import *`) is too loose to use as an
+ * anchor for type resolution — it gives no signal about whether the name was
+ * actually imported. `Registry.lookup` may accept wildcard bindings at its
+ * own discretion (with lower evidence weight); `resolveTypeRef` does not.
+ *
+ * **What 'type-kind' means.** The subset of `NodeLabel` that a type annotation
+ * may legitimately reference: class-like, interface-like, enum-like, and
+ * alias-like kinds. See `TYPE_KINDS` below.
+ *
+ * Pure function — safe to call repeatedly; no side effects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTypeRef = resolveTypeRef;
+// ─── Strict policy constants ────────────────────────────────────────────────
+/** `'wildcard'` is deliberately absent. See file header. */
+const STRICT_ORIGINS = new Set([
+    'local',
+    'import',
+    'namespace',
+    'reexport',
+]);
+/**
+ * `NodeLabel` values that may appear on the RHS of a type annotation.
+ *
+ * Includes the usual class-like and interface-like kinds plus the alias-like
+ * ones (`TypeAlias`, `Typedef`). `Namespace` is excluded — it is a scope
+ * container, not a value type. `Function` / `Method` / `Variable` are
+ * excluded by design: a `rawName` bound to them at a strict origin is a
+ * *shadowing* binding, which the algorithm short-circuits to `null`.
+ *
+ * `'Type'` (the generic `NodeLabel` value) is also excluded — verified
+ * against `cgraph/src/core/ingestion/` at the time of writing, no
+ * production extractor emits `type: 'Type'` for annotation-relevant
+ * symbols. Should a future extractor start emitting it, add `'Type'`
+ * here and add a test asserting the new path.
+ */
+const TYPE_KINDS = new Set([
+    'Class',
+    'Interface',
+    'Enum',
+    'Struct',
+    'Union',
+    'Trait',
+    'TypeAlias',
+    'Typedef',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Template',
+]);
+// ─── Main entry point ──────────────────────────────────────────────────────
+function resolveTypeRef(ref, ctx) {
+    // Phase 1: scope-chain walk anchored at the declaration site.
+    let currentId = ref.declaredAtScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        // Cycle guard — a well-formed scope tree never loops, but a bug in the
+        // construction path should fail fast here rather than hanging.
+        if (visited.has(currentId))
+            return null;
+        visited.add(currentId);
+        const scope = ctx.scopes.getScope(currentId);
+        if (scope === undefined)
+            return null; // broken chain = unresolvable
+        const bindings = scope.bindings.get(ref.rawName);
+        if (bindings !== undefined && bindings.length > 0) {
+            // At least one binding exists at this scope → it is the shadowing site.
+            // Either one of them qualifies, or the name is shadowed by a non-type.
+            for (const binding of bindings) {
+                if (!STRICT_ORIGINS.has(binding.origin))
+                    continue;
+                if (TYPE_KINDS.has(binding.def.type)) {
+                    return binding.def;
+                }
+            }
+            // Shadowed by a non-type / non-strict-origin binding. Fail fast — no
+            // global fallback, no walk to the parent.
+            return null;
+        }
+        currentId = scope.parent;
+    }
+    // Phase 2: dotted fallback via `QualifiedNameIndex`. Only accept a unique
+    // type-kind hit; anything ambiguous returns null (strict: no guesses).
+    if (ref.rawName.includes('.')) {
+        const candidates = ctx.qualifiedNameIndex.get(ref.rawName);
+        let onlyTypeDef = null;
+        for (const defId of candidates) {
+            const def = ctx.defIndex.get(defId);
+            if (def === undefined)
+                continue;
+            if (!TYPE_KINDS.has(def.type))
+                continue;
+            if (onlyTypeDef !== null)
+                return null; // ambiguous
+            onlyTypeDef = def;
+        }
+        if (onlyTypeDef !== null)
+            return onlyTypeDef;
+    }
+    return null;
+}

package/dist/core/code/shared/scope-resolution/scope-id.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * `ScopeId` canonical constructor + string intern pool
+ * (RFC §2.2; Ring 2 SHARED #912).
+ *
+ * `ScopeId` is a deterministic string derived from the scope's file path,
+ * byte range, and kind:
+ *
+ *   scope:{filePath}#{startLine}:{startCol}-{endLine}:{endCol}:{kind}
+ *
+ * Two scopes produced by reparsing the same file at the same positions are
+ * `===`-equal as strings. Beyond the canonical shape, `makeScopeId` also
+ * **interns** the string through a process-local pool, so repeated calls
+ * with structurally identical inputs return the same string reference —
+ * making `Map<ScopeId, ...>` lookups and cache keys identity-fast.
+ *
+ * The intern pool is unbounded. The number of distinct `ScopeId`s across a
+ * single indexing run is O(total scopes in workspace), which is bounded by
+ * source-text size and already in memory; interning adds no asymptotic
+ * pressure. `clearScopeIdInternPool` is exported for test isolation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeScopeId = makeScopeId;
+exports.clearScopeIdInternPool = clearScopeIdInternPool;
+/**
+ * Build a canonical `ScopeId` from its structural parts and intern it.
+ *
+ * Pure + referentially transparent: given the same input shape, always
+ * returns the same string reference for the lifetime of the pool.
+ */
+function makeScopeId(input) {
+    const raw = `scope:${input.filePath}#${input.range.startLine}:${input.range.startCol}-${input.range.endLine}:${input.range.endCol}:${input.kind}`;
+    const existing = INTERN_POOL.get(raw);
+    if (existing !== undefined)
+        return existing;
+    INTERN_POOL.set(raw, raw);
+    return raw;
+}
+/**
+ * Drop the intern pool. Intended for test setup/teardown — production code
+ * should not need this, since the pool's memory usage is bounded by the
+ * number of live scopes and cleaning it mid-run would break identity
+ * equality for existing scope ids.
+ */
+function clearScopeIdInternPool() {
+    INTERN_POOL.clear();
+}
+/** Internal: shared intern pool (process-local). */
+const INTERN_POOL = new Map();

package/dist/core/code/shared/scope-resolution/scope-tree.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * `ScopeTree` — the lexical-scope spine of the `SemanticModel`
+ * (RFC §2.2 + §3.1; Ring 2 SHARED #912).
+ *
+ * Generalizes the `enclosingFunctions` pattern from closed PR #902 to
+ * arbitrary `ScopeKind`s. Owns the (parent ↔ children) relationship
+ * derived from each `Scope.parent` pointer, and validates the structural
+ * invariants a well-formed scope tree must satisfy.
+ *
+ * Invariants enforced at build time (throw on violation):
+ *
+ *   - Every non-`Module` scope has a non-null parent.
+ *   - Every parent pointer references a scope that was also supplied to
+ *     `buildScopeTree`.
+ *   - Parent range **strictly contains** child range.
+ *   - Sibling ranges under the same parent do not overlap.
+ *   - Parent and child live in the same `filePath`. (Cross-file parent
+ *     pointers would be a category error — a `File` scope is not the
+ *     parent of another file's scopes; imports do that job.)
+ *
+ * Satisfies the `ScopeLookup` contract (defined in `./types.js`), so
+ * `resolveTypeRef` (#916) and the scope-aware registries (#917) can take a
+ * `ScopeTree` directly without adapters.
+ *
+ * Immutable surface: `byId` is a `ReadonlyMap`; children arrays are
+ * `Object.freeze`d; miss lookups return a shared frozen empty array.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeTreeInvariantError = void 0;
+exports.buildScopeTree = buildScopeTree;
+exports.canParentScope = canParentScope;
+// ─── Build errors ───────────────────────────────────────────────────────────
+/**
+ * Thrown by `buildScopeTree` when the input violates a structural
+ * invariant. Carries the offending ids + the invariant name so failed
+ * extraction pipelines can report actionable diagnostics.
+ */
+class ScopeTreeInvariantError extends Error {
+    invariant;
+    constructor(invariant, message) {
+        super(message);
+        this.invariant = invariant;
+        this.name = 'ScopeTreeInvariantError';
+    }
+}
+exports.ScopeTreeInvariantError = ScopeTreeInvariantError;
+// ─── Builder ───────────────────────────────────────────────────────────────
+/**
+ * Build an immutable `ScopeTree` from a flat list of `Scope` records.
+ *
+ * Throws `ScopeTreeInvariantError` on the first invariant violation; a
+ * malformed tree is a bug in the extraction pipeline, not a data case for
+ * consumers to handle, so fail-fast is the correct posture.
+ */
+function buildScopeTree(scopes) {
+    const byId = new Map();
+    const childrenById = new Map();
+    // ── Pass 1: collect by id + duplicate check ───────────────────────────
+    for (const scope of scopes) {
+        if (byId.has(scope.id)) {
+            throw new ScopeTreeInvariantError('duplicate-scope-id', `Two scopes share id '${scope.id}'. Scope ids must be unique per tree.`);
+        }
+        byId.set(scope.id, scope);
+    }
+    // ── Pass 2: validate parent pointers + build children buckets ─────────
+    for (const scope of scopes) {
+        if (scope.parent === null) {
+            if (scope.kind !== 'Module') {
+                throw new ScopeTreeInvariantError('non-module-requires-parent', `Scope '${scope.id}' has kind '${scope.kind}' but no parent. Only 'Module' scopes may be root-level.`);
+            }
+            continue;
+        }
+        const parent = byId.get(scope.parent);
+        if (parent === undefined) {
+            throw new ScopeTreeInvariantError('parent-not-found', `Scope '${scope.id}' references parent '${scope.parent}' which is not part of this tree.`);
+        }
+        if (parent.filePath !== scope.filePath) {
+            throw new ScopeTreeInvariantError('parent-must-share-filepath', `Scope '${scope.id}' (${scope.filePath}) has parent '${parent.id}' in a different file (${parent.filePath}). Parent/child scopes must share filePath.`);
+        }
+        if (!canParentScope(parent.range, scope.range, parent.kind, scope.kind)) {
+            throw new ScopeTreeInvariantError('parent-must-contain-child', `Parent scope '${parent.id}' at ${formatRange(parent.range)} does not contain child '${scope.id}' at ${formatRange(scope.range)} (allowed: strict containment, or equal-range Module-as-parent).`);
+        }
+        let bucket = childrenById.get(parent.id);
+        if (bucket === undefined) {
+            bucket = [];
+            childrenById.set(parent.id, bucket);
+        }
+        bucket.push(scope.id);
+    }
+    // ── Pass 3: sibling-overlap check ─────────────────────────────────────
+    for (const [parentId, childIds] of childrenById) {
+        if (childIds.length < 2)
+            continue;
+        // Sort siblings by (startLine, startCol) for an O(n log n) pairwise
+        // scan instead of O(n²) all-pairs.
+        const children = childIds.map((id) => byId.get(id)).slice();
+        children.sort((a, b) => comparePosition(a.range, b.range));
+        for (let i = 1; i < children.length; i++) {
+            const prev = children[i - 1];
+            const curr = children[i];
+            if (rangesOverlap(prev.range, curr.range)) {
+                throw new ScopeTreeInvariantError('sibling-ranges-overlap', `Sibling scopes under parent '${parentId}' overlap: '${prev.id}' ${formatRange(prev.range)} and '${curr.id}' ${formatRange(curr.range)}.`);
+            }
+        }
+    }
+    // Freeze children arrays so the surface is truly read-only.
+    const frozenChildren = new Map();
+    for (const [parentId, childIds] of childrenById) {
+        frozenChildren.set(parentId, Object.freeze(childIds.slice()));
+    }
+    return freezeTree(byId, frozenChildren);
+}
+// ─── Internals ──────────────────────────────────────────────────────────────
+const EMPTY_CHILDREN = Object.freeze([]);
+function freezeTree(byId, childrenById) {
+    return {
+        byId,
+        get size() {
+            return byId.size;
+        },
+        getScope(id) {
+            return byId.get(id);
+        },
+        getParent(id) {
+            const scope = byId.get(id);
+            if (scope === undefined || scope.parent === null)
+                return undefined;
+            return byId.get(scope.parent);
+        },
+        getChildren(id) {
+            return childrenById.get(id) ?? EMPTY_CHILDREN;
+        },
+        getAncestors(id) {
+            const start = byId.get(id);
+            if (start === undefined || start.parent === null)
+                return EMPTY_CHILDREN;
+            const out = [];
+            const visited = new Set([id]);
+            let cursor = start.parent;
+            while (cursor !== null && !visited.has(cursor)) {
+                visited.add(cursor);
+                out.push(cursor);
+                const next = byId.get(cursor);
+                cursor = next === undefined ? null : next.parent;
+            }
+            return Object.freeze(out);
+        },
+        has(id) {
+            return byId.has(id);
+        },
+    };
+}
+/**
+ * `outer` strictly contains `inner` when `outer`'s start is at or before
+ * `inner`'s start, `outer`'s end is at or after `inner`'s end, and they are
+ * not the exact same range. Equal ranges are rejected — a child cannot
+ * occupy the exact same span as its parent.
+ */
+function rangeStrictlyContains(outer, inner) {
+    if (outer.startLine === inner.startLine &&
+        outer.startCol === inner.startCol &&
+        outer.endLine === inner.endLine &&
+        outer.endCol === inner.endCol) {
+        return false;
+    }
+    const outerStartsAtOrBefore = outer.startLine < inner.startLine ||
+        (outer.startLine === inner.startLine && outer.startCol <= inner.startCol);
+    const outerEndsAtOrAfter = outer.endLine > inner.endLine ||
+        (outer.endLine === inner.endLine && outer.endCol >= inner.endCol);
+    return outerStartsAtOrBefore && outerEndsAtOrAfter;
+}
+function rangesEqual(a, b) {
+    return (a.startLine === b.startLine &&
+        a.startCol === b.startCol &&
+        a.endLine === b.endLine &&
+        a.endCol === b.endCol);
+}
+/**
+ * Whether `outer` (kind `outerKind`) is a valid parent for `inner` (kind
+ * `innerKind`).
+ *
+ * Strict containment is the general rule. The single carve-out is the
+ * `Module`/non-`Module` pair whose ranges are exactly equal — this happens
+ * naturally when tree-sitter reports identical byte spans for the
+ * `compilation_unit` (or equivalent file-root construct) and the file's
+ * single top-level scope. Common shape: a C# file consisting of nothing
+ * but `namespace X { ... }` with no leading or trailing trivia outside the
+ * namespace's `{}` body — `compilation_unit` and `namespace_declaration`
+ * both span exactly the same byte range. The `Module` is the universal
+ * outer of any file-level scope by language semantics, so coincident
+ * ranges should not break the parent chain.
+ *
+ * The carve-out is direction-asymmetric: only `Module`-as-outer parents a
+ * same-range non-`Module`, never the reverse. This preserves the
+ * acyclicity buildScopeTree relies on, and matches the corresponding
+ * helper in `scope-extractor.ts` so `pass1BuildScopes` and the validator
+ * agree on what a well-formed parent edge looks like.
+ */
+function canParentScope(outer, inner, outerKind, innerKind) {
+    if (rangeStrictlyContains(outer, inner))
+        return true;
+    if (outerKind === 'Module' && innerKind !== 'Module' && rangesEqual(outer, inner))
+        return true;
+    return false;
+}
+/**
+ * Two ranges overlap when neither finishes before the other begins. Ranges
+ * that merely touch at a single boundary point (`a.end === b.start`) do
+ * NOT overlap — this matches tree-sitter's half-open-like range semantics
+ * and the typical "sibling blocks meet but don't overlap" pattern.
+ */
+function rangesOverlap(a, b) {
+    const aEndsBeforeB = a.endLine < b.startLine || (a.endLine === b.startLine && a.endCol <= b.startCol);
+    const bEndsBeforeA = b.endLine < a.startLine || (b.endLine === a.startLine && b.endCol <= a.startCol);
+    return !(aEndsBeforeB || bEndsBeforeA);
+}
+function comparePosition(a, b) {
+    if (a.startLine !== b.startLine)
+        return a.startLine - b.startLine;
+    return a.startCol - b.startCol;
+}
+function formatRange(r) {
+    return `${r.startLine}:${r.startCol}-${r.endLine}:${r.endCol}`;
+}

package/dist/core/code/shared/scope-resolution/symbol-definition.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * `SymbolDefinition` — the canonical shape of an indexed symbol record.
+ *
+ * Historically defined in `cgraph/src/core/ingestion/model/symbol-table.ts`;
+ * moved into `cgraph-shared` as part of RFC #909 Ring 1 (#910) so the
+ * scope-resolution types that reference it can live in the shared package
+ * alongside their consumers (`cgraph/` and `cgraph-web/`).
+ *
+ * Shape is unchanged from the prior local definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/scope-resolution/types.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Scope-resolution type definitions — RFC §2 data model (authoritative source).
+ *
+ * See: https://www.notion.so/346dc50b6ed281cfaacbe480bf231d50
+ *
+ * Anti-drift rule: every type, interface, and enum defined here is the single
+ * source of truth. Later code that references these names must import them
+ * from `cgraph-shared`; it must not re-define them locally.
+ *
+ * Lifecycle contract (RFC §2.8): scopes are **constructed during extraction,
+ * linked during finalize, immutable after finalize**. All fields are
+ * `readonly` at the type level; `Object.freeze` is applied at runtime in dev
+ * builds.
+ *
+ * Two structures are populated after freeze:
+ *   1. `ReferenceIndex` — by resolution, before emission.
+ *   2. `ScopeResolutionIndexes.bindingAugmentations` — the dedicated
+ *      append-only post-finalize binding channel (e.g. C# same-namespace
+ *      cross-file fanout). The companion `indexes.bindings` is the
+ *      finalize-output channel and is deep-frozen by `materializeBindings`;
+ *      walkers consult both via `lookupBindingsAt`. See `ScopeResolver`
+ *      Invariant I8 for the full lifecycle contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/test-helpers.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Test-only helpers.
+ *
+ * Symbols here are reachable from `cgraph-shared/test-helpers` so test
+ * suites can reset shared registries or exercise internal classifiers,
+ * but they are deliberately NOT re-exported from the main `cgraph-shared`
+ * barrel. Production consumers should never import this module — calling
+ * `__resetBreakerRegistry__()` from a tool implementation would silently
+ * nuke every circuit breaker process-wide.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyOutcome = exports.__resetBreakerRegistry__ = void 0;
+var circuit_breaker_js_1 = require("./integrations/circuit-breaker.js");
+Object.defineProperty(exports, "__resetBreakerRegistry__", { enumerable: true, get: function () { return circuit_breaker_js_1.__resetBreakerRegistry__; } });
+var resilient_fetch_js_1 = require("./integrations/resilient-fetch.js");
+Object.defineProperty(exports, "classifyOutcome", { enumerable: true, get: function () { return resilient_fetch_js_1.classifyOutcome; } });