@orangepro/orangepro-mcp 0.1.0

package/dist/local/analyze/behaviorContracts.js

@@ -0,0 +1,169 @@
+import { slugify } from "../util/ids.js";
+const HTTP_METHODS = new Set(["get", "post", "put", "delete", "patch", "options", "head", "all"]);
+// Known limits for this v1 metadata extractor:
+// - only literal route strings are captured;
+// - custom/composed decorators are not expanded;
+// - computed router methods/paths are ignored.
+// That is intentional while Endpoint nodes are informational only and excluded
+// from the coverage denominator.
+const NEST_METHOD_DECORATOR = /@(Get|Post|Put|Delete|Patch|Options|Head|All)\s*\(\s*(?:(["'`])([^"'`]*)\2)?\s*\)(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:public\s+|private\s+|protected\s+|async\s+)*([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g;
+const NEST_CONTROLLER_DECORATOR = /@Controller\s*\(\s*(?:(["'`])([^"'`]*)\1)?\s*\)\s*(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+const EXPRESS_ROUTER_CALL = /\b(?:router|app)\s*\.\s*(get|post|put|delete|patch|options|head|all)\s*\(\s*(["'`])([^"'`]*)\2\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?|\([^)]*\)\s*=>|async\s+\([^)]*\)\s*=>|function\s+[A-Za-z_$][A-Za-z0-9_$]*)/gi;
+const EXPRESS_ROUTE_CHAIN = /\b(?:router|app)\s*\.\s*route\s*\(\s*(["'`])([^"'`]*)\1\s*\)((?:\s*\.\s*(?:get|post|put|delete|patch|options|head|all)\s*\([^)]*\))+)/gi;
+const CHAINED_METHOD_CALL = /\.\s*(get|post|put|delete|patch|options|head|all)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?|\([^)]*\)\s*=>|async\s+\([^)]*\)\s*=>|function\s+[A-Za-z_$][A-Za-z0-9_$]*)/gi;
+const FASTIFY_CALL = /\bfastify\s*\.\s*(get|post|put|delete|patch|options|head|all)\s*\(\s*(["'`])([^"'`]*)\2\s*,\s*(?:\{[^)]*\}\s*,\s*)?([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?|\([^)]*\)\s*=>|async\s+\([^)]*\)\s*=>|function\s+[A-Za-z_$][A-Za-z0-9_$]*)/gi;
+const FILE_ROUTE_EXPORT = /\bexport\s+(?:(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD|ALL)\s*\(|const\s+(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD|ALL)\s*=)/g;
+export function extractBehaviorContracts(content, file) {
+    return dedupeContracts([
+        ...extractFileRouteContracts(content, file),
+        ...extractNestContracts(content, file),
+        ...extractRouterContracts(content, file, EXPRESS_ROUTER_CALL, "express"),
+        ...extractExpressRouteChains(content, file),
+        ...extractRouterContracts(content, file, FASTIFY_CALL, "fastify")
+    ]);
+}
+function extractFileRouteContracts(content, file) {
+    const path = fileRoutePath(file);
+    if (!path)
+        return [];
+    const contracts = [];
+    for (const match of content.matchAll(FILE_ROUTE_EXPORT)) {
+        const method = httpMethod(match[1] ?? match[2]);
+        contracts.push(makeContract({
+            file,
+            framework: "file_route",
+            method,
+            path,
+            handler: method
+        }));
+    }
+    return contracts;
+}
+function extractNestContracts(content, file) {
+    const controllers = [...content.matchAll(NEST_CONTROLLER_DECORATOR)].map((match) => ({
+        index: match.index ?? 0,
+        path: normalizeRoutePath(match[2] ?? ""),
+        name: match[3]
+    }));
+    if (controllers.length === 0)
+        return [];
+    const contracts = [];
+    for (const match of content.matchAll(NEST_METHOD_DECORATOR)) {
+        const index = match.index ?? 0;
+        const controller = nearestController(controllers, index);
+        const method = httpMethod(match[1]);
+        const routePath = joinRoutePaths(controller?.path ?? "", match[3] ?? "");
+        const handler = match[4];
+        contracts.push(makeContract({
+            file,
+            framework: "nestjs",
+            method,
+            path: routePath,
+            handler,
+            controller: controller?.name
+        }));
+    }
+    return contracts;
+}
+function nearestController(controllers, index) {
+    let current;
+    for (const controller of controllers) {
+        if (controller.index <= index)
+            current = controller;
+        else
+            break;
+    }
+    return current;
+}
+function extractRouterContracts(content, file, pattern, framework) {
+    const contracts = [];
+    for (const match of content.matchAll(pattern)) {
+        const handler = handlerName(match[4]);
+        contracts.push(makeContract({
+            file,
+            framework,
+            method: httpMethod(match[1]),
+            path: normalizeRoutePath(match[3] ?? ""),
+            handler
+        }));
+    }
+    return contracts;
+}
+function extractExpressRouteChains(content, file) {
+    const contracts = [];
+    for (const match of content.matchAll(EXPRESS_ROUTE_CHAIN)) {
+        const path = normalizeRoutePath(match[2] ?? "");
+        const chain = match[3] ?? "";
+        for (const methodMatch of chain.matchAll(CHAINED_METHOD_CALL)) {
+            contracts.push(makeContract({
+                file,
+                framework: "express",
+                method: httpMethod(methodMatch[1]),
+                path,
+                handler: handlerName(methodMatch[2])
+            }));
+        }
+    }
+    return contracts;
+}
+function makeContract(input) {
+    const title = `${input.method} ${input.path}`;
+    return {
+        id: `endpoint:${slugify(`${input.method}-${input.path}-${input.file}-${input.handler ?? ""}`)}`,
+        title,
+        kind: "http_endpoint",
+        framework: input.framework,
+        method: input.method,
+        path: input.path,
+        file: input.file,
+        handler: input.handler,
+        controller: input.controller,
+        source: "framework"
+    };
+}
+function httpMethod(value) {
+    const lower = value.toLowerCase();
+    return HTTP_METHODS.has(lower) ? lower.toUpperCase() : value.toUpperCase();
+}
+function normalizeRoutePath(value) {
+    const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
+    return trimmed ? `/${trimmed}` : "/";
+}
+function fileRoutePath(file) {
+    const normalized = file.replace(/\\/g, "/");
+    if (!/(^|\/)route\.[cm]?[jt]sx?$/.test(normalized))
+        return null;
+    const parts = normalized.split("/");
+    const apiIndex = parts.findIndex((part) => part === "api" || part === "apis");
+    if (apiIndex === -1)
+        return null;
+    const routeParts = parts.slice(apiIndex + 1, -1).map((part) => part
+        .replace(/^\[\[\.\.\.(.+)\]\]$/, ":$1*")
+        .replace(/^\[\.\.\.(.+)\]$/, ":$1*")
+        .replace(/^\[(.+)\]$/, ":$1"));
+    return normalizeRoutePath(routeParts.join("/"));
+}
+function joinRoutePaths(prefix, route) {
+    const parts = [prefix, route].map((part) => part.trim().replace(/^\/+|\/+$/g, "")).filter(Boolean);
+    return parts.length ? `/${parts.join("/")}` : "/";
+}
+function handlerName(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.startsWith("async") || trimmed.startsWith("(") || trimmed.startsWith("function"))
+        return undefined;
+    return trimmed;
+}
+function dedupeContracts(contracts) {
+    const seen = new Set();
+    const output = [];
+    for (const contract of contracts) {
+        const key = `${contract.framework}:${contract.method}:${contract.path}:${contract.file}:${contract.handler ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        output.push(contract);
+    }
+    return output;
+}

package/dist/local/analyze/boilerplate.js

@@ -0,0 +1,42 @@
+// Trivial-accessor / object-protocol exclusion from the BEHAVIOR denominator.
+//
+// Boilerplate accessors (Java getId/setName, toString/equals/hashCode, Python
+// __repr__/__str__) have no meaningful behavior to test. Counting them as
+// untested behaviors under-claims coverage on entity-heavy repos (Spring
+// Petclinic was ~33% getters/setters). They stay in the graph as CodeSymbol
+// nodes for completeness, but are marked denominator_eligible:false with a
+// reason, and surfaced as `excluded_boilerplate` so the report can disclose:
+// "107 symbols found, 35 boilerplate accessors excluded, 72 behaviors counted."
+//
+// Name-based and deliberately CONSERVATIVE — language-aware so it never strips
+// real logic. Body-aware refinement is a documented follow-up.
+export const BOILERPLATE_REASON = "Trivial accessor/object method — excluded from behavior denominator.";
+/**
+ * True iff `name` is a trivial accessor/object-protocol member for `language`.
+ * Only ever applied to function/method symbols (classes are never boilerplate).
+ *
+ *  - Java/Kotlin: getX/setX/isX ONLY when the body is AST-proven trivial
+ *    (trivialAccessor); toString/equals/hashCode by name (object plumbing).
+ *  - Python: low-signal dunders __repr__ and __str__ ONLY. snake_case accessors
+ *    like get_x / is_x are NOT excluded — those routinely hit DB/API/business logic.
+ *  - Go and everything else: nothing (e.g. `main` may be real runtime wiring).
+ */
+export function isBoilerplateSymbol(name, language, symbolKind, trivialAccessor) {
+    if (symbolKind !== "method" && symbolKind !== "function")
+        return false;
+    switch (language) {
+        case "java":
+        case "kotlin":
+            // A getX/setX/isX JavaBean accessor is excluded ONLY when the AST proved
+            // its body is trivial — so `getOwner()` that calls a repository, or any
+            // get-named method with real logic, stays a counted behavior.
+            if (/^(get|set|is)[A-Z]/.test(name))
+                return trivialAccessor === true;
+            // Object-protocol plumbing, excluded by name (not business behavior).
+            return name === "toString" || name === "equals" || name === "hashCode";
+        case "python":
+            return name === "__repr__" || name === "__str__";
+        default:
+            return false;
+    }
+}

package/dist/local/analyze/callGraph.js

@@ -0,0 +1,458 @@
+// AST-derived call extraction for TS/JS (Layer-1 call graph, PR 1).
+//
+// Pure parse step: walk a file's AST and record each call as a (caller, callee)
+// pair, where the caller is the nearest enclosing NAMED symbol scope. Resolution
+// of the callee to a concrete CodeSymbol — and the strict "both endpoints are
+// emitted symbols" rule — happens in the analyzer, which holds the cross-file
+// symbol index and the import-binding map.
+//
+// SCOPE-AWARE (no guessing): a free `bar()` or static `C.bar()` is dropped when
+// `bar`/`C` is shadowed by a parameter, local variable, local function/class,
+// catch binding, or destructuring binding in the enclosing lexical scope — the
+// call then targets the LOCAL, not an emitted symbol. We over-approximate the
+// shadow set (every binding anywhere in the enclosing function chain, excluding
+// nested function scopes), which can only UNDER-emit; hard CALLS cannot guess.
+//
+// Callee forms captured (everything else dropped):
+//   - `bar()`      → free identifier (same-file or import-resolved later)
+//   - `this.bar()` → a member of the caller's own class (never shadowed)
+//   - `C.bar()`    → a static member, qualifier is the class identifier
+//   - `this.dep.bar()` → an injected field whose type is explicit in the class
+import ts from "typescript";
+export const MEDUSA_INTERNAL_SERVICE_TYPE = "__medusa_internal_service__";
+const MAX_CALLS_PER_FILE = 2000;
+function isFunctionLike(n) {
+    return (ts.isFunctionDeclaration(n) ||
+        ts.isFunctionExpression(n) ||
+        ts.isArrowFunction(n) ||
+        ts.isMethodDeclaration(n) ||
+        ts.isConstructorDeclaration(n) ||
+        ts.isGetAccessorDeclaration(n) ||
+        ts.isSetAccessorDeclaration(n));
+}
+/** Collect identifier names introduced by a binding name (incl. destructuring). */
+function collectBindingName(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.add(name.text);
+    }
+    else {
+        for (const el of name.elements) {
+            if (ts.isBindingElement(el))
+                collectBindingName(el.name, out);
+        }
+    }
+}
+/**
+ * All names bound lexically inside `fn`: its own name, parameters (destructuring-
+ * aware), and every declaration at any block depth within the body — EXCLUDING
+ * nested function scopes (which own their bindings). Over-approximated on
+ * purpose (block/TDZ nuance ignored): a superset only ever drops more edges.
+ */
+function scopeBindings(fn) {
+    const out = new Set();
+    if ("name" in fn && fn.name && ts.isIdentifier(fn.name))
+        out.add(fn.name.text);
+    for (const p of fn.parameters)
+        collectBindingName(p.name, out);
+    if (fn.body)
+        collectDecls(fn.body, out);
+    return out;
+}
+/** Collect declared bindings under `node`, NOT descending into nested function scopes. */
+function collectDecls(node, out) {
+    ts.forEachChild(node, (child) => {
+        if (isFunctionLike(child) || ts.isClassExpression(child)) {
+            if ((ts.isFunctionDeclaration(child) || ts.isClassDeclaration(child)) && child.name)
+                out.add(child.name.text);
+            return; // separate scope — its locals do not shadow here
+        }
+        if (ts.isClassDeclaration(child)) {
+            if (child.name)
+                out.add(child.name.text);
+            return;
+        }
+        if (ts.isVariableDeclaration(child) || ts.isBindingElement(child))
+            collectBindingName(child.name, out);
+        if (ts.isCatchClause(child) && child.variableDeclaration)
+            collectBindingName(child.variableDeclaration.name, out);
+        collectDecls(child, out);
+    });
+}
+function simpleTypeName(type) {
+    if (!type || !ts.isTypeReferenceNode(type) || !ts.isIdentifier(type.typeName) || (type.typeArguments?.length ?? 0) > 0)
+        return null;
+    return type.typeName.text;
+}
+function medusaInternalServiceTypeName(type) {
+    if (!type || !ts.isTypeReferenceNode(type))
+        return null;
+    const name = type.typeName;
+    if (ts.isIdentifier(name) && name.text === "IMedusaInternalService")
+        return MEDUSA_INTERNAL_SERVICE_TYPE;
+    if (ts.isQualifiedName(name) && name.right.text === "IMedusaInternalService")
+        return MEDUSA_INTERNAL_SERVICE_TYPE;
+    return null;
+}
+function injectableTypeName(type) {
+    return simpleTypeName(type) ?? medusaInternalServiceTypeName(type);
+}
+function hasParameterPropertyModifier(param) {
+    return Boolean(param.modifiers?.some((m) => m.kind === ts.SyntaxKind.PublicKeyword ||
+        m.kind === ts.SyntaxKind.PrivateKeyword ||
+        m.kind === ts.SyntaxKind.ProtectedKeyword ||
+        m.kind === ts.SyntaxKind.ReadonlyKeyword));
+}
+function typeLiteralPropertyTypes(type) {
+    const out = new Map();
+    if (!type || !ts.isTypeLiteralNode(type))
+        return out;
+    for (const member of type.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const prop = member.name && ts.isIdentifier(member.name) ? member.name.text : null;
+        const propType = injectableTypeName(member.type);
+        if (prop && propType)
+            out.set(prop, propType);
+    }
+    return out;
+}
+function collectInterfacePropertyTypes(sf) {
+    const out = new Map();
+    ts.forEachChild(sf, (node) => {
+        if (ts.isTypeAliasDeclaration(node) && ts.isTypeLiteralNode(node.type)) {
+            out.set(node.name.text, typeLiteralPropertyTypes(node.type));
+            return;
+        }
+        if (!ts.isInterfaceDeclaration(node))
+            return;
+        const props = new Map();
+        for (const member of node.members) {
+            if (!ts.isPropertySignature(member) || !member.type || !ts.isIdentifier(member.name))
+                continue;
+            const propType = simpleTypeName(member.type);
+            if (propType)
+                props.set(member.name.text, propType);
+        }
+        out.set(node.name.text, props);
+    });
+    return out;
+}
+function objectBindingPropertyTypes(type, interfaces) {
+    if (type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && (type.typeArguments?.length ?? 0) === 0) {
+        return interfaces.get(type.typeName.text) ?? new Map();
+    }
+    return typeLiteralPropertyTypes(type);
+}
+function collectConstructorParamTypes(ctor, interfaces) {
+    const out = new Map();
+    for (const p of ctor.parameters) {
+        const directType = injectableTypeName(p.type);
+        if (ts.isIdentifier(p.name) && directType) {
+            out.set(p.name.text, directType);
+            continue;
+        }
+        if (!ts.isObjectBindingPattern(p.name))
+            continue;
+        const propTypes = objectBindingPropertyTypes(p.type, interfaces);
+        for (const el of p.name.elements) {
+            if (!ts.isBindingElement(el) || !ts.isIdentifier(el.name))
+                continue;
+            const propName = el.propertyName && ts.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+            const propType = propTypes.get(propName);
+            if (propType)
+                out.set(el.name.text, propType);
+        }
+    }
+    return out;
+}
+function collectInjectedFields(cls, interfaces) {
+    const out = new Map();
+    for (const member of cls.members) {
+        if (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+            const typeName = injectableTypeName(member.type);
+            if (typeName)
+                out.set(member.name.text, typeName);
+            continue;
+        }
+        if (!ts.isConstructorDeclaration(member))
+            continue;
+        const paramTypes = collectConstructorParamTypes(member, interfaces);
+        for (const p of member.parameters) {
+            if (!ts.isIdentifier(p.name) || !hasParameterPropertyModifier(p))
+                continue;
+            const typeName = injectableTypeName(p.type);
+            if (typeName)
+                out.set(p.name.text, typeName);
+        }
+        if (!member.body)
+            continue;
+        for (const stmt of member.body.statements) {
+            if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression))
+                continue;
+            const assignment = stmt.expression;
+            if (assignment.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+                continue;
+            const left = assignment.left;
+            const right = assignment.right;
+            if (!ts.isPropertyAccessExpression(left) || left.expression.kind !== ts.SyntaxKind.ThisKeyword || !ts.isIdentifier(left.name))
+                continue;
+            if (!ts.isIdentifier(right))
+                continue;
+            const typeName = paramTypes.get(right.text);
+            if (typeName)
+                out.set(left.name.text, typeName);
+        }
+    }
+    return out;
+}
+function collectInjectedFieldsByClass(sf) {
+    const out = new Map();
+    const interfaces = collectInterfacePropertyTypes(sf);
+    ts.forEachChild(sf, (node) => {
+        if (!ts.isClassDeclaration(node) || !node.name)
+            return;
+        const fields = collectInjectedFields(node, interfaces);
+        if (fields.size > 0)
+            out.set(node.name.text, fields);
+    });
+    return out;
+}
+export const MEDUSA_GENERATED_METHOD_BASES = ["retrieve", "list", "listAndCount", "delete", "softDelete", "restore", "create", "update"];
+function upperCaseFirst(value) {
+    return value ? `${value[0].toUpperCase()}${value.slice(1)}` : value;
+}
+function pluralizeModelKey(value) {
+    if (/[sxz]$/i.test(value) || /(?:ch|sh)$/i.test(value))
+        return `${value}es`;
+    if (/[^aeiou]y$/i.test(value))
+        return `${value.slice(0, -1)}ies`;
+    return `${value}s`;
+}
+export function medusaGeneratedMethodNames(modelKey) {
+    return MEDUSA_GENERATED_METHOD_BASES.map((base) => medusaGeneratedMethodName(modelKey, base));
+}
+export function medusaGeneratedMethodName(modelKey, base) {
+    const singular = upperCaseFirst(modelKey);
+    const plural = upperCaseFirst(pluralizeModelKey(modelKey));
+    return `${base}${base === "retrieve" ? singular : plural}`;
+}
+function modelKeysFromObjectLiteral(expr) {
+    const keys = [];
+    for (const prop of expr.properties) {
+        if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop))
+            return null;
+        if (ts.isPropertyAssignment(prop)) {
+            if (prop.name && ts.isIdentifier(prop.name))
+                keys.push(prop.name.text);
+            else if (prop.name && ts.isStringLiteral(prop.name) && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(prop.name.text))
+                keys.push(prop.name.text);
+            else
+                return null;
+        }
+        else {
+            keys.push(prop.name.text);
+        }
+    }
+    return keys;
+}
+function constObjectModelMaps(sf) {
+    const out = new Map();
+    ts.forEachChild(sf, (node) => {
+        if (!ts.isVariableStatement(node))
+            return;
+        for (const decl of node.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name) || !decl.initializer || !ts.isObjectLiteralExpression(decl.initializer))
+                continue;
+            const keys = modelKeysFromObjectLiteral(decl.initializer);
+            if (keys)
+                out.set(decl.name.text, keys);
+        }
+    });
+    return out;
+}
+function medusaServiceCall(expr) {
+    if (!ts.isCallExpression(expr))
+        return null;
+    const callee = expr.expression;
+    if (ts.isIdentifier(callee) && callee.text === "MedusaService")
+        return expr;
+    if (ts.isPropertyAccessExpression(callee) &&
+        callee.name.text === "MedusaService" &&
+        ts.isIdentifier(callee.expression) &&
+        callee.expression.text === "ModulesSdkUtils") {
+        return expr;
+    }
+    return null;
+}
+function modelKeysFromExpr(expr, constModels) {
+    if (ts.isObjectLiteralExpression(expr))
+        return modelKeysFromObjectLiteral(expr);
+    if (ts.isIdentifier(expr))
+        return constModels.get(expr.text) ?? null;
+    return null;
+}
+export function extractMedusaGeneratedServices(content, tsx) {
+    const sf = ts.createSourceFile(tsx ? "generated.tsx" : "generated.ts", content, ts.ScriptTarget.Latest, true, tsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const constModels = constObjectModelMaps(sf);
+    const out = [];
+    ts.forEachChild(sf, (node) => {
+        if (!ts.isClassDeclaration(node) || !node.name || !node.heritageClauses)
+            return;
+        for (const clause of node.heritageClauses) {
+            if (clause.token !== ts.SyntaxKind.ExtendsKeyword)
+                continue;
+            for (const type of clause.types) {
+                const call = medusaServiceCall(type.expression);
+                const arg = call?.arguments[0];
+                if (!arg)
+                    continue;
+                const modelKeys = modelKeysFromExpr(arg, constModels);
+                if (!modelKeys || modelKeys.length === 0)
+                    continue;
+                const methods = [...new Set(modelKeys.flatMap(medusaGeneratedMethodNames))];
+                out.push({ className: node.name.text, modelKeys, methods });
+            }
+        }
+    });
+    return out;
+}
+/**
+ * Extract raw (caller, callee) call pairs from a TS/JS file. `tsx` selects the
+ * grammar (TSX for .tsx/.jsx). Caller attribution: a call is attributed to the
+ * nearest enclosing function declaration, class method, or const binding —
+ * anonymous closures (callbacks, `useEffect(() => …)`) inherit their enclosing
+ * named scope. Calls at module scope (no enclosing named symbol) are dropped.
+ */
+export function extractCalls(content, tsx) {
+    const sf = ts.createSourceFile(tsx ? "calls.tsx" : "calls.ts", content, ts.ScriptTarget.Latest, 
+    /*setParentNodes*/ true, tsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const out = [];
+    let capped = false;
+    const injectedFieldsByClass = collectInjectedFieldsByClass(sf);
+    // `thisExact` = `this` currently refers to the lexical class instance, so a
+    // `this.member()` resolves exactly to that class's member. True only inside a
+    // class method body and arrow callbacks nested within it; a non-arrow
+    // `function () {}` (or a nested function declaration) REBINDS `this`, so a
+    // `this.member()` there is NOT exact and is dropped.
+    const recordCall = (node, caller, shadowed, thisExact) => {
+        if (out.length >= MAX_CALLS_PER_FILE) {
+            capped = true;
+            return;
+        }
+        const e = node.expression;
+        if (ts.isIdentifier(e)) {
+            if (shadowed.has(e.text))
+                return; // a local binding shadows the callee
+            out.push({ caller, callee: e.text, via: "free" });
+        }
+        else if (ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.name)) {
+            if (e.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                if (!thisExact)
+                    return; // `this` was rebound by a non-arrow function — not exact
+                out.push({ caller, callee: e.name.text, via: "this" });
+            }
+            else if (ts.isPropertyAccessExpression(e.expression) &&
+                e.expression.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                ts.isIdentifier(e.expression.name)) {
+                if (!thisExact)
+                    return; // `this` was rebound by a non-arrow function — not exact
+                const cls = caller.includes(".") ? caller.slice(0, caller.indexOf(".")) : "";
+                const field = e.expression.name.text;
+                const injectedType = cls ? injectedFieldsByClass.get(cls)?.get(field) : undefined;
+                if (injectedType)
+                    out.push({ caller, callee: e.name.text, via: "injected", qualifier: field, injectedType });
+            }
+            else if (ts.isIdentifier(e.expression)) {
+                if (shadowed.has(e.expression.text))
+                    return; // a local shadows the qualifier object
+                out.push({ caller, callee: e.name.text, via: "static", qualifier: e.expression.text });
+            }
+        }
+    };
+    const extend = (parent, fn) => {
+        const locals = scopeBindings(fn);
+        if (locals.size === 0)
+            return parent;
+        return new Set([...parent, ...locals]);
+    };
+    // `topLevel` = we are at the file's MODULE scope, where a named function/class/
+    // const declaration is an emittable symbol the analyzer can match by name. It
+    // is FALSE inside any function/method/closure body AND inside a `namespace`/
+    // `module` block (whose members are NOT emitted as top-level symbols, so a
+    // namespace-nested `inner` must not impersonate a top-level exported `inner`).
+    // A nested named declaration does not establish a caller; its calls are dropped
+    // (under-emit; hard CALLS cannot guess). Anonymous closures still inherit the
+    // enclosing caller — they have no name to impersonate.
+    const walk = (node, caller, shadowed, thisExact, topLevel) => {
+        if (capped)
+            return;
+        if (ts.isModuleDeclaration(node)) {
+            // namespace/module N { … } — a non-emitting boundary. Drop its calls.
+            if (node.body)
+                ts.forEachChild(node.body, (x) => walk(x, null, shadowed, false, false));
+            return;
+        }
+        if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+            if (!topLevel || ts.isClassExpression(node))
+                return; // nested/namespace/expression class — drop
+            const cls = node.name?.text;
+            for (const m of node.members) {
+                if (ts.isMethodDeclaration(m) && m.name && ts.isIdentifier(m.name) && m.body) {
+                    const c = cls ? `${cls}.${m.name.text}` : null;
+                    // A method body has class `this` (exact); it is no longer top-level.
+                    if (c)
+                        ts.forEachChild(m.body, (x) => walk(x, c, extend(shadowed, m), true, false));
+                }
+            }
+            return;
+        }
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            if (node.body) {
+                const sh = extend(shadowed, node);
+                // Nested/namespace function declaration → drop (caller=null); rebinds `this`.
+                const next = topLevel ? node.name.text : null;
+                ts.forEachChild(node.body, (x) => walk(x, next, sh, false, false));
+            }
+            return;
+        }
+        if (ts.isVariableStatement(node)) {
+            if (!topLevel)
+                return; // nested/namespace const/let → drop (would impersonate an emitted symbol)
+            for (const d of node.declarationList.declarations) {
+                if (ts.isIdentifier(d.name) && d.initializer) {
+                    const callerName = d.name.text;
+                    const init = d.initializer;
+                    if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+                        walk(init, callerName, shadowed, thisExact, false); // arrow/fn handler decides `this`
+                    }
+                    else {
+                        // wrapper call (forwardRef(...), memo(...)): don't record it, descend for inner closures.
+                        ts.forEachChild(init, (x) => walk(x, callerName, shadowed, thisExact, false));
+                    }
+                }
+            }
+            return;
+        }
+        if (ts.isArrowFunction(node)) {
+            // Arrow: keeps the enclosing caller AND lexical `this`. Walk the body NODE
+            // directly so an EXPRESSION body (`() => render()`) is not skipped.
+            const sh = extend(shadowed, node);
+            if (node.body)
+                walk(node.body, caller, sh, thisExact, false);
+            return;
+        }
+        if (ts.isFunctionExpression(node)) {
+            // `function () {}` rebinds `this` — clear thisExact for its body.
+            const sh = extend(shadowed, node);
+            if (node.body)
+                walk(node.body, caller, sh, false, false);
+            return;
+        }
+        if (caller && ts.isCallExpression(node))
+            recordCall(node, caller, shadowed, thisExact);
+        ts.forEachChild(node, (c) => walk(c, caller, shadowed, thisExact, topLevel));
+    };
+    const EMPTY = new Set();
+    ts.forEachChild(sf, (c) => walk(c, null, EMPTY, false, true));
+    return out;
+}