gitnexus 1.6.6-rc.2 → 1.6.6-rc.21

package/dist/core/ingestion/model/field-registry.d.ts

@@ -2,15 +2,29 @@
  * Field Registry
  *
  * Owner-scoped field/property index extracted from SymbolTable.
- * Stores Property symbols keyed by `ownerNodeId\0fieldName` for O(1) lookup.
+ * Stores Property / Variable / Const / Static symbols keyed by
+ * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
+ * under the same (owner, name) — e.g. legacy Property plus a
+ * scope-resolution Variable reconciliation entry.
  */
 import type { SymbolDefinition } from '../../../_shared/index.js';
 export interface FieldRegistry {
-    /** Look up a field/property by its owning class nodeId and field name. */
+    /**
+     * First field registered under `(ownerNodeId, fieldName)`, if any.
+     * Registration order is first-wins: when a Property and a Variable share
+     * an `(owner, simpleName)` key, the earlier `register(...)` call's def is
+     * returned. Prefer `lookupAllByOwner` when overloads or duplicate-kind
+     * entries under the same name must all be visible.
+     */
     lookupFieldByOwner(ownerNodeId: string, fieldName: string): SymbolDefinition | undefined;
+    /**
+     * Every field registered under `(ownerNodeId, fieldName)` in registration
+     * order. Returns `[]` on miss.
+     */
+    lookupAllByOwner(ownerNodeId: string, fieldName: string): readonly SymbolDefinition[];
 }
 export interface MutableFieldRegistry extends FieldRegistry {
-    /** Register a field/property under its owner. */
+    /** Register a field under its owner. Appends when the key already exists. */
     register(ownerNodeId: string, fieldName: string, def: SymbolDefinition): void;
     /** Clear all entries. */
     clear(): void;

package/dist/core/ingestion/model/field-registry.js

@@ -2,21 +2,36 @@
  * Field Registry
  *
  * Owner-scoped field/property index extracted from SymbolTable.
- * Stores Property symbols keyed by `ownerNodeId\0fieldName` for O(1) lookup.
+ * Stores Property / Variable / Const / Static symbols keyed by
+ * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
+ * under the same (owner, name) — e.g. legacy Property plus a
+ * scope-resolution Variable reconciliation entry.
  */
+const EMPTY = Object.freeze([]);
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
 export const createFieldRegistry = () => {
     const fieldByOwner = new Map();
+    const lookupAllByOwner = (ownerNodeId, fieldName) => {
+        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`) ?? EMPTY;
+    };
     const lookupFieldByOwner = (ownerNodeId, fieldName) => {
-        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`);
+        const pool = lookupAllByOwner(ownerNodeId, fieldName);
+        return pool.length === 0 ? undefined : pool[0];
     };
     const register = (ownerNodeId, fieldName, def) => {
-        fieldByOwner.set(`${ownerNodeId}\0${fieldName}`, def);
+        const key = `${ownerNodeId}\0${fieldName}`;
+        const existing = fieldByOwner.get(key);
+        if (existing) {
+            existing.push(def);
+        }
+        else {
+            fieldByOwner.set(key, [def]);
+        }
     };
     const clear = () => {
         fieldByOwner.clear();
     };
-    return { lookupFieldByOwner, register, clear };
+    return { lookupFieldByOwner, lookupAllByOwner, register, clear };
 };

