homegraph 1.6.3 → 1.6.4

package/dist/extraction/jsdoc-type-tags.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Spec 0066 — parse JSDoc `@returns` / `@param` type tags as a fallback when
+ * the signature has no usable return/param type name. Docstring text still
+ * lives on `nodes.docstring` (Spec 0020); this only extracts type *names*.
+ */
+/**
+ * Unwrap Promise/Array/… and strip arrays/generics to a bare type identifier.
+ * Returns undefined for empty / primitive / void-like results.
+ */
+export declare function extractBaseTypeName(raw: string | undefined | null): string | undefined;
+/** `@returns {Type}` or `@return Type` → base type name. */
+export declare function parseJsdocReturns(docstring: string | undefined | null): string | undefined;
+export interface JsdocParamType {
+    paramName: string;
+    typeName: string;
+}
+/** `@param {Type} name` entries with a resolvable type name. */
+export declare function parseJsdocParams(docstring: string | undefined | null): JsdocParamType[];
+//# sourceMappingURL=jsdoc-type-tags.d.ts.map

package/dist/extraction/jsdoc-type-tags.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Spec 0066 — parse JSDoc `@returns` / `@param` type tags as a fallback when
+ * the signature has no usable return/param type name. Docstring text still
+ * lives on `nodes.docstring` (Spec 0020); this only extracts type *names*.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractBaseTypeName = extractBaseTypeName;
+exports.parseJsdocReturns = parseJsdocReturns;
+exports.parseJsdocParams = parseJsdocParams;
+const PRIMITIVE_OR_VOID = new Set([
+    'void',
+    'undefined',
+    'null',
+    'never',
+    'any',
+    'unknown',
+    'object',
+    'Object',
+    'string',
+    'String',
+    'number',
+    'Number',
+    'boolean',
+    'Boolean',
+    'bigint',
+    'symbol',
+    'Symbol',
+    'this',
+    'self',
+    'static',
+]);
+/**
+ * Unwrap Promise/Array/… and strip arrays/generics to a bare type identifier.
+ * Returns undefined for empty / primitive / void-like results.
+ */
+function extractBaseTypeName(raw) {
+    if (!raw)
+        return undefined;
+    let t = raw.trim();
+    if (!t)
+        return undefined;
+    // Drop leading `readonly` / `export` noise occasionally glued into tags.
+    t = t.replace(/^(?:readonly|export|declare)\s+/i, '').trim();
+    // Take the first union arm: `Foo | null` → `Foo`.
+    if (t.includes('|')) {
+        t = t.split('|')[0].trim();
+    }
+    // Function type → skip (no single type node).
+    if (t.includes('=>'))
+        return undefined;
+    if (t.endsWith('[]')) {
+        t = t.slice(0, -2).trim();
+    }
+    const wrapper = t.match(/^(?:Promise|Array|ReadonlyArray|Callback|Set|Iterable|Partial|Required|Readonly)\s*<\s*(.+)\s*>$/i);
+    if (wrapper?.[1]) {
+        t = wrapper[1].trim();
+        // Nested commas in Map/Record — take last type arg when present.
+        if (t.includes(',')) {
+            const mapLike = t.match(/^(?:Map|Record)\s*<[^,]+,\s*(.+)>$/i);
+            if (mapLike?.[1])
+                t = mapLike[1].trim();
+            else
+                t = t.split(',').pop().trim();
+        }
+    }
+    const mapMatch = t.match(/^(?:Map|Record)\s*<[^,]+,\s*(.+)>$/i);
+    if (mapMatch?.[1])
+        t = mapMatch[1].trim();
+    // Strip remaining generics: `Foo<T>` → `Foo`
+    t = t.replace(/<[^>]*>/g, '').replace(/\[\]/g, '').trim();
+    if (!t)
+        return undefined;
+    // Qualified → trailing simple name (`ns.Bar` → `Bar`)
+    const simple = t.split('.').filter(Boolean).pop() ?? t;
+    if (!simple || PRIMITIVE_OR_VOID.has(simple))
+        return undefined;
+    // Must look like an identifier (PascalCase preferred but allow any word).
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(simple))
+        return undefined;
+    return simple;
+}
+/** `@returns {Type}` or `@return Type` → base type name. */
+function parseJsdocReturns(docstring) {
+    if (!docstring)
+        return undefined;
+    const re = /@returns?\s+(?:\{([^}]+)\}|([A-Za-z_][\w.<>[\],\s|]*))/gi;
+    let m;
+    while ((m = re.exec(docstring)) !== null) {
+        const raw = (m[1] ?? m[2] ?? '').trim();
+        const base = extractBaseTypeName(raw);
+        if (base)
+            return base;
+    }
+    return undefined;
+}
+/** `@param {Type} name` entries with a resolvable type name. */
+function parseJsdocParams(docstring) {
+    if (!docstring)
+        return [];
+    const out = [];
+    const re = /@param(?:eter)?\s+(?:\{([^}]+)\}\s+)?\[?(\w+)\]?/gi;
+    let m;
+    while ((m = re.exec(docstring)) !== null) {
+        const typeRaw = m[1]?.trim();
+        const paramName = m[2];
+        if (!typeRaw || !paramName)
+            continue;
+        const typeName = extractBaseTypeName(typeRaw);
+        if (typeName)
+            out.push({ paramName, typeName });
+    }
+    return out;
+}
+//# sourceMappingURL=jsdoc-type-tags.js.map

