@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/inspect/standalone-inspect-analysis.js

@@ -0,0 +1,319 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStandaloneInspectPayload = runStandaloneInspectPayload;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const inspect_duplicates_service_1 = require("./inspect-duplicates-service");
+const inspect_source_ranges_1 = require("./inspect-source-ranges");
+const inspect_source_shape_1 = require("./inspect-source-shape");
+const standalone_inspect_model_1 = require("./standalone-inspect-model");
+const standalone_inspect_usages_1 = require("./standalone-inspect-usages");
+async function runStandaloneInspectPayload(cwd, payload) {
+    const rawRequests = Array.isArray(payload.requests) ? payload.requests : [payload];
+    const results = [];
+    for (const raw of rawRequests) {
+        if (!isRecord(raw)) {
+            results.push({ ok: false, code: "INVALID_INSPECT_REQUEST", error: "Inspect request must be an object." });
+            continue;
+        }
+        try {
+            results.push(await runRequest(cwd, normalizeRequest(cwd, raw)));
+        }
+        catch (error) {
+            results.push({ id: typeof raw.id === "string" ? raw.id : null, op: typeof raw.op === "string" ? raw.op : "file", ok: false, code: "INSPECT_REQUEST_FAILED", error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return { ok: results.every((item) => item.ok !== false), operation: "inspect", requestCount: results.length, results };
+}
+async function runRequest(cwd, request) {
+    if (request.op === "directoryFallback" && request.fallback)
+        return request.fallback;
+    const sourceFile = path.resolve(cwd, request.sourceFile);
+    request.sourceFile = sourceFile;
+    request.cwd = cwd;
+    if (request.op === "duplicates")
+        return (0, inspect_duplicates_service_1.buildDuplicatesPayload)(sourceFile, request);
+    if (!fs.existsSync(sourceFile))
+        return { id: request.id ?? null, op: request.op, ok: false, code: "FILE_NOT_FOUND", error: `File not found: ${sourceFile}`, requestedPath: request.sourceFile, resolvedPath: sourceFile };
+    if (request.op === "usages")
+        return (0, standalone_inspect_usages_1.buildStandaloneUsagesPayload)(cwd, sourceFile, request);
+    if (!fs.statSync(sourceFile).isFile())
+        return { id: request.id ?? null, op: request.op, ok: false, code: "NOT_A_FILE", error: `Expected a file: ${sourceFile}`, requestedPath: request.sourceFile, resolvedPath: sourceFile };
+    const sourceText = fs.readFileSync(sourceFile, "utf8");
+    const symbols = (0, inspect_source_shape_1.collectInspectSymbols)(sourceFile, sourceText);
+    if (request.op === "file") {
+        const topLevelSymbols = symbols.map((symbol) => (0, inspect_source_shape_1.symbolToPayload)(symbol, request.includeRanges));
+        const result = { id: request.id ?? null, op: request.op, ok: true, sourceFile, languageId: languageId(sourceFile), symbolCount: topLevelSymbols.length, symbols: topLevelSymbols };
+        if (topLevelSymbols.length === 0 && sourceText.trim())
+            result.hasNonDeclarationText = true;
+        if (request.localOnly) {
+            const reexports = collectReexports(sourceFile, sourceText);
+            result.mode = "local";
+            result.localDeclarationCount = topLevelSymbols.length;
+            result.reexportCount = reexports.length;
+            result.reexports = reexports;
+        }
+        return result;
+    }
+    if (request.op === "exports") {
+        const exported = [...symbols.filter((item) => item.exported), ...(request.resolveStar ? await (0, inspect_source_shape_1.collectStarExportSymbols)(sourceFile, sourceText) : [])]
+            .filter((item) => item.exported)
+            .map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges));
+        return { id: request.id ?? null, op: request.op, ok: true, sourceFile, exportCount: exported.length, exports: exported };
+    }
+    if (request.op === "members") {
+        const parent = (0, inspect_source_shape_1.findSymbol)(symbols, request.symbolName, request.symbolKind);
+        if (!parent)
+            return notFound(request);
+        const visible = request.memberAll ? parent.children : parent.children.slice(request.memberOffset, request.memberOffset + request.memberLimit);
+        return {
+            id: request.id ?? null,
+            op: request.op,
+            ok: true,
+            sourceFile,
+            entity: (0, inspect_source_shape_1.symbolToPayload)(parent, request.includeRanges),
+            memberCount: parent.children.length,
+            memberOffset: request.memberAll ? 0 : request.memberOffset,
+            memberLimit: request.memberAll ? parent.children.length : request.memberLimit,
+            hiddenMemberCount: request.memberAll ? 0 : Math.max(0, parent.children.length - request.memberOffset - visible.length),
+            members: visible.map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges)),
+            ...(request.memberAll ? {} : { hiddenMembers: parent.children.slice(request.memberOffset + visible.length).map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges)) })
+        };
+    }
+    const symbol = (0, inspect_source_shape_1.findCodeSymbol)(symbols, request);
+    if (!symbol)
+        return notFound(request);
+    if (request.op === "dependencies") {
+        const groups = collectLocalDependencies(sourceFile, sourceText, symbols, symbol);
+        const dependencies = [...groups.typeOnly, ...groups.value, ...groups.unclassified].sort((left, right) => left.range.start.line - right.range.start.line);
+        return {
+            id: request.id ?? null,
+            op: request.op,
+            ok: true,
+            sourceFile,
+            entity: (0, inspect_source_shape_1.symbolToPayload)(symbol, request.includeRanges),
+            dependencyCount: dependencies.length,
+            dependencies: dependencies.map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges)),
+            typeOnlyDependencies: groups.typeOnly.map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges)),
+            valueDependencies: groups.value.map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges)),
+            unclassifiedDependencies: groups.unclassified.map((item) => (0, inspect_source_shape_1.symbolToPayload)(item, request.includeRanges))
+        };
+    }
+    return {
+        id: request.id ?? null,
+        op: request.op,
+        ok: true,
+        sourceFile,
+        entity: (0, inspect_source_shape_1.symbolToPayload)(symbol, request.includeRanges),
+        code: (0, inspect_source_ranges_1.sliceSourceByRange)(sourceText, symbol.range),
+        lineCount: Math.max(1, symbol.range.end.line - symbol.range.start.line + 1)
+    };
+}
+function collectLocalDependencies(file, text, symbols, target) {
+    const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true);
+    const start = target.node.getStart(source);
+    const end = target.node.getEnd();
+    const topLevel = new Map(symbols.filter((item) => item !== target).map((item) => [item.name, item]));
+    const byName = new Map();
+    const decoratorReferences = new Set();
+    const directMemberCalls = new Map();
+    const targetNode = findNodeBySpan(source, start, end) ?? target.node;
+    const visit = (node) => {
+        if (typescript_1.default.isCallExpression(node) && typescript_1.default.isPropertyAccessExpression(node.expression)) {
+            const rawExpressionText = node.expression.getText(source);
+            const expressionText = rawExpressionText.replace(/^this\./u, "");
+            if (rawExpressionText.startsWith("this.") && expressionText.includes(".") && !directMemberCalls.has(expressionText)) {
+                const range = (0, inspect_source_ranges_1.toRangeInfo)(source, node.expression.getStart(source), node.expression.getEnd());
+                directMemberCalls.set(expressionText, {
+                    name: expressionText,
+                    kind: "method",
+                    exported: false,
+                    path: [expressionText],
+                    range,
+                    selectionRange: range,
+                    signature: "",
+                    children: [],
+                    node: node.expression,
+                    selector: expressionText
+                });
+            }
+        }
+        if (typescript_1.default.isIdentifier(node)) {
+            const dependency = topLevel.get(node.text);
+            if (dependency) {
+                const kind = isTypePosition(node) ? "type" : "value";
+                const previous = byName.get(node.text);
+                byName.set(node.text, previous && previous !== kind ? "mixed" : kind);
+                if (isInsideDecorator(node))
+                    decoratorReferences.add(node.text);
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(targetNode);
+    const typeOnly = [];
+    const value = [];
+    const unclassified = [];
+    for (const [name, kind] of byName) {
+        const original = topLevel.get(name);
+        const item = decoratorReferences.has(name) ? { ...original, selector: `@${name}` } : original;
+        if (kind === "type")
+            typeOnly.push(item);
+        else if (kind === "value")
+            value.push(item);
+        else
+            unclassified.push(item);
+    }
+    value.push(...directMemberCalls.values());
+    return { typeOnly, value, unclassified };
+}
+function isInsideDecorator(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (typescript_1.default.isDecorator(current)) {
+            const callee = typescript_1.default.isCallExpression(current.expression) ? current.expression.expression : current.expression;
+            return node.getStart() >= callee.getStart() && node.getEnd() <= callee.getEnd();
+        }
+        if (typescript_1.default.isStatement(current) || typescript_1.default.isClassElement(current))
+            return false;
+    }
+    return false;
+}
+function findNodeBySpan(source, start, end) {
+    let found = null;
+    const visit = (node) => {
+        if (node.getStart(source) === start && node.getEnd() === end) {
+            found = node;
+            return;
+        }
+        if (start >= node.getStart(source) && end <= node.getEnd())
+            typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function isTypePosition(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (typescript_1.default.isTypeNode(current) || typescript_1.default.isTypeAliasDeclaration(current) || typescript_1.default.isInterfaceDeclaration(current))
+            return true;
+        if (typescript_1.default.isExpression(current) || typescript_1.default.isStatement(current))
+            return false;
+    }
+    return false;
+}
+function collectReexports(file, text) {
+    const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true);
+    return source.statements.flatMap((statement) => {
+        if (!typescript_1.default.isExportDeclaration(statement) || !statement.moduleSpecifier || !typescript_1.default.isStringLiteral(statement.moduleSpecifier))
+            return [];
+        const start = source.getLineAndCharacterOfPosition(statement.getStart(source));
+        const end = source.getLineAndCharacterOfPosition(statement.getEnd());
+        return [{ moduleSpecifier: statement.moduleSpecifier.text, exportAll: !statement.exportClause, text: statement.getText(source), range: { start: { line: start.line, character: start.character }, end: { line: end.line, character: end.character } } }];
+    });
+}
+function normalizeRequest(cwd, raw) {
+    const op = typeof raw.op === "string" ? raw.op : "file";
+    const kinds = readStrings(raw.duplicateKinds ?? raw.kinds).map(standalone_inspect_model_1.normalizeKind).filter((item) => item !== null);
+    return {
+        ...(typeof raw.id === "string" ? { id: raw.id } : {}),
+        op: (["file", "exports", "members", "code", "dependencies", "slice", "usages", "duplicates", "directoryFallback"].includes(op) ? op : "file"),
+        sourceFile: readFirstString(raw.sourceFile, raw.file, raw.target, raw.dir, raw.scope) ?? "",
+        cwd,
+        ...(typeof raw.symbolName === "string" ? { symbolName: raw.symbolName } : {}),
+        ...(typeof raw.symbolKind === "string" ? { symbolKind: raw.symbolKind } : {}),
+        ...(typeof raw.parentName === "string" ? { parentName: raw.parentName } : {}),
+        ...(typeof raw.parentKind === "string" ? { parentKind: raw.parentKind } : {}),
+        usageEntities: readUsageEntities(raw.usageEntities),
+        includeRanges: raw.ranges === true || raw.includeRanges === true,
+        resolveStar: raw.resolveStar === true,
+        localOnly: raw.localOnly === true,
+        memberOffset: numberValue(raw.offset ?? raw.memberOffset, 0),
+        memberLimit: numberValue(raw.limit ?? raw.memberLimit, 20),
+        memberAll: raw.all === true || raw.memberAll === true,
+        usageScopes: readStrings(raw.scope ?? raw.scopes),
+        duplicateScopes: readStrings(raw.scope ?? raw.scopes),
+        duplicateKinds: kinds,
+        duplicateDetail: raw.detail === "locations" || raw.detail === "code" ? raw.detail : "summary",
+        duplicateMode: raw.mode === "exact" || raw.mode === "both" ? raw.mode : "names",
+        duplicateEntities: readEntityFilters(raw.duplicateEntities),
+        duplicateExclude: readEntityFilters(raw.duplicateExclude),
+        duplicatePathExclude: readStrings(raw.duplicatePathExclude),
+        duplicateLimit: numberValue(raw.limit, 10),
+        duplicateOffset: numberValue(raw.offset, 0),
+        excludeTarget: raw.excludeTarget === true,
+        targetLocalUsagesHidden: raw.targetLocalUsagesHidden === true,
+        ...(isRecord(raw.fallback) ? { fallback: raw.fallback } : {})
+    };
+}
+function readEntityFilters(value) {
+    return Array.isArray(value) ? value.flatMap((item) => isRecord(item) && typeof item.symbolName === "string" ? [{ symbolName: item.symbolName, ...(typeof item.symbolKind === "string" ? { symbolKind: item.symbolKind } : {}) }] : []) : [];
+}
+function readUsageEntities(value) {
+    return Array.isArray(value) ? value.flatMap((item) => {
+        if (!isRecord(item) || typeof item.symbolName !== "string")
+            return [];
+        return [{
+                symbolName: item.symbolName,
+                ...(typeof item.symbolKind === "string" ? { symbolKind: item.symbolKind } : {}),
+                ...(typeof item.parentName === "string" ? { parentName: item.parentName } : {}),
+                ...(typeof item.parentKind === "string" ? { parentKind: item.parentKind } : {})
+            }];
+    }) : [];
+}
+function readStrings(value) { if (typeof value === "string")
+    return [value]; return Array.isArray(value) ? value.filter((item) => typeof item === "string") : []; }
+function readFirstString(...values) { for (const value of values) {
+    if (typeof value === "string" && value)
+        return value;
+    if (Array.isArray(value) && typeof value[0] === "string")
+        return value[0];
+} return null; }
+function numberValue(value, fallback) { return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback; }
+function languageId(file) { const ext = path.extname(file).toLowerCase(); return ext === ".tsx" ? "typescriptreact" : ext === ".jsx" ? "javascriptreact" : [".js", ".mjs", ".cjs"].includes(ext) ? "javascript" : "typescript"; }
+function isRecord(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value)); }
+function notFound(request) {
+    return {
+        id: request.id ?? null,
+        op: request.op,
+        ok: false,
+        code: "INSPECT_SYMBOL_NOT_FOUND",
+        error: `Symbol not found: ${request.symbolKind ? `${request.symbolKind}:` : ""}${request.symbolName ?? ""}`,
+        sourceFile: request.sourceFile
+    };
+}

