carrick 0.3.102 → 0.3.104

package/sidecar/dist/src/project-loader.js

@@ -12,8 +12,9 @@
 import { Project } from 'ts-morph';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
-import { DenoProject, findDenoConfig, serviceConfigPath } from './capture/index.js';
+import { DenoProject, findDenoConfig, findServiceTsconfig, serviceConfigPath } from './capture/index.js';
 import { moduleFormatResolutionHost } from './module-format.js';
+import { ExternalImports, registerExternalImports } from './origin.js';
 /**
  * Source-file patterns used when the repo declares no tsconfig, relative to
  * the repo root. `node_modules` is excluded explicitly: a glob that matches
@@ -124,6 +125,7 @@ export class ProjectLoader {
     ownerProjects = new Map();
     repoRoot;
     tsconfigPath;
+    scanRoot;
     tsconfigSnapshot;
     pinnedDependencies;
     initialized = false;
@@ -140,6 +142,7 @@ export class ProjectLoader {
                 ? options.tsconfigPath
                 : path.resolve(this.repoRoot, options.tsconfigPath);
         }
+        this.scanRoot = options.scanRoot;
         // Store snapshot if provided
         this.tsconfigSnapshot = options.tsconfigSnapshot;
         this.pinnedDependencies = options.pinnedDependencies;
@@ -190,14 +193,18 @@ export class ProjectLoader {
                     this.buildProject = () => {
                         const deno = new DenoProject(denoConfig, this.repoRoot);
                         this.denoProject = deno;
+                        // The graph's external-library verdicts, kept past the program
+                        // rebuilds that drop them (carrick#1731).
+                        const imports = new ExternalImports();
                         const project = new Project({
                             compilerOptions: deno.parsed.options,
                             skipAddingFilesFromTsConfig: true,
-                            resolutionHost: (host, getOptions) => ({
+                            resolutionHost: imports.recording((host, getOptions) => ({
                                 resolveModuleNames: (names, from) => names.map(name => deno.resolve(name, from, getOptions(), host)),
                                 resolveTypeReferenceDirectives: (names, from) => names.map(name => deno.resolveTypeReference(typeof name === 'string' ? name : name.fileName, from, getOptions(), host)),
-                            }),
+                            })),
                         });
+                        registerExternalImports(project, imports);
                         for (const file of deno.parsed.fileNames)
                             project.addSourceFileAtPath(file);
                         for (const diagnostic of deno.diagnostics)
@@ -313,12 +320,17 @@ export class ProjectLoader {
     }
     /** A ts-morph project built from one tsconfig and the files it lists. */
     projectFromConfig(configPath) {
-        return new Project({
+        const imports = new ExternalImports();
+        const project = new Project({
             tsConfigFilePath: configPath,
             skipAddingFilesFromTsConfig: false,
-            // Each import resolves in its file's own module format (carrick#1619).
-            resolutionHost: moduleFormatResolutionHost,
+            // Each import resolves in its file's own module format (carrick#1619),
+            // and every external-library answer is kept past the program rebuilds
+            // that drop it (carrick#1731).
+            resolutionHost: imports.recording(moduleFormatResolutionHost),
         });
+        registerExternalImports(project, imports);
+        return project;
     }
     /**
      * Which project types `file` (carrick#1604): the key of its owning
@@ -412,30 +424,19 @@ export class ProjectLoader {
         return this.pinnedDependencies;
     }
     /**
-     * Find the tsconfig.json file to use
+     * The tsconfig to build from: the named one when it exists, else the one
+     * `findServiceTsconfig` finds for the service, which capture also reads.
      *
-     * @returns Absolute path to tsconfig.json, or undefined if not found
+     * @returns Absolute path to the tsconfig, or undefined if not found
      */
     findTsConfig() {
-        // If a specific path was provided, try to use it
         if (this.tsconfigPath) {
             if (fs.existsSync(this.tsconfigPath)) {
                 return this.tsconfigPath;
             }
             this.log(`Specified tsconfig not found: ${this.tsconfigPath}`);
         }
-        // Try common tsconfig locations
-        const candidates = [
-            path.join(this.repoRoot, 'tsconfig.json'),
-            path.join(this.repoRoot, 'tsconfig.build.json'),
-            path.join(this.repoRoot, 'tsconfig.app.json'),
-        ];
-        for (const candidate of candidates) {
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        return undefined;
+        return findServiceTsconfig(this.repoRoot, this.scanRoot);
     }
     /**
      * Add source files from common project locations when no tsconfig is found.

package/sidecar/dist/src/type-inferrer.d.ts

@@ -182,6 +182,25 @@ export declare class TypeInferrer {
      */
     private resolveParamTarget;
     private inferResponseBody;
+    /**
+     * True when a located call's own result is the route's payload, so the
+     * transitional drill into its first argument must not run (carrick#1732).
+     *
+     * `res.json(users)` reached that drill because nothing above it recognised
+     * the send: its result reads `void`, `any` or `unknown`, and the payload is
+     * the argument. `toPublicView(row)` is the opposite case: a mapper building
+     * the object the route sends. Its first argument is the row it was built
+     * FROM, which carries columns the route never sends.
+     *
+     * The call's result decides, not where its callee is declared. It is the
+     * payload when it reads as one by the rule a response helper's argument is
+     * read with (`nodeCarriesPayloadContract`: object-shaped, not machinery,
+     * not `void`/`any`/`unknown`) and the object is not a library's own: a
+     * codec's writer from `encode(message)` or a reply builder from a send is
+     * the library describing itself, and keeps the drill. A library call that
+     * returns the repo's own type (`toInstance(View, plain)`) is the payload.
+     */
+    private callResultIsPayload;
     /**
      * The wire representation a request's printed type takes. A route response
      * is serialised as JSON by every sender this layer reads a payload out of,
@@ -238,6 +257,30 @@ export declare class TypeInferrer {
      */
     private receivingCallOf;
     private inferCallResult;
+    /**
+     * What the source states the body read at `terminal` to be, when the type
+     * `extractExplicitTypeFromAncestor` printed for it is stated AT the read
+     * (carrick#1749): the read is the operand of that cast, or the initializer
+     * of that annotated declaration, through wrappers that leave a value as it
+     * is (parentheses, `await`, `!`, another cast). An annotation further out —
+     * the declared type of the function the read sits in — describes something
+     * else, and is not reported.
+     */
+    private statedBodyAtRead;
+    /**
+     * A stated type with `any` or `unknown` written anywhere in it (`unknown`,
+     * `Record<string, unknown>`, `{ items: any[] }`) leaves a position open: it
+     * is a placeholder the source narrows later (`const data: unknown = await
+     * res.json()`, then `data as Entry[]`), not its statement of the body.
+     */
+    private leavesAPositionOpen;
+    /**
+     * The named root of a stated body type: `Promise<...>` and `PromiseLike`
+     * (the language's await protocol), array levels, parentheses, `readonly`
+     * and `| null`/`| undefined` are peeled, and what is left is either a type
+     * reference, whose name is the root, or anything else, which has none.
+     */
+    private statedRoot;
     private inferVariable;
     private inferExpression;
     private inferRequestBody;
@@ -361,6 +404,33 @@ export declare class TypeInferrer {
      * HTTP response is read exactly this way whatever produced the response, so
      * the shape is structural, not a framework's name.
      */
+    /**
+     * The body read inside a chain that starts at `callExpr` (carrick#1749):
+     * `request(url).check(ok).mapOk(response => { const data = response as
+     * SearchResponse; ... })`.
+     *
+     * The chain is the run of member calls whose receiver is the call, then
+     * that call's result, and so on. A callback passed to one of them whose
+     * first parameter the compiler types `unknown` is handed a value nothing
+     * has typed yet, which is what a parsed body is; where the source casts
+     * that parameter, the cast is what the caller says the body is. The value
+     * the chain ends in is what the caller computed from it, and publishing
+     * that as the body is the false mismatch this rule exists for.
+     *
+     * Exactly one such cast across the whole chain answers. None, or more than
+     * one (a callback on the failure side can be handed an `unknown` too), and
+     * the walk carries on as before. A parameter typed `any` is not read: an
+     * unresolved library types every callback that way, success and failure
+     * alike, so it says nothing about which one is the body.
+     */
+    private bodyReadInCallbackChain;
+    /**
+     * The casts of a callback's first parameter, when the compiler types that
+     * parameter `unknown`: `response as T` and `<T>response`, the operand being
+     * the parameter itself. A cast that leaves a position open states nothing
+     * about the body and is skipped.
+     */
+    private castsOfUnreadParameter;
     private bodyReadOnReceiver;
     private collectDefUseNodes;
     private expressionUsesNames;
@@ -539,6 +609,8 @@ export declare class TypeInferrer {
      */
     private unwrapJsonStringifyArg;
     private extractExplicitTypeFromAncestor;
+    /** The annotation `extractExplicitTypeFromAncestor` prints, as a node. */
+    private explicitTypeNodeFromAncestor;
     /**
      * Render an explicit annotation (`as T`, `<T>`, or a typed binding) as
      * fully-structural text.

package/sidecar/dist/src/type-inferrer.js

@@ -20,7 +20,7 @@
 import * as path from 'node:path';
 import { Node, SyntaxKind, ts, } from 'ts-morph';
 import { validateInferRequestItem } from './validators.js';
-import { isExternalOrigin } from './origin.js';
+import { externalImportsOf, isExternalOrigin } from './origin.js';
 import { addedDiagnostics, applyInsertions, fileDiagnostics, literalInsertions, mapBack, mapForward, normalise, pathOf, } from './unwidened.js';
 import { expandTypeStructural, } from './type-structural-expander.js';
 /**
@@ -277,6 +277,7 @@ export class TypeInferrer {
         return {
             program: this.project.getProgram().compilerObject,
             repoRoot: this.repoRoot,
+            imports: externalImportsOf(this.project),
         };
     }
     /**
@@ -940,7 +941,9 @@ export class TypeInferrer {
                 this.log(`Span resolves to a callback-registration call at ${request.file_path}:${request.line_number}; no payload to infer`);
                 return null;
             }
-            if (args.length > 0) {
+            // A call whose result is a value the repo shapes is not a send: it is
+            // the payload (carrick#1732), and drilling would publish its input.
+            if (args.length > 0 && !this.callResultIsPayload(node)) {
                 payloadNode = args[0];
             }
         }
@@ -973,6 +976,31 @@ export class TypeInferrer {
         const anchor = this.unwrapArrayLevels(this.unwrapPromiseType(payloadType));
         return this.createInferredType(request, typeString, false, this.getNodeLocation(payloadNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, this.primaryTypeSymbol(anchor.element), anchor.depth);
     }
+    /**
+     * True when a located call's own result is the route's payload, so the
+     * transitional drill into its first argument must not run (carrick#1732).
+     *
+     * `res.json(users)` reached that drill because nothing above it recognised
+     * the send: its result reads `void`, `any` or `unknown`, and the payload is
+     * the argument. `toPublicView(row)` is the opposite case: a mapper building
+     * the object the route sends. Its first argument is the row it was built
+     * FROM, which carries columns the route never sends.
+     *
+     * The call's result decides, not where its callee is declared. It is the
+     * payload when it reads as one by the rule a response helper's argument is
+     * read with (`nodeCarriesPayloadContract`: object-shaped, not machinery,
+     * not `void`/`any`/`unknown`) and the object is not a library's own: a
+     * codec's writer from `encode(message)` or a reply builder from a send is
+     * the library describing itself, and keeps the drill. A library call that
+     * returns the repo's own type (`toInstance(View, plain)`) is the payload.
+     */
+    callResultIsPayload(call) {
+        const { element } = this.unwrapArrayLevels(this.unwrapPromiseType(call.getType()));
+        if (this.symbolIsLibOrExternalOrigin(element.getSymbol() ?? element.getAliasSymbol())) {
+            return false;
+        }
+        return this.nodeCarriesPayloadContract(call, false);
+    }
     /**
      * The wire representation a request's printed type takes. A route response
      * is serialised as JSON by every sender this layer reads a payload out of,
@@ -1309,7 +1337,132 @@ export class TypeInferrer {
                 }
             }
         }
-        return this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(terminalNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, anchor ? this.primaryTypeSymbol(anchor.element) : undefined, anchor?.depth);
+        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(terminalNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, anchor ? this.primaryTypeSymbol(anchor.element) : undefined, anchor?.depth);
+        // carrick#1749: say when the text is the source's own statement of the
+        // body, and what that statement is rooted at, so the scanner can tell a
+        // model symbol that names the body from one that names a part of it.
+        const statedBody = explicitType ? this.statedBodyAtRead(terminalNode) : undefined;
+        if (statedBody) {
+            inferred.stated_body = statedBody;
+        }
+        return inferred;
+    }
+    /**
+     * What the source states the body read at `terminal` to be, when the type
+     * `extractExplicitTypeFromAncestor` printed for it is stated AT the read
+     * (carrick#1749): the read is the operand of that cast, or the initializer
+     * of that annotated declaration, through wrappers that leave a value as it
+     * is (parentheses, `await`, `!`, another cast). An annotation further out —
+     * the declared type of the function the read sits in — describes something
+     * else, and is not reported.
+     */
+    statedBodyAtRead(terminal) {
+        const typeNode = this.explicitTypeNodeFromAncestor(terminal);
+        const owner = typeNode?.getParent();
+        if (!typeNode || !owner || this.leavesAPositionOpen(typeNode))
+            return undefined;
+        let current = terminal;
+        for (;;) {
+            if (current === owner)
+                break;
+            const parent = current.getParent();
+            if (!parent)
+                return undefined;
+            if (parent === owner &&
+                Node.isVariableDeclaration(parent) &&
+                parent.getInitializer() === current) {
+                break;
+            }
+            if (!Node.isParenthesizedExpression(parent) &&
+                !Node.isAwaitExpression(parent) &&
+                !Node.isNonNullExpression(parent) &&
+                !Node.isAsExpression(parent) &&
+                !Node.isTypeAssertion(parent) &&
+                !Node.isSatisfiesExpression(parent)) {
+                return undefined;
+            }
+            current = parent;
+        }
+        return this.statedRoot(typeNode);
+    }
+    /**
+     * A stated type with `any` or `unknown` written anywhere in it (`unknown`,
+     * `Record<string, unknown>`, `{ items: any[] }`) leaves a position open: it
+     * is a placeholder the source narrows later (`const data: unknown = await
+     * res.json()`, then `data as Entry[]`), not its statement of the body.
+     */
+    leavesAPositionOpen(typeNode) {
+        const open = (node) => node.getKind() === SyntaxKind.AnyKeyword || node.getKind() === SyntaxKind.UnknownKeyword;
+        return open(typeNode) || typeNode.getDescendants().some(open);
+    }
+    /**
+     * The named root of a stated body type: `Promise<...>` and `PromiseLike`
+     * (the language's await protocol), array levels, parentheses, `readonly`
+     * and `| null`/`| undefined` are peeled, and what is left is either a type
+     * reference, whose name is the root, or anything else, which has none.
+     */
+    statedRoot(typeNode) {
+        let node = typeNode;
+        let depth = 0;
+        for (let step = 0; step < 16; step++) {
+            if (Node.isParenthesizedTypeNode(node)) {
+                node = node.getTypeNode();
+                continue;
+            }
+            if (Node.isArrayTypeNode(node)) {
+                node = node.getElementTypeNode();
+                depth++;
+                continue;
+            }
+            if (Node.isTypeOperatorTypeNode(node) &&
+                node.getOperator() === SyntaxKind.ReadonlyKeyword) {
+                node = node.getTypeNode();
+                continue;
+            }
+            if (Node.isUnionTypeNode(node)) {
+                const present = node
+                    .getTypeNodes()
+                    .filter((member) => !((Node.isLiteralTypeNode(member) &&
+                    member.getLiteral().getKind() === SyntaxKind.NullKeyword) ||
+                    member.getKind() === SyntaxKind.UndefinedKeyword ||
+                    member.getKind() === SyntaxKind.NullKeyword));
+                if (present.length === 1) {
+                    node = present[0];
+                    continue;
+                }
+                break;
+            }
+            if (Node.isTypeReference(node)) {
+                const name = node.getTypeName().getText();
+                const args = node.getTypeArguments();
+                if (args.length === 1 && (name === 'Promise' || name === 'PromiseLike')) {
+                    node = args[0];
+                    continue;
+                }
+                if (args.length === 1 && (name === 'Array' || name === 'ReadonlyArray')) {
+                    node = args[0];
+                    depth++;
+                    continue;
+                }
+            }
+            break;
+        }
+        const depthField = depth > 0 ? { array_depth: depth } : {};
+        if (!Node.isTypeReference(node)) {
+            return depthField;
+        }
+        const typeName = node.getTypeName();
+        const nameNode = Node.isQualifiedName(typeName) ? typeName.getRight() : typeName;
+        let symbol = nameNode.getSymbol();
+        if (symbol?.isAlias()) {
+            symbol = symbol.getAliasedSymbol() ?? symbol;
+        }
+        const source = symbol?.getDeclarations()[0]?.getSourceFile().getFilePath();
+        return {
+            root: nameNode.getText(),
+            ...(source ? { root_source: source } : {}),
+            ...depthField,
+        };
     }
     inferVariable(sourceFile, request, extractionConfig) {
         const node = this.resolveTargetNode(sourceFile, request);
@@ -1632,6 +1785,14 @@ export class TypeInferrer {
     // Call Result Resolution
     // ===========================================================================
     resolveCallResultTerminalNode(callExpr, func) {
+        // carrick#1749: the call starts a chain, and a callback in it is handed
+        // the body unread and casts it. That cast is the body read, and it comes
+        // before the return-statement answer below, which for a chain is the
+        // value the caller computed from the body, not the body.
+        const chainRead = this.bodyReadInCallbackChain(callExpr);
+        if (chainRead) {
+            return { terminal: chainRead, projectionOnly: false, projections: [] };
+        }
         const returnStmt = callExpr.getFirstAncestorByKind(SyntaxKind.ReturnStatement);
         if (returnStmt) {
             const returnExpr = returnStmt.getExpression();
@@ -2094,6 +2255,80 @@ export class TypeInferrer {
      * HTTP response is read exactly this way whatever produced the response, so
      * the shape is structural, not a framework's name.
      */
+    /**
+     * The body read inside a chain that starts at `callExpr` (carrick#1749):
+     * `request(url).check(ok).mapOk(response => { const data = response as
+     * SearchResponse; ... })`.
+     *
+     * The chain is the run of member calls whose receiver is the call, then
+     * that call's result, and so on. A callback passed to one of them whose
+     * first parameter the compiler types `unknown` is handed a value nothing
+     * has typed yet, which is what a parsed body is; where the source casts
+     * that parameter, the cast is what the caller says the body is. The value
+     * the chain ends in is what the caller computed from it, and publishing
+     * that as the body is the false mismatch this rule exists for.
+     *
+     * Exactly one such cast across the whole chain answers. None, or more than
+     * one (a callback on the failure side can be handed an `unknown` too), and
+     * the walk carries on as before. A parameter typed `any` is not read: an
+     * unresolved library types every callback that way, success and failure
+     * alike, so it says nothing about which one is the body.
+     */
+    bodyReadInCallbackChain(callExpr) {
+        const reads = [];
+        let receiver = callExpr;
+        for (let link = 0; link < 64; link++) {
+            const access = receiver.getParent();
+            if (!access ||
+                !Node.isPropertyAccessExpression(access) ||
+                access.getExpression() !== receiver) {
+                break;
+            }
+            const call = access.getParent();
+            if (!call || !Node.isCallExpression(call) || call.getExpression() !== access) {
+                break;
+            }
+            for (const arg of call.getArguments()) {
+                if (Node.isArrowFunction(arg) || Node.isFunctionExpression(arg)) {
+                    reads.push(...this.castsOfUnreadParameter(arg));
+                }
+            }
+            receiver = call;
+        }
+        return reads.length === 1 ? reads[0] : undefined;
+    }
+    /**
+     * The casts of a callback's first parameter, when the compiler types that
+     * parameter `unknown`: `response as T` and `<T>response`, the operand being
+     * the parameter itself. A cast that leaves a position open states nothing
+     * about the body and is skipped.
+     */
+    castsOfUnreadParameter(callback) {
+        const param = callback.getParameters()[0];
+        const name = param?.getNameNode();
+        if (!param || !name || !Node.isIdentifier(name) || !param.getType().isUnknown()) {
+            return [];
+        }
+        const symbol = name.getSymbol();
+        if (!symbol)
+            return [];
+        return callback.getDescendants().filter((node) => {
+            if (!Node.isAsExpression(node) && !Node.isTypeAssertion(node))
+                return false;
+            let operand = node.getExpression();
+            while (Node.isParenthesizedExpression(operand)) {
+                operand = operand.getExpression();
+            }
+            if (!Node.isIdentifier(operand) || operand.getSymbol() !== symbol)
+                return false;
+            const stated = node.getType();
+            const statedNode = node.getTypeNode();
+            return (!!statedNode &&
+                !stated.isAny() &&
+                !stated.isUnknown() &&
+                !this.leavesAPositionOpen(statedNode));
+        });
+    }
     bodyReadOnReceiver(identifier) {
         const access = identifier.getParent();
         if (!access ||
@@ -2610,7 +2845,7 @@ export class TypeInferrer {
         }
         const program = this.project.getProgram().compilerObject;
         for (const decl of symbol.getDeclarations()) {
-            if (isExternalOrigin(program, decl.getSourceFile().compilerNode, this.repoRoot)) {
+            if (isExternalOrigin(program, decl.getSourceFile().compilerNode, this.repoRoot, externalImportsOf(this.project))) {
                 return true;
             }
         }
@@ -2796,11 +3031,16 @@ export class TypeInferrer {
         return this.unwrapExpressionNode(args[0]);
     }
     extractExplicitTypeFromAncestor(node) {
+        const typeNode = this.explicitTypeNodeFromAncestor(node);
+        return typeNode ? this.expandAnnotationTypeNode(typeNode) : null;
+    }
+    /** The annotation `extractExplicitTypeFromAncestor` prints, as a node. */
+    explicitTypeNodeFromAncestor(node) {
         const varDecl = node.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
         if (varDecl) {
             const typeNode = varDecl.getTypeNode();
             if (typeNode) {
-                return this.expandAnnotationTypeNode(typeNode);
+                return typeNode;
             }
         }
         // Consider the node ITSELF as well as its ancestors: the `call_result`
@@ -2813,7 +3053,7 @@ export class TypeInferrer {
         if (asExpr) {
             const typeNode = asExpr.getTypeNode();
             if (typeNode) {
-                return this.expandAnnotationTypeNode(typeNode);
+                return typeNode;
             }
         }
         const typeAssertion = Node.isTypeAssertion(node)
@@ -2822,10 +3062,10 @@ export class TypeInferrer {
         if (typeAssertion) {
             const typeNode = typeAssertion.getTypeNode();
             if (typeNode) {
-                return this.expandAnnotationTypeNode(typeNode);
+                return typeNode;
             }
         }
-        return null;
+        return undefined;
     }
     /**
      * Render an explicit annotation (`as T`, `<T>`, or a typed binding) as

package/sidecar/dist/src/type-structural-expander.d.ts

@@ -29,6 +29,7 @@
  * structural form rather than a dangling name.
  */
 import { type Node, type Type, ts } from 'ts-morph';
+import { type ExternalImports } from './origin.js';
 /**
  * Bound on the structural-expansion recursion. Deep enough for every realistic
  * request/response shape; a backstop against pathological/recursive types the
@@ -83,11 +84,14 @@ export type WireFormat = 'declared' | 'json';
  * its own cache leaves no such segment in the path (carrick#1264). The program
  * carries the resolver's own verdict, so it is what `isExternalOrigin` is
  * asked — the same instrument the inference path uses, so the two layers
- * cannot disagree about which types to inline.
+ * cannot disagree about which types to inline. `imports` is that verdict kept
+ * past the program rebuilds that drop it (carrick#1731), for a project the
+ * loader built.
  */
 export interface ExpandOrigin {
     readonly program: ts.Program;
     readonly repoRoot: string;
+    readonly imports?: ExternalImports;
 }
 /** Everything `expandTypeStructural` takes besides the type and its origin. */
 export interface ExpandOptions {

package/sidecar/dist/src/type-structural-expander.js

@@ -366,7 +366,7 @@ function isLibraryType(type, origin) {
     const decls = symbol.getDeclarations();
     if (decls.length === 0)
         return false;
-    return decls.some((decl) => isExternalOrigin(origin.program, decl.getSourceFile().compilerNode, origin.repoRoot));
+    return decls.some((decl) => isExternalOrigin(origin.program, decl.getSourceFile().compilerNode, origin.repoRoot, origin.imports));
 }
 /**
  * Non-expanded text for a type. Passes `undefined` as the enclosing node so