package/dist/core/ingestion/model/owned-members-lookup.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Owner-keyed member lookup for Step 2 (RFC #909 / PR #1656).
+ *
+ * Merges MethodRegistry + FieldRegistry hits for `(ownerDefId, memberName)`
+ * in O(1) map time per registry — no `defs.byId` scan. Callers that omit
+ * this helper and leave `ownedMembersByOwner` unset fall back to an O(|defs|)
+ * compatibility scan inside `lookupCore.collectOwnedMembers`.
+ */
+import type { DefId, SymbolDefinition } from '../../../_shared/index.js';
+import type { SemanticModel } from './semantic-model.js';
+/**
+ * Production hook for `RegistryContext.ownedMembersByOwner`.
+ * Returns `[]` on miss (authoritative indexed empty) — never `undefined`.
+ *
+ * Merges hits from all three owner-keyed registries (methods, fields,
+ * nested types) under the same `(ownerDefId, memberName)` key. The
+ * caller's `acceptedKinds` filter in `lookupCore` picks the right subset.
+ */
+export declare function lookupOwnedMembersByOwner(model: Pick<SemanticModel, 'methods' | 'fields' | 'types'>, ownerDefId: DefId, memberName: string): readonly SymbolDefinition[];

package/dist/core/ingestion/model/owned-members-lookup.js

@@ -0,0 +1,43 @@
+/**
+ * Owner-keyed member lookup for Step 2 (RFC #909 / PR #1656).
+ *
+ * Merges MethodRegistry + FieldRegistry hits for `(ownerDefId, memberName)`
+ * in O(1) map time per registry — no `defs.byId` scan. Callers that omit
+ * this helper and leave `ownedMembersByOwner` unset fall back to an O(|defs|)
+ * compatibility scan inside `lookupCore.collectOwnedMembers`.
+ */
+const EMPTY = Object.freeze([]);
+/**
+ * Production hook for `RegistryContext.ownedMembersByOwner`.
+ * Returns `[]` on miss (authoritative indexed empty) — never `undefined`.
+ *
+ * Merges hits from all three owner-keyed registries (methods, fields,
+ * nested types) under the same `(ownerDefId, memberName)` key. The
+ * caller's `acceptedKinds` filter in `lookupCore` picks the right subset.
+ */
+export function lookupOwnedMembersByOwner(model, ownerDefId, memberName) {
+    const methods = model.methods.lookupAllByOwner(ownerDefId, memberName);
+    const fields = model.fields.lookupAllByOwner(ownerDefId, memberName);
+    const nestedTypes = model.types.lookupAllByOwner(ownerDefId, memberName);
+    const methodCount = methods.length;
+    const fieldCount = fields.length;
+    const typeCount = nestedTypes.length;
+    const total = methodCount + fieldCount + typeCount;
+    if (total === 0)
+        return EMPTY;
+    if (methodCount === total)
+        return methods;
+    if (fieldCount === total)
+        return fields;
+    if (typeCount === total)
+        return nestedTypes;
+    const merged = new Array(total);
+    let i = 0;
+    for (let j = 0; j < methodCount; j++)
+        merged[i++] = methods[j];
+    for (let j = 0; j < fieldCount; j++)
+        merged[i++] = fields[j];
+    for (let j = 0; j < typeCount; j++)
+        merged[i++] = nestedTypes[j];
+    return merged;
+}

package/dist/core/ingestion/model/type-registry.d.ts

@@ -27,12 +27,21 @@ export interface TypeRegistry {
      * Returned array is a view into the live index — do not mutate.
      */
     lookupImplByName(name: string): readonly SymbolDefinition[];
+    /**
+     * Look up nested-type defs registered under `(ownerNodeId, simpleName)`
+     * in registration order. Returns `[]` on miss. Used by Step 2 Receiver/MRO
+     * resolution when the receiver's owner declares nested classes/structs/
+     * enums/typedefs/etc. that the caller's `acceptedKinds` includes.
+     */
+    lookupAllByOwner(ownerNodeId: string, simpleName: string): readonly SymbolDefinition[];
 }
 export interface MutableTypeRegistry extends TypeRegistry {
     /** Register a class-like type by name and qualified name. */
     registerClass(name: string, qualifiedName: string, def: SymbolDefinition): void;
     /** Register a Rust Impl block by name. */
     registerImpl(name: string, def: SymbolDefinition): void;
+    /** Register a nested type under its owner. Appends when the key already exists. */
+    registerByOwner(ownerNodeId: string, simpleName: string, def: SymbolDefinition): void;
     /** Clear all entries. */
     clear(): void;
 }

package/dist/core/ingestion/model/type-registry.js

@@ -5,6 +5,7 @@
  * Eagerly-populated indexes keyed by symbol name and qualified name.
  * Also includes a separate index for Rust Impl blocks.
  */
+const EMPTY = Object.freeze([]);
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -12,6 +13,7 @@ export const createTypeRegistry = () => {
     const classByName = new Map();
     const classByQualifiedName = new Map();
     const implByName = new Map();
+    const nestedByOwner = new Map();
     const lookupClassByName = (name) => {
         return classByName.get(name) ?? [];
     };
@@ -21,6 +23,9 @@ export const createTypeRegistry = () => {
     const lookupImplByName = (name) => {
         return implByName.get(name) ?? [];
     };
+    const lookupAllByOwner = (ownerNodeId, simpleName) => {
+        return nestedByOwner.get(`${ownerNodeId}\0${simpleName}`) ?? EMPTY;
+    };
     const registerClass = (name, qualifiedName, def) => {
         const existing = classByName.get(name);
         if (existing) {
@@ -46,17 +51,30 @@ export const createTypeRegistry = () => {
             implByName.set(name, [def]);
         }
     };
+    const registerByOwner = (ownerNodeId, simpleName, def) => {
+        const key = `${ownerNodeId}\0${simpleName}`;
+        const existing = nestedByOwner.get(key);
+        if (existing) {
+            existing.push(def);
+        }
+        else {
+            nestedByOwner.set(key, [def]);
+        }
+    };
     const clear = () => {
         classByName.clear();
         classByQualifiedName.clear();
         implByName.clear();
+        nestedByOwner.clear();
     };
     return {
         lookupClassByName,
         lookupClassByQualifiedName,
         lookupImplByName,
+        lookupAllByOwner,
         registerClass,
         registerImpl,
+        registerByOwner,
         clear,
     };
 };

package/dist/core/ingestion/registry-primary-flag.js

@@ -72,6 +72,7 @@ export const MIGRATED_LANGUAGES = new Set([
     SupportedLanguages.C,
     SupportedLanguages.CPlusPlus,
     SupportedLanguages.PHP,
+    SupportedLanguages.JavaScript,
 ]);
 /**
  * Return the env-var name that controls a given language's registry-

package/dist/core/ingestion/resolve-references.d.ts

@@ -37,12 +37,14 @@
  *     resolution but not emitted as multiple edges; callers that want
  *     branch-on-ambiguity behavior should consume the registries directly.
  */
-import { CLASS_KINDS, FIELD_KINDS, METHOD_KINDS, type ReferenceIndex, type RegistryProviders } from '../../_shared/index.js';
+import { CLASS_KINDS, FIELD_KINDS, METHOD_KINDS, type ReferenceIndex, type RegistryContext, type RegistryProviders } from '../../_shared/index.js';
 import type { ScopeResolutionIndexes } from './model/scope-resolution-indexes.js';
 export interface ResolveReferencesInput {
     readonly scopes: ScopeResolutionIndexes;
     /** Provider hooks consumed by the registries (e.g. `arityCompatibility`). */
     readonly providers?: RegistryProviders;
+    /** Required owner-keyed member lookup used by Step 2 receiver/MRO walks. */
+    readonly ownedMembersByOwner: RegistryContext['ownedMembersByOwner'];
 }
 export interface ResolveStats {
     readonly sitesProcessed: number;

package/dist/core/ingestion/resolve-references.js

@@ -51,6 +51,7 @@ export function resolveReferenceSites(input) {
         defs: scopes.defs,
         qualifiedNames: scopes.qualifiedNames,
         moduleScopes: scopes.moduleScopes,
+        ownedMembersByOwner: input.ownedMembersByOwner,
         methodDispatch: scopes.methodDispatch,
         providers,
     };
@@ -135,7 +136,10 @@ function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry) {
         case 'write': {
             // Try field first; fall through to method then class so bare-name
             // reads of a function (e.g. `cb = save`) still resolve.
-            const fieldHits = fieldRegistry.lookup(site.name, site.inScope);
+            const fieldOpts = {
+                ...(site.explicitReceiver !== undefined ? { explicitReceiver: site.explicitReceiver } : {}),
+            };
+            const fieldHits = fieldRegistry.lookup(site.name, site.inScope, fieldOpts);
             if (fieldHits.length > 0)
                 return fieldHits;
             const methodHits = methodRegistry.lookup(site.name, site.inScope);

package/dist/core/ingestion/scope-extractor.js

@@ -692,6 +692,7 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
         const explicitReceiver = extractExplicitReceiver(match);
         const arity = extractArity(match);
         const argumentTypes = extractArgumentTypes(match);
+        const argumentTypeClasses = parseJsonParameterTypeClassesCapture(match['@reference.parameter-type-classes']);
         const site = {
             name: nameCap.text,
             atRange: anchor.range,
@@ -701,6 +702,7 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
             ...(explicitReceiver !== undefined ? { explicitReceiver } : {}),
             ...(arity !== undefined ? { arity } : {}),
             ...(argumentTypes !== undefined ? { argumentTypes } : {}),
+            ...(argumentTypeClasses !== undefined ? { argumentTypeClasses } : {}),
         };
         referenceSites.push(site);
     }
@@ -806,9 +808,11 @@ const KNOWN_SUB_TAGS = new Set([
     '@reference.receiver',
     '@reference.arity',
     '@reference.parameter-types',
+    '@reference.parameter-type-classes',
     '@declaration.parameter-count',
     '@declaration.required-parameter-count',
     '@declaration.parameter-types',
+    '@declaration.parameter-type-classes',
     '@declaration.template-constraints',
 ]);
 /**

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -70,6 +70,7 @@ export declare function pickImplicitThisOverload(site: {
     readonly name: string;
     readonly arity?: number;
     readonly argumentTypes?: readonly string[];
+    readonly argumentTypeClasses?: readonly import('../../../../_shared/index.js').ParameterTypeClass[];
 }, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, hookCtx?: {
     readonly conversionRankFn?: ConversionRankFn;
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -22,6 +22,11 @@ import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
     const seen = new Set();
+    // Build an O(1) simple-name -> callable defs index over scopes.defs once
+    // per pass so pickUniqueGlobalCallable doesn't re-scan defs.byId.values()
+    // per call site. Same name + callable-kind filter that the previous scan
+    // applied (see pickUniqueGlobalCallable JSDoc). Cost: O(|defs|) once.
+    const globalCallablesBySimpleName = buildGlobalCallableIndex(scopes);
     for (const parsed of parsedFiles) {
         for (const site of parsed.referenceSites) {
             if (site.kind !== 'call')
@@ -67,6 +72,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         const allCallables = findAllCallableBindingsInScope(site.inScope, site.name, scopes);
                         if (allCallables.length > 1) {
                             const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
+                                argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
@@ -121,6 +127,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         }
                         else {
                             const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, {
+                                argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
@@ -159,6 +166,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         push(ordinary);
                         push(adl);
                         const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, {
+                            argumentTypeClasses: site.argumentTypeClasses,
                             conversionRankFn: options.conversionRankFn,
                             constraintCompatibility: options.constraintCompatibility,
                         });
@@ -187,7 +195,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the caller does not import the target package. Same-package calls are
             // usually caught by nearest-scope lookup before reaching here.
             if (fnDef === undefined && options.allowGlobalFallback === true) {
-                fnDef = pickUniqueGlobalCallable(site.name, model, scopes, parsed.filePath, options.isFileLocalDef, site.arity, options.isCallableVisibleFromCaller !== undefined
+                fnDef = pickUniqueGlobalCallable(site.name, model, globalCallablesBySimpleName, parsed.filePath, options.isFileLocalDef, site.arity, options.isCallableVisibleFromCaller !== undefined
                     ? (candidate) => options.isCallableVisibleFromCaller({
                         callerParsed: parsed,
                         candidate,
@@ -227,15 +235,36 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     }
     return emitted;
 }
-function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, conversionRankFn) {
-    const scopeDefs = [];
-    const scopeSeen = new Set();
+/**
+ * Build a `simpleName -> callable defs` index from `scopes.defs` once per
+ * pass. Mirrors the filter the old per-site scan applied: Function /
+ * Method / Constructor, keyed by the last `.`-segment of `qualifiedName`
+ * (falling back to the qualifiedName itself when undotted). Used by
+ * `pickUniqueGlobalCallable` so every free-call fallback site is O(1)
+ * instead of O(|defs|).
+ */
+function buildGlobalCallableIndex(scopes) {
+    const out = new Map();
     for (const def of scopes.defs.byId.values()) {
-        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName;
-        if (simple !== name)
-            continue;
         if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
             continue;
+        const qualified = def.qualifiedName;
+        if (qualified === undefined || qualified.length === 0)
+            continue;
+        const dot = qualified.lastIndexOf('.');
+        const simple = dot === -1 ? qualified : qualified.slice(dot + 1);
+        const bucket = out.get(simple);
+        if (bucket)
+            bucket.push(def);
+        else
+            out.set(simple, [def]);
+    }
+    return out;
+}
+function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, conversionRankFn) {
+    const scopeDefs = [];
+    const scopeSeen = new Set();
+    for (const def of globalCallablesBySimpleName.get(name) ?? []) {
         // Skip file-local defs (e.g. C `static` functions) that live in a
         // different file from the caller — they are logically invisible.
         if (isFileLocalDef !== undefined && def.filePath !== callerFilePath && isFileLocalDef(def)) {
@@ -401,6 +430,7 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
     // disambiguating signal) leaves the call unresolved rather than
     // routing to an arbitrary first overload by registration order.
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: hookCtx?.conversionRankFn,
         constraintCompatibility: hookCtx?.constraintCompatibility,
     });

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -59,6 +59,8 @@ export type ConversionRankFn = (argType: string, paramType: string) => number;
  * undefined preserves the legacy arity + exact-type behavior.
  */
 export interface OverloadNarrowingHookCtx {
+    /** Shape-preserving per-argument sidecar aligned with `argTypes`. */
+    readonly argumentTypeClasses?: ConstraintContext['argumentTypeClasses'];
     /** Conversion-rank scoring fallback (step 4b). Engages when the
      *  exact-type filter rejects every candidate. */
     readonly conversionRankFn?: ConversionRankFn;

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -118,7 +118,14 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
     // than emitting a wrong edge.
     if (hookCtx?.constraintCompatibility !== undefined && argCount !== undefined) {
         const callsite = { arity: argCount };
-        const ctx = argTypes !== undefined ? { argumentTypes: argTypes } : {};
+        const ctx = argTypes !== undefined
+            ? {
+                argumentTypes: argTypes,
+                ...(hookCtx.argumentTypeClasses !== undefined
+                    ? { argumentTypeClasses: hookCtx.argumentTypeClasses }
+                    : {}),
+            }
+            : {};
         result = result.filter((def) => {
             if (def.templateConstraints === undefined)
                 return true;

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -250,6 +250,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         const methodOverloads = model.methods.lookupAllByOwner(ownerId, memberName);
                         if (methodOverloads.length > 0) {
                             const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, {
+                                argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: provider.conversionRankFn,
                                 constraintCompatibility: provider.constraintCompatibility,
                             });
@@ -532,6 +533,7 @@ function pickOverload(ownerId, memberName, site, model, provider) {
     if (overloads.length === 1)
         return overloads[0];
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
         constraintCompatibility: provider.constraintCompatibility,
     });

package/dist/core/ingestion/scope-resolution/pipeline/reconcile-ownership.d.ts

@@ -18,8 +18,8 @@
  * undefined `ownerId` is reachable via either:
  *   - `model.methods.lookupAllByOwner(ownerId, simpleName)` — if the
  *     def is a Method / Function / Constructor, OR
- *   - `model.fields.lookupFieldByOwner(ownerId, simpleName)` — if the
- *     def is a Property / Variable.
+ *   - `model.fields.lookupAllByOwner(ownerId, simpleName)` — if the
+ *     def is a Property / Variable / Const / Static.
  *
  * This invariant is the foundation of Contract Invariant I9
  * (`contract/scope-resolver.ts`): scope-resolution passes MUST read
@@ -47,6 +47,8 @@ export interface ReconcileStats {
     readonly methodsRegistered: number;
     /** Property/Variable defs registered into FieldRegistry. */
     readonly fieldsRegistered: number;
+    /** Class-like nested type defs registered into TypeRegistry by owner. */
+    readonly nestedTypesRegistered: number;
     /** Defs already present (idempotent skip). */
     readonly skippedAlreadyPresent: number;
 }

package/dist/core/ingestion/scope-resolution/pipeline/reconcile-ownership.js

@@ -18,8 +18,8 @@
  * undefined `ownerId` is reachable via either:
  *   - `model.methods.lookupAllByOwner(ownerId, simpleName)` — if the
  *     def is a Method / Function / Constructor, OR
- *   - `model.fields.lookupFieldByOwner(ownerId, simpleName)` — if the
- *     def is a Property / Variable.
+ *   - `model.fields.lookupAllByOwner(ownerId, simpleName)` — if the
+ *     def is a Property / Variable / Const / Static.
  *
  * This invariant is the foundation of Contract Invariant I9
  * (`contract/scope-resolver.ts`): scope-resolution passes MUST read
@@ -41,9 +41,25 @@
  * follow-up plan.
  */
 import { simpleQualifiedName } from '../graph-bridge/ids.js';
+const NESTED_TYPE_KINDS = new Set([
+    'Class',
+    'Interface',
+    'Enum',
+    'Struct',
+    'Union',
+    'Trait',
+    'TypeAlias',
+    'Typedef',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Template',
+    'Namespace',
+]);
 export function reconcileOwnership(parsedFiles, model) {
     let methodsRegistered = 0;
     let fieldsRegistered = 0;
+    let nestedTypesRegistered = 0;
     let skippedAlreadyPresent = 0;
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
@@ -62,18 +78,30 @@ export function reconcileOwnership(parsedFiles, model) {
                 model.methods.register(ownerId, simple, def);
                 methodsRegistered++;
             }
-            else if (def.type === 'Property' || def.type === 'Variable') {
-                const existing = model.fields.lookupFieldByOwner(ownerId, simple);
-                if (existing !== undefined && existing.nodeId === def.nodeId) {
+            else if (def.type === 'Property' ||
+                def.type === 'Variable' ||
+                def.type === 'Const' ||
+                def.type === 'Static') {
+                const existing = model.fields.lookupAllByOwner(ownerId, simple);
+                if (existing.some((e) => e.nodeId === def.nodeId)) {
                     skippedAlreadyPresent++;
                     continue;
                 }
                 model.fields.register(ownerId, simple, def);
                 fieldsRegistered++;
             }
+            else if (NESTED_TYPE_KINDS.has(def.type)) {
+                const existing = model.types.lookupAllByOwner(ownerId, simple);
+                if (existing.some((e) => e.nodeId === def.nodeId)) {
+                    skippedAlreadyPresent++;
+                    continue;
+                }
+                model.types.registerByOwner(ownerId, simple, def);
+                nestedTypesRegistered++;
+            }
         }
     }
-    return { methodsRegistered, fieldsRegistered, skippedAlreadyPresent };
+    return { methodsRegistered, fieldsRegistered, nestedTypesRegistered, skippedAlreadyPresent };
 }
 /**
  * Debug-mode parity validator. Runs only when
@@ -111,14 +139,25 @@ export function validateOwnershipParity(parsedFiles, model, onWarn) {
                     mismatches++;
                 }
             }
-            else if (def.type === 'Property' || def.type === 'Variable') {
-                const found = model.fields.lookupFieldByOwner(ownerId, simple);
-                if (found === undefined || found.nodeId !== def.nodeId) {
+            else if (def.type === 'Property' ||
+                def.type === 'Variable' ||
+                def.type === 'Const' ||
+                def.type === 'Static') {
+                const found = model.fields.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
                     onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
                         `owned by ${ownerId} as "${simple}" not in FieldRegistry`);
                     mismatches++;
                 }
             }
+            else if (NESTED_TYPE_KINDS.has(def.type)) {
+                const found = model.types.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
+                    onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
+                        `owned by ${ownerId} as "${simple}" not in TypeRegistry owner index`);
+                    mismatches++;
+                }
+            }
         }
     }
     return mismatches;

package/dist/core/ingestion/scope-resolution/pipeline/registry.js

@@ -17,6 +17,7 @@ import { javaScopeResolver } from '../../languages/java/scope-resolver.js';
 import { cScopeResolver } from '../../languages/c/scope-resolver.js';
 import { cppScopeResolver } from '../../languages/cpp/scope-resolver.js';
 import { phpScopeResolver } from '../../languages/php/scope-resolver.js';
+import { javascriptScopeResolver } from '../../languages/javascript/scope-resolver.js';
 /** Map of `SupportedLanguages` → `ScopeResolver`. The phase iterates
  *  this map intersected with `MIGRATED_LANGUAGES` (the per-language
  *  flag set) so adding a resolver here without flipping the flag is
@@ -30,4 +31,5 @@ export const SCOPE_RESOLVERS = new Map([
     [SupportedLanguages.C, cScopeResolver],
     [SupportedLanguages.CPlusPlus, cppScopeResolver],
     [SupportedLanguages.PHP, phpScopeResolver],
+    [SupportedLanguages.JavaScript, javascriptScopeResolver],
 ]);

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -22,6 +22,7 @@
  *
  * Plan: `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
+import { lookupOwnedMembersByOwner } from '../../model/owned-members-lookup.js';
 import { reconcileOwnership, validateOwnershipParity } from './reconcile-ownership.js';
 import { validateBindingsImmutability } from './validate-bindings-immutability.js';
 import { extractParsedFile } from '../../scope-extractor-bridge.js';
@@ -236,6 +237,7 @@ export function runScopeResolution(input, provider) {
     const { referenceIndex, stats: resolveStats } = resolveReferenceSites({
         scopes: indexes,
         providers: registryProviders,
+        ownedMembersByOwner: (ownerDefId, memberName) => lookupOwnedMembersByOwner(readonlyModel, ownerDefId, memberName),
     });
     const tResolve = PROF ? process.hrtime.bigint() : 0n;
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────

package/dist/core/lbug/lbug-adapter.d.ts

@@ -66,7 +66,9 @@ export declare const initLbug: (dbPath: string) => Promise<{
  * database is busy (e.g. `gitnexus analyze` holds the write lock).
  * Each retry waits DB_LOCK_RETRY_DELAY_MS * attempt milliseconds.
  */
-export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>) => Promise<T>;
+export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>, options?: {
+    readOnly?: boolean;
+}) => Promise<T>;
 export type LbugProgressCallback = (message: string) => void;
 export declare const loadGraphToLbug: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: LbugProgressCallback) => Promise<{
     success: boolean;