package/dist/inspect/standalone-inspect-model.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeKind = normalizeKind;
+function normalizeKind(kind) {
+    const normalized = kind.trim().toLowerCase();
+    return ["class", "interface", "function", "type", "enum", "namespace", "variable", "method", "property", "constructor", "runtime", "export"].includes(normalized)
+        ? normalized
+        : null;
+}

package/dist/inspect/standalone-inspect-process.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStandaloneInspectWorker = runStandaloneInspectWorker;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const owned_one_shot_process_1 = require("../workers/owned-one-shot-process");
+async function runStandaloneInspectWorker(workspaceRoot, payload, options = {}) {
+    const request = { type: "standaloneInspectRequest", id: `inspect_${(0, node_crypto_1.randomUUID)().replace(/-/g, "")}`, workspaceRoot: path.resolve(workspaceRoot), payload };
+    const result = await (0, owned_one_shot_process_1.runOwnedOneShotWorker)({
+        request,
+        workerPath: options.workerPath ?? path.join(__dirname, "standalone-inspect-worker.js"),
+        deadlineMs: options.deadlineMs ?? 180_000,
+        errorPrefix: "STANDALONE_INSPECT",
+        label: "Standalone inspect worker",
+        lifecycleReason: "standalone-inspect-worker",
+        validateResult: (raw, pid) => isResult(raw, request, pid) ? raw : null
+    });
+    return result.result;
+}
+function isResult(raw, request, pid) {
+    return Boolean(raw && typeof raw === "object" && !Array.isArray(raw) && raw.type === "standaloneInspectResult" && raw.id === request.id && raw.pid === pid && raw.result && typeof raw.result === "object");
+}