package/dist/extraction/languages/arkts.js

@@ -141,6 +141,7 @@ const liveness_watchdog_1 = require("../../mcp/liveness-watchdog");
 const migrate_semantics_1 = require("../../arkui/migrate-semantics");
 const migrate_passage_1 = require("../../arkui/migrate-passage");
 const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+const jsdoc_type_tags_1 = require("../jsdoc-type-tags");
 const wasm_runtime_flags_1 = require("../wasm-runtime-flags");
 const ignore_1 = __importDefault(require("ignore"));
 /** Primitive / void return types — not stored in nodes.return_type (inference-only column). */
@@ -3995,29 +3996,18 @@ class ArkTSAdapter {
             this.crossFileEdges.push(edge);
         }
     }
-    ensureMethodNode(method, relativePath, result, parentId) {
-        const existing = this.methodToId.get(method);
-        if (existing)
-            return existing;
-        try {
-            const bySig = this.methodSigToId.get(method.getSignature().toString());
-            if (bySig) {
-                this.methodToId.set(method, bySig);
-                return bySig;
-            }
-        }
-        catch {
-            // fall through
-        }
-        if (shouldSkipArkMethod(method) && !isAnonymousArkMethod(method))
-            return null;
-        const displayName = arkMethodDisplayName(method);
-        if (!displayName)
-            return null;
-        const cls = method.getDeclaringArkClass();
-        const kind = cls.isDefaultArkClass() ? 'function' : 'method';
-        this.indexMethod(relativePath, languageForArkAnalyzerPath(relativePath), result, method, parentId, kind, displayName);
-        return this.methodToId.get(method) ?? null;
+    /**
+     * Lazily index a method for ViewTree (and any caller that used to pass the
+     * ViewTree owner path). Attribution always follows the method's declaring
+     * ArkFile / class — same as {@link resolveMethodNodeId} — so nested ViewTree
+     * walks cannot pin `%AM*` handlers onto the importer (Spec 0064).
+     *
+     * `relativePath` / `result` / `parentId` from the caller are ignored for the
+     * node row (kept on the signature so ViewTree call sites stay unchanged);
+     * ViewTree *edges* still use the importer via {@link addViewTreeEdge}.
+     */
+    ensureMethodNode(method, _relativePath, _result, _parentId) {
+        return this.resolveMethodNodeId(method);
     }
     indexMethod(relativePath, language, result, method, parentId, forcedKind, forcedDisplayName) {
         const displayName = forcedDisplayName ?? resolveMethodDisplayName(method);
@@ -4057,6 +4047,52 @@ class ArkTSAdapter {
         result.edges.push(arkEdge(parentId, methodNode.id, 'contains'));
         this.indexDecorators(result, methodNode.id, method, relativePath, language, line);
         this.indexNativeNapiCalls(method, methodNode.id, relativePath, language, result);
+        // Spec 0066: return/param types as resolvable `returns` / `type_of` refs.
+        this.emitMethodTypeEdges(method, methodNode.id, relativePath, language, line, returnType, methodNode.docstring, result);
+    }
+    /**
+     * Spec 0066 — push unresolved `returns` / `type_of` from signature types,
+     * falling back to JSDoc `@returns` / `@param` when the signature lacks them.
+     */
+    emitMethodTypeEdges(method, fromNodeId, relativePath, language, line, returnType, docstring, result) {
+        const push = (referenceName, referenceKind) => {
+            result.unresolvedReferences.push({
+                fromNodeId,
+                referenceName,
+                referenceKind,
+                line,
+                column: 0,
+                filePath: relativePath,
+                language,
+            });
+        };
+        if (returnType) {
+            push(returnType, 'returns');
+        }
+        else {
+            const fromDoc = (0, jsdoc_type_tags_1.parseJsdocReturns)(docstring);
+            if (fromDoc)
+                push(fromDoc, 'returns');
+        }
+        let emittedParam = false;
+        try {
+            for (const p of method.getParameters()) {
+                const raw = p.getType()?.toString();
+                const base = normalizeArktsReturnType(raw);
+                if (base) {
+                    push(base, 'type_of');
+                    emittedParam = true;
+                }
+            }
+        }
+        catch {
+            // parameters unavailable
+        }
+        if (!emittedParam) {
+            for (const p of (0, jsdoc_type_tags_1.parseJsdocParams)(docstring)) {
+                push(p.typeName, 'type_of');
+            }
+        }
     }
     indexNativeNapiCalls(method, fromNodeId, relativePath, language, result) {
         const code = method.getCode();

package/dist/extraction/store-flush-guard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Store-phase flush / backpressure guards (Spec 0065).
+ *
+ * When `flushOrdered` records a store failure in `flushError` but returns a
+ * resolved promise, the feed backpressure `while` would otherwise spin on
+ * `await Promise.resolve()` forever (100% CPU hang). Call this at the top of
+ * that loop (and anywhere else that waits on flush progress).
+ */
+/** Throw if the ordered store flush already failed or the run was aborted. */
+export declare function throwIfStoreFlushFailed(aborted: boolean, flushError: unknown): void;
+//# sourceMappingURL=store-flush-guard.d.ts.map

package/dist/extraction/store-flush-guard.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Store-phase flush / backpressure guards (Spec 0065).
+ *
+ * When `flushOrdered` records a store failure in `flushError` but returns a
+ * resolved promise, the feed backpressure `while` would otherwise spin on
+ * `await Promise.resolve()` forever (100% CPU hang). Call this at the top of
+ * that loop (and anywhere else that waits on flush progress).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwIfStoreFlushFailed = throwIfStoreFlushFailed;
+/** Throw if the ordered store flush already failed or the run was aborted. */
+function throwIfStoreFlushFailed(aborted, flushError) {
+    if (flushError)
+        throw flushError;
+    if (aborted)
+        throw new Error('Aborted');
+}
+//# sourceMappingURL=store-flush-guard.js.map

package/dist/extraction/store-worker.d.ts

@@ -6,8 +6,9 @@
  * connection: the orchestrator posts one message per file (in file order) and
  * the worker applies them in arrival order, which preserves the #1015
  * insertion-order determinism exactly as if the main thread had run the same
- * calls. The main thread performs NO database access while the writer is
- * active (fresh-DB path only), so there is no cross-connection contention.
+ * calls. Spec 0065: the main connection is closed for the worker's lifetime
+ * (`exclusiveHandoff`) — an idle open handle on MEMORY/non-WAL backends was
+ * enough to surface SQLITE_BUSY during ArkTS→store handoff.
  *
  * Protocol (main → worker):
  *   {type:'open', dbPath, fastInit}  → open connection, reply {type:'ready'}

package/dist/extraction/store-worker.js

@@ -7,8 +7,9 @@
  * connection: the orchestrator posts one message per file (in file order) and
  * the worker applies them in arrival order, which preserves the #1015
  * insertion-order determinism exactly as if the main thread had run the same
- * calls. The main thread performs NO database access while the writer is
- * active (fresh-DB path only), so there is no cross-connection contention.
+ * calls. Spec 0065: the main connection is closed for the worker's lifetime
+ * (`exclusiveHandoff`) — an idle open handle on MEMORY/non-WAL backends was
+ * enough to surface SQLITE_BUSY during ArkTS→store handoff.
  *
  * Protocol (main → worker):
  *   {type:'open', dbPath, fastInit}  → open connection, reply {type:'ready'}

package/dist/extraction/tree-sitter.d.ts

@@ -595,9 +595,15 @@ export declare class TreeSitterExtractor {
     private readonly BUILTIN_TYPES;
     /**
      * Extract type references from type annotations on a function/method/field node.
-     * Creates 'references' edges for parameter types, return types, and field types.
+     * Spec 0066: parameter / field types → `type_of`; return types → `returns`.
+     * Dart / Scala mixed signature walks stay `references` (out of this Spec).
      */
     private extractTypeAnnotations;
+    /**
+     * Spec 0066: when the AST omitted return/param types, emit unresolved
+     * `returns` / `type_of` refs from JSDoc `@returns` / `@param {Type}`.
+     */
+    private emitJsdocTypeFallbacks;
     /**
      * Extract C# type references from a node that owns a type position —
      * a method/constructor declaration, a property declaration, or a
@@ -647,6 +653,7 @@ export declare class TreeSitterExtractor {
     /**
      * Recursively walk a subtree and extract all type_identifier references.
      * Handles unions, intersections, generics, arrays, etc.
+     * Spec 0066: callers pass `returns` / `type_of` for signature positions.
      */
     private extractTypeRefsFromSubtree;
     /**

package/dist/extraction/tree-sitter.js

@@ -47,6 +47,7 @@ const function_ref_1 = require("./function-ref");
 const generated_detection_1 = require("./generated-detection");
 const languages_1 = require("./languages");
 const c_cpp_1 = require("./languages/c-cpp");
+const jsdoc_type_tags_1 = require("./jsdoc-type-tags");
 const liquid_extractor_1 = require("./liquid-extractor");
 const razor_extractor_1 = require("./razor-extractor");
 const svelte_extractor_1 = require("./svelte-extractor");
@@ -1511,6 +1512,8 @@ class TreeSitterExtractor {
             return;
         // Extract type annotations (parameter types and return type)
         this.extractTypeAnnotations(node, funcNode.id);
+        // Spec 0066: JSDoc @returns/@param when the signature omitted types.
+        this.emitJsdocTypeFallbacks(funcNode.id, docstring);
         // Extract decorators applied to the function (rare in JS/TS but
         // present in Python `@decorator def f():` and Java/Kotlin
         // annotations on free functions).
@@ -1712,6 +1715,8 @@ class TreeSitterExtractor {
         }
         // Extract type annotations (parameter types and return type)
         this.extractTypeAnnotations(node, methodNode.id);
+        // Spec 0066: JSDoc @returns/@param when the signature omitted types.
+        this.emitJsdocTypeFallbacks(methodNode.id, docstring);
         // Extract decorators (`@Get('/list') list() {}`).
         this.extractDecoratorsFor(node, methodNode.id);
         // Push to stack and visit body
@@ -5636,7 +5641,8 @@ class TreeSitterExtractor {
     ]);
     /**
      * Extract type references from type annotations on a function/method/field node.
-     * Creates 'references' edges for parameter types, return types, and field types.
+     * Spec 0066: parameter / field types → `type_of`; return types → `returns`.
+     * Dart / Scala mixed signature walks stay `references` (out of this Spec).
      */
     extractTypeAnnotations(node, nodeId) {
         if (!this.extractor)
@@ -5668,6 +5674,7 @@ class TreeSitterExtractor {
         // `type_identifier` child, not a `type` field — so getChildByField below
         // finds neither. Walk the inner signature: param names / the method name are
         // `identifier` (not `type_identifier`), so only types surface.
+        // Spec 0066: leave as `references` (mixed return+param walk).
         if (this.language === 'dart') {
             let sig = node;
             if (node.type === 'method_signature') {
@@ -5677,7 +5684,7 @@ class TreeSitterExtractor {
                     c.type === 'constructor_signature' ||
                     c.type === 'factory_constructor_signature') ?? node;
             }
-            this.extractTypeRefsFromSubtree(sig, nodeId);
+            this.extractTypeRefsFromSubtree(sig, nodeId, 'references');
             return;
         }
         // Extract parameter type annotations. Scala curries — `def f(a)(implicit
@@ -5687,19 +5694,19 @@ class TreeSitterExtractor {
         if (this.language === 'scala') {
             for (const pc of node.namedChildren) {
                 if (pc.type === 'parameters')
-                    this.extractTypeRefsFromSubtree(pc, nodeId);
+                    this.extractTypeRefsFromSubtree(pc, nodeId, 'type_of');
             }
         }
         else {
             const params = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.paramsField || 'parameters');
             if (params) {
-                this.extractTypeRefsFromSubtree(params, nodeId);
+                this.extractTypeRefsFromSubtree(params, nodeId, 'type_of');
             }
         }
         // Extract return type annotation
         const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.returnField || 'return_type');
         if (returnType) {
-            this.extractTypeRefsFromSubtree(returnType, nodeId);
+            this.extractTypeRefsFromSubtree(returnType, nodeId, 'returns');
         }
         // Scala context bounds / type-parameter bounds: `def f[A: Monoid]`,
         // `[F[_]: Monad]`, `[A <: Foo]` carry the bound type inside `type_parameters`.
@@ -5711,13 +5718,46 @@ class TreeSitterExtractor {
         if (this.language === 'scala') {
             const typeParams = node.namedChildren.find((c) => c.type === 'type_parameters');
             if (typeParams) {
-                this.extractTypeRefsFromSubtree(typeParams, nodeId);
+                this.extractTypeRefsFromSubtree(typeParams, nodeId, 'type_of');
             }
         }
         // Extract direct type annotation (for class fields like `model: ITextModel`)
         const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
         if (typeAnnotation) {
-            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
+            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId, 'type_of');
+        }
+    }
+    /**
+     * Spec 0066: when the AST omitted return/param types, emit unresolved
+     * `returns` / `type_of` refs from JSDoc `@returns` / `@param {Type}`.
+     */
+    emitJsdocTypeFallbacks(fromNodeId, docstring) {
+        if (!docstring)
+            return;
+        const hasReturns = this.unresolvedReferences.some((r) => r.fromNodeId === fromNodeId && r.referenceKind === 'returns');
+        if (!hasReturns) {
+            const ret = (0, jsdoc_type_tags_1.parseJsdocReturns)(docstring);
+            if (ret) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: ret,
+                    referenceKind: 'returns',
+                    line: 1,
+                    column: 0,
+                });
+            }
+        }
+        const hasTypeOf = this.unresolvedReferences.some((r) => r.fromNodeId === fromNodeId && r.referenceKind === 'type_of');
+        if (!hasTypeOf) {
+            for (const p of (0, jsdoc_type_tags_1.parseJsdocParams)(docstring)) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: p.typeName,
+                    referenceKind: 'type_of',
+                    line: 1,
+                    column: 0,
+                });
+            }
         }
     }
     /**
@@ -5923,21 +5963,22 @@ class TreeSitterExtractor {
         // Find type_annotation child (covers TS `: Type`, Rust `: Type`, etc.)
         const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
         if (typeAnnotation) {
-            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
+            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId, 'type_of');
         }
     }
     /**
      * Recursively walk a subtree and extract all type_identifier references.
      * Handles unions, intersections, generics, arrays, etc.
+     * Spec 0066: callers pass `returns` / `type_of` for signature positions.
      */
-    extractTypeRefsFromSubtree(node, fromNodeId) {
+    extractTypeRefsFromSubtree(node, fromNodeId, referenceKind = 'references') {
         if (node.type === 'type_identifier') {
             const typeName = (0, tree_sitter_helpers_1.getNodeText)(node, this.source);
             if (typeName && !this.BUILTIN_TYPES.has(typeName)) {
                 this.unresolvedReferences.push({
                     fromNodeId,
                     referenceName: typeName,
-                    referenceKind: 'references',
+                    referenceKind,
                     line: node.startPosition.row + 1,
                     column: node.startPosition.column,
                 });
@@ -5948,7 +5989,7 @@ class TreeSitterExtractor {
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child) {
-                this.extractTypeRefsFromSubtree(child, fromNodeId);
+                this.extractTypeRefsFromSubtree(child, fromNodeId, referenceKind);
             }
         }
     }

package/dist/index.js

@@ -490,7 +490,37 @@ class HomeGraph {
                     this.db.beginBulkParseLoad();
                 let result;
                 try {
-                    result = await this.orchestrator.indexAll(options.onProgress, options.signal, options.verbose, walValve ? () => walValve.backpressure() : undefined, freshDb ? { dbPath: this.db.getPath(), fastInit } : null);
+                    result = await this.orchestrator.indexAll(options.onProgress, options.signal, options.verbose, walValve ? () => walValve.backpressure() : undefined, freshDb
+                        ? {
+                            dbPath: this.db.getPath(),
+                            fastInit,
+                            // Spec 0065: exclusive store-worker handoff (close main → worker → reopen).
+                            exclusiveHandoff: {
+                                release: () => {
+                                    this.db.closeForExclusiveWriter();
+                                },
+                                reclaim: () => {
+                                    this.db.reopenAfterExclusiveWriter({ fastInit });
+                                    this.queries.rebind(this.db.getDb());
+                                    (0, context_1.bindExtractionContext)(this.projectRoot, this.queries);
+                                    // ATTACH is per-connection. ohosApiDbPath survives rebind and
+                                    // would make attachOhosApiDb early-return while the schema
+                                    // is gone → "no such table: ohos_api.nodes". Clear then reattach.
+                                    const priorOhos = this.queries.getOhosApiDbPath();
+                                    this.queries.attachOhosApiDb(null);
+                                    if (priorOhos) {
+                                        this.queries.attachOhosApiDb(priorOhos);
+                                    }
+                                    else if ((0, graph_sources_1.graphSourceFlags)(this.graphSources).sdk) {
+                                        (0, arkts_1.restoreOhosApiDbAttach)(this.queries);
+                                        if (!this.queries.getOhosApiDbPath()) {
+                                            (0, arkts_1.attachExistingOhosApiDbForProject)(this.projectRoot, this.queries);
+                                        }
+                                    }
+                                },
+                            },
+                        }
+                        : null);
                 }
                 finally {
                     if (freshDb) {

package/dist/resolution/callback-synthesizer.d.ts

@@ -25,6 +25,18 @@ import type { Edge } from '../types';
 import type { QueryBuilder } from '../db/queries';
 import type { ResolutionContext } from './types';
 import { type MaybeYield } from './cooperative-yield';
+/**
+ * Spec 0045 A — ArkUI parent build/@Builder → child @Component/@Builder.
+ * Analog of react jsx-child: only static PascalCase call names that resolve to
+ * a unique in-repo component/builder; ambiguous names are dropped.
+ *
+ * Scan the enclosing @Component/@Builder struct (or Builder function) body —
+ * not only the `build()` method span — because ArkUI trailing lambdas
+ * (`Column() { Child() }`) are often attributed with tight method ranges that
+ * omit nested call sites.
+ */
+/** @internal exported for PERF kind-scan regression tests (resolveChild name-miss path). */
+export declare function arkuiChildComponentEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]>;
 /** `has(...)` shape passed to pass gates — true when the project contains any of the languages. */
 type HasLang = (...ls: string[]) => boolean;
 /**

package/dist/resolution/callback-synthesizer.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SYNTH_PROGRESS_STEPS = exports.SYNTH_PASSES = void 0;
+exports.arkuiChildComponentEdges = arkuiChildComponentEdges;
 exports.synthesizeCallbackEdges = synthesizeCallbackEdges;
 const generated_detection_1 = require("../extraction/generated-detection");
 const strip_comments_1 = require("./strip-comments");
@@ -1018,6 +1019,7 @@ function isArkuiBuildParent(n) {
  * (`Column() { Child() }`) are often attributed with tight method ranges that
  * omit nested call sites.
  */
+/** @internal exported for PERF kind-scan regression tests (resolveChild name-miss path). */
 async function arkuiChildComponentEdges(ctx, onYield) {
     const edges = [];
     const seen = new Set();
@@ -1033,15 +1035,10 @@ async function arkuiChildComponentEdges(ctx, onYield) {
         return '';
     };
     const resolveChild = (name, fromFile, parentId) => {
+        // Name index only — miss returns null. Framework PascalCase calls
+        // (Column/Button/Text/…) dominate misses and must not full-scan kinds
+        // (Spec 0063). Same drop policy as ambiguous multi-match below.
         let candidates = ctx.getNodesByName(name).filter(isArkuiChildTarget);
-        if (candidates.length === 0) {
-            candidates = [
-                ...ctx.getNodesByKind('struct'),
-                ...ctx.getNodesByKind('component'),
-                ...ctx.getNodesByKind('function'),
-                ...ctx.getNodesByKind('method'),
-            ].filter((n) => n.name === name && isArkuiChildTarget(n));
-        }
         candidates = candidates.filter((n) => n.id !== parentId);
         // Dedupe by id — name index can surface the same row twice across caches.
         candidates = [...new Map(candidates.map((n) => [n.id, n])).values()];

package/dist/resolution/name-matcher.d.ts

@@ -30,6 +30,11 @@ export declare function isKnownLanguageFamily(lang: string): boolean;
  * returns `false` here and is left alone.
  */
 export declare function crossesKnownFamily(a: string, b: string): boolean;
+/**
+ * Spec 0066: resolve a return/param type name to a unique type node.
+ * Ambiguous same-named types → no edge (wrong type hub is worse than none).
+ */
+export declare function matchTypeEdge(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
 /**
  * Resolve a function-as-value reference (#756) — a function name used as a
  * callback/function-pointer value (`register(handler)`, `o->cb = handler`,