package/dist/inspect/standalone-inspect-usages.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStandaloneUsagesPayload = buildStandaloneUsagesPayload;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const standalone_ts_project_1 = require("../imports/standalone-ts-project");
+const inspect_reverse_module_closure_1 = require("./inspect-reverse-module-closure");
+const inspect_source_ranges_1 = require("./inspect-source-ranges");
+const inspect_source_shape_1 = require("./inspect-source-shape");
+function buildStandaloneUsagesPayload(root, targetPath, request) {
+    if (!fs.existsSync(targetPath))
+        return { id: request.id ?? null, op: request.op, ok: false, code: "USAGES_TARGET_NOT_FOUND", error: `Usage target not found: ${targetPath}` };
+    const targetMode = fs.statSync(targetPath).isDirectory() ? "directory" : "file";
+    const targetFiles = targetMode === "directory" ? collectSourceFiles(targetPath) : [targetPath];
+    const queryMode = request.usageEntities.length > 0 || Boolean(request.symbolName) ? "explicit" : "exports";
+    if (targetFiles.length === 0)
+        return emptyResult(targetPath, targetMode, queryMode, request);
+    const project = (0, standalone_ts_project_1.createStandaloneTsProject)(root, targetFiles[0]);
+    try {
+        const scopes = request.usageScopes.map((scope) => path.resolve(root, scope));
+        const targets = collectTargets(targetFiles, request);
+        const boundaryTargets = targets.filter((target) => (0, inspect_reverse_module_closure_1.shouldUseReverseModuleClosureForUsageTarget)(typescript_1.default, target.role, target.symbol.node, target.symbol.exported));
+        const closure = boundaryTargets.length > 0 ? buildClosure(root, targetPath, request, boundaryTargets) : null;
+        const occurrences = new Map();
+        for (const item of closure?.occurrences ?? [])
+            occurrences.set(item.seedId, [...(occurrences.get(item.seedId) ?? []), item]);
+        const symbolCache = new Map();
+        const textCache = new Map();
+        const items = targets.map((target) => buildUsageItem(project.languageService, target, scopes, targetPath, request.excludeTarget, symbolCache, textCache, occurrences.get(targetKey(target)) ?? []));
+        const referenceCount = items.reduce((sum, item) => sum + numberField(item, "referenceCount"), 0);
+        const files = new Set(items.flatMap((item) => Array.isArray(item.usedBy) ? item.usedBy.filter(isRecord).flatMap((usage) => typeof usage.file === "string" ? [path.normalize(usage.file)] : []) : []));
+        return {
+            id: request.id ?? null,
+            op: request.op,
+            ok: true,
+            targetPath,
+            targetMode,
+            queryMode,
+            excludeTarget: request.excludeTarget,
+            targetLocalUsagesHidden: request.targetLocalUsagesHidden,
+            usageScopes: request.usageScopes,
+            configFilePath: project.configFilePath,
+            ...(closure ? { reverseModuleClosure: {
+                    complete: closure.complete,
+                    truncated: closure.truncated,
+                    pendingStateCount: closure.pendingStateCount,
+                    filesScanned: closure.filesScanned,
+                    bytesScanned: closure.bytesScanned,
+                    edgeCount: closure.edgeCount,
+                    statesVisited: closure.statesVisited,
+                    programBuildCount: closure.programBuildCount,
+                    durationMs: closure.durationMs,
+                    rssBeforeMiB: closure.rssBeforeMiB,
+                    rssAfterMiB: closure.rssAfterMiB,
+                    uncertaintyCount: closure.uncertainties.length,
+                    uncertaintyTotal: closure.uncertaintyTotal,
+                    uncertaintiesTruncated: closure.uncertaintiesTruncated,
+                    uncertainties: closure.uncertainties
+                } } : {}),
+            summary: `${items.length} ${plural(items.length, "symbol")}, ${referenceCount} ${plural(referenceCount, "ref")}, ${files.size} ${plural(files.size, "file")}`,
+            itemCount: items.length,
+            referenceCount,
+            fileCount: files.size,
+            items
+        };
+    }
+    finally {
+        project.dispose();
+    }
+}
+function collectTargets(files, request) {
+    const result = [];
+    for (const file of files) {
+        const text = fs.readFileSync(file, "utf8");
+        const symbols = (0, inspect_source_shape_1.collectInspectSymbols)(file, text);
+        const boundaryExports = collectNamedExports(file, text);
+        const requested = request.usageEntities.length > 0 ? request.usageEntities : request.symbolName ? [{ symbolName: request.symbolName, ...(request.symbolKind ? { symbolKind: request.symbolKind } : {}) }] : null;
+        if (requested) {
+            for (const entity of requested) {
+                const symbol = (0, inspect_source_shape_1.findCodeSymbol)(symbols, { ...request, ...entity }) ?? (0, inspect_source_shape_1.findCodeSymbol)(boundaryExports, { ...request, ...entity });
+                if (!symbol)
+                    continue;
+                const exported = markLocalExported(text, symbol);
+                result.push({ file, symbol: exported, role: "self" });
+                if (symbol.kind === "class")
+                    for (const child of symbol.children.filter((item) => item.kind === "method" || item.kind === "property"))
+                        result.push({ file, symbol: child, role: "member" });
+            }
+            continue;
+        }
+        const exported = symbols.filter((item) => item.exported && !typescript_1.default.isExportDeclaration(item.node));
+        for (const symbol of uniqueSymbols([...exported, ...boundaryExports]))
+            result.push({ file, symbol, role: "export" });
+    }
+    return result;
+}
+function buildUsageItem(service, target, scopes, targetPath, excludeTarget, symbolCache, textCache, boundaryOccurrences) {
+    const sourceText = readText(target.file, textCache);
+    const position = offsetAt(sourceText, target.symbol.selectionRange.start.line, target.symbol.selectionRange.start.character);
+    const groups = service.findReferences(target.file, position) ?? [];
+    const raw = groups.flatMap((group) => group.references).filter((item) => !item.isDefinition)
+        .filter((item) => matchesScopes(item.fileName, scopes))
+        .filter((item) => !excludeTarget || !isInsideTarget(item.fileName, targetPath));
+    const rawSpans = new Set(raw.map((item) => spanKey(item.fileName, item.textSpan.start, item.textSpan.length)));
+    const references = raw.filter((item) => !isImportExportReference(item.fileName, item.textSpan.start, textCache));
+    const byFile = new Map();
+    for (const reference of references) {
+        const file = path.normalize(reference.fileName);
+        const text = readText(file, textCache);
+        const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true);
+        const location = source.getLineAndCharacterOfPosition(reference.textSpan.start);
+        const container = containingSymbol(readSymbols(file, symbolCache, textCache), location.line, location.character, target.symbol.name);
+        byFile.set(file, [...(byFile.get(file) ?? []), { line: location.line + 1, character: location.character, ...(container ? { container: (0, inspect_source_shape_1.symbolToPayload)(container, true) } : {}) }]);
+    }
+    let boundaryReferenceCount = 0;
+    for (const occurrence of boundaryOccurrences) {
+        const file = path.normalize(occurrence.file);
+        if (["exportStar", "namespace", "dynamic"].includes(occurrence.kind))
+            continue;
+        if (rawSpans.has(spanKey(file, occurrence.start, occurrence.length)) || byFile.has(file))
+            continue;
+        byFile.set(file, [{
+                line: occurrence.line + 1,
+                character: occurrence.character,
+                boundary: {
+                    kind: occurrence.kind,
+                    moduleSpecifier: occurrence.moduleSpecifier,
+                    entity: occurrence.entity,
+                    ...(occurrence.importedName ? { importedName: occurrence.importedName } : {}),
+                    ...(occurrence.exposedName ? { exposedName: occurrence.exposedName } : {}),
+                    ...(occurrence.localName ? { localName: occurrence.localName } : {}),
+                    typeOnly: occurrence.typeOnly,
+                    uncertain: occurrence.uncertain
+                }
+            }]);
+        boundaryReferenceCount += 1;
+    }
+    const usedBy = [...byFile.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([file, locations]) => ({ file, count: locations.length, locations }));
+    const count = references.length + boundaryReferenceCount;
+    return { entity: (0, inspect_source_shape_1.symbolToPayload)(target.symbol, false), declaredIn: target.file, role: target.role, summary: `${count} ${plural(count, "ref")}, ${usedBy.length} ${plural(usedBy.length, "file")}`, referenceCount: count, boundaryReferenceCount, fileCount: usedBy.length, usedBy };
+}
+function buildClosure(root, targetPath, request, targets) {
+    const configs = new Map();
+    return (0, inspect_reverse_module_closure_1.buildReverseModuleEntityClosure)({
+        ts: typescript_1.default,
+        files: collectSourceFiles(root),
+        seeds: targets.map((target) => ({ id: targetKey(target), file: target.file, entity: target.symbol.name })),
+        resolveModule: (fromFile, specifier) => {
+            const directory = path.dirname(fromFile);
+            let options = configs.get(directory);
+            if (!options) {
+                try {
+                    const project = (0, standalone_ts_project_1.createStandaloneTsProject)(root, fromFile);
+                    options = project.parsedConfig.options;
+                    project.dispose();
+                }
+                catch {
+                    options = {};
+                }
+                configs.set(directory, options);
+            }
+            return typescript_1.default.resolveModuleName(specifier, fromFile, options, typescript_1.default.sys).resolvedModule?.resolvedFileName ?? null;
+        },
+        includeOccurrence: (file) => matchesScopes(file, request.usageScopes.map((scope) => path.resolve(root, scope))) && (!request.excludeTarget || !isInsideTarget(file, targetPath))
+    });
+}
+function collectNamedExports(file, text) {
+    const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true);
+    const symbols = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isExportDeclaration(statement) || !statement.exportClause || !typescript_1.default.isNamedExports(statement.exportClause))
+            continue;
+        const sourceModule = statement.moduleSpecifier && typescript_1.default.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+        for (const element of statement.exportClause.elements) {
+            const symbol = (0, inspect_source_shape_1.createSyntheticSymbol)(typescript_1.default, source, element, { name: element.name.text, kind: "export", exported: true, ...(sourceModule ? { sourceModule } : {}) });
+            symbol.selectionRange = (0, inspect_source_ranges_1.toRangeInfo)(source, element.name.getStart(source), element.name.getEnd());
+            symbols.push(symbol);
+        }
+    }
+    return symbols;
+}
+function markLocalExported(text, symbol) {
+    if (symbol.exported)
+        return symbol;
+    const source = typescript_1.default.createSourceFile("target.ts", text, typescript_1.default.ScriptTarget.Latest, true);
+    const exported = source.statements.some((statement) => typescript_1.default.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause) && statement.exportClause.elements.some((item) => (item.propertyName?.text ?? item.name.text) === symbol.name));
+    return exported ? { ...symbol, exported: true } : symbol;
+}
+function isImportExportReference(file, position, cache) {
+    const source = typescript_1.default.createSourceFile(file, readText(file, cache), typescript_1.default.ScriptTarget.Latest, true);
+    let node = source;
+    const visit = (current) => { if (position >= current.getStart(source) && position < current.getEnd()) {
+        node = current;
+        typescript_1.default.forEachChild(current, visit);
+    } };
+    visit(source);
+    for (let current = node; current; current = current.parent)
+        if (typescript_1.default.isImportDeclaration(current) || typescript_1.default.isExportDeclaration(current) || typescript_1.default.isImportEqualsDeclaration(current))
+            return true;
+    return false;
+}
+function containingSymbol(symbols, line, character, exclude) {
+    return (0, inspect_source_shape_1.flattenSymbols)([...symbols]).filter((item) => item.name !== exclude && rangeContains(item, line, character)).sort((a, b) => rangeSize(a) - rangeSize(b))[0] ?? null;
+}
+function rangeContains(symbol, line, character) { const { start, end } = symbol.range; return (line > start.line || line === start.line && character >= start.character) && (line < end.line || line === end.line && character <= end.character); }
+function rangeSize(symbol) { return (symbol.range.end.line - symbol.range.start.line) * 1_000_000 + symbol.range.end.character - symbol.range.start.character; }
+function readText(file, cache) { let text = cache.get(file); if (text === undefined) {
+    text = fs.readFileSync(file, "utf8");
+    cache.set(file, text);
+} return text; }
+function readSymbols(file, cache, textCache) { let symbols = cache.get(file); if (!symbols) {
+    symbols = (0, inspect_source_shape_1.collectInspectSymbols)(file, readText(file, textCache));
+    cache.set(file, symbols);
+} return symbols; }
+function offsetAt(text, line, character) { const lines = text.split(/\r?\n/); let offset = 0; for (let index = 0; index < Math.min(line, lines.length); index += 1)
+    offset += (lines[index]?.length ?? 0) + 1; return Math.min(text.length, offset + character); }
+function matchesScopes(file, scopes) { return scopes.length === 0 || scopes.some((scope) => { const relative = path.relative(scope, file); return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)); }); }
+function isInsideTarget(file, target) { const relative = path.relative(target, file); return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)); }
+function spanKey(file, start, length) { const normalized = path.normalize(file); return `${process.platform === "win32" ? normalized.toLowerCase() : normalized}:${start}:${length}`; }
+function targetKey(target) { return `${path.normalize(target.file)}\0${target.symbol.name}\0${target.symbol.selectionRange.start.line}\0${target.symbol.selectionRange.start.character}`; }
+function uniqueSymbols(symbols) { return [...new Map(symbols.map((item) => [`${item.name}\0${item.selectionRange.start.line}\0${item.selectionRange.start.character}`, item])).values()]; }
+function collectSourceFiles(scope) { if (!fs.existsSync(scope))
+    return []; if (fs.statSync(scope).isFile())
+    return isSource(scope) ? [path.normalize(scope)] : []; const result = []; for (const entry of fs.readdirSync(scope, { withFileTypes: true })) {
+    if (["node_modules", ".git", ".tmp", "dist", "out", "build"].includes(entry.name))
+        continue;
+    const child = path.join(scope, entry.name);
+    if (entry.isDirectory())
+        result.push(...collectSourceFiles(child));
+    else if (entry.isFile() && isSource(child))
+        result.push(path.normalize(child));
+} return result.sort(); }
+function isSource(file) { return /\.(?:[cm]?[jt]sx?)$/i.test(file) && !file.endsWith(".d.ts"); }
+function emptyResult(targetPath, targetMode, queryMode, request) { return { id: request.id ?? null, op: request.op, ok: true, targetPath, targetMode, queryMode, excludeTarget: request.excludeTarget, targetLocalUsagesHidden: request.targetLocalUsagesHidden, usageScopes: request.usageScopes, summary: "0 symbols, 0 refs, 0 files", itemCount: 0, referenceCount: 0, fileCount: 0, items: [] }; }
+function plural(count, singular) { return count === 1 ? singular : `${singular}s`; }
+function numberField(value, key) { return typeof value[key] === "number" ? value[key] : 0; }
+function isRecord(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value)); }