@beignet/cli 0.0.39 → 0.0.41

package/dist/app-map.js

@@ -0,0 +1,1141 @@
+import path from "node:path";
+import ts from "typescript";
+import { createSourceIndex, exportedVariableDeclarations, literalText, localImportReferences, propertyAssignment, propertyName, visitCalls, } from "./analysis/source-index.js";
+import { createAnalysisWorkspace, } from "./analysis/workspace.js";
+import { directoryPath } from "./config.js";
+import { inspectApp, } from "./inspect.js";
+import { lintApp } from "./lint.js";
+import { auditProviders } from "./provider-audit.js";
+export { appMapNodeKinds } from "./app-map-schema.js";
+const workflowKinds = new Set([
+    "event",
+    "listener",
+    "job",
+    "schedule",
+    "task",
+    "notification",
+    "upload",
+]);
+const definitionCalls = {
+    defineEvent: "event",
+    defineListener: "listener",
+    defineJob: "job",
+    defineNotificationDeliveryJob: "job",
+    defineSchedule: "schedule",
+    defineTask: "task",
+    defineNotification: "notification",
+    defineUpload: "upload",
+    defineAgentCapability: "agent-capability",
+};
+/** Build a deterministic, side-effect-free map of one Beignet app. */
+export async function mapApp(options = {}) {
+    const workspace = await createAnalysisWorkspace(options.cwd);
+    const [inspection, lint, providerAudit] = await Promise.all([
+        inspectApp({ cwd: workspace.targetDir, strict: options.strict ?? true }),
+        lintApp({ cwd: workspace.targetDir }),
+        auditProviders({ cwd: workspace.targetDir }),
+    ]);
+    const sourceIndex = createSourceIndex(workspace);
+    const nodes = new Map();
+    const edges = [];
+    const unresolved = [];
+    const definitions = new Map();
+    const definitionBySource = new Map();
+    const registries = [];
+    const featuresPath = directoryPath(workspace.config.paths.features);
+    const featureNames = discoverFeatureNames(workspace, featuresPath);
+    const addNode = (node) => {
+        const existing = nodes.get(node.id);
+        if (!existing) {
+            nodes.set(node.id, node);
+            return;
+        }
+        if (sourceKey(existing.source) !== sourceKey(node.source)) {
+            unresolved.push({
+                code: "duplicate_node_id",
+                message: `Multiple declarations resolve to app-map node ${node.id}.`,
+                source: node.source,
+            });
+        }
+    };
+    const addEdge = (edge) => edges.push(edge);
+    for (const feature of featureNames) {
+        const featureFiles = filesForFeature(workspace.files, featuresPath, feature);
+        const roles = summarizeFeatureFiles(featureFiles);
+        addNode({
+            id: featureId(feature),
+            kind: "feature",
+            name: feature,
+            feature,
+            source: { file: `${featuresPath}/${feature}` },
+            status: "declared",
+            details: roles,
+        });
+        for (const file of featureFiles.filter(isTestFile)) {
+            const id = `test:${file}`;
+            addNode({
+                id,
+                kind: "test",
+                name: path.posix.basename(file),
+                feature,
+                source: { file },
+                status: "declared",
+            });
+            addEdge(exactEdge("contains-test", featureId(feature), id, file));
+        }
+    }
+    const contractIds = new Map();
+    const contractIdsByExport = new Map();
+    for (const contract of inspection.contracts) {
+        const id = `contract:${contract.file}#${contract.exportName}`;
+        const feature = featureForFile(contract.file, featuresPath);
+        contractIds.set(symbolKey(contract.file, contract.exportName), id);
+        const exports = contractIdsByExport.get(contract.exportName) ?? [];
+        exports.push(id);
+        contractIdsByExport.set(contract.exportName, exports);
+        addNode({
+            id,
+            kind: "contract",
+            name: contract.exportName,
+            ...(feature ? { feature } : {}),
+            source: { file: contract.file, exportName: contract.exportName },
+            status: "declared",
+            details: {
+                method: contract.method,
+                path: contract.path,
+                metadata: contract.metadata,
+            },
+        });
+        if (feature) {
+            addEdge(exactEdge("owns", featureId(feature), id, contract.file));
+        }
+        const ability = contract.metadata?.authorizationAbility;
+        if (ability) {
+            addEdge(exactEdge("authorizes", id, abilityId(ability), contract.file));
+        }
+    }
+    const routeIds = new Map();
+    for (const route of inspection.routes) {
+        const contractId = contractIds.get(symbolKey(route.file, route.exportName));
+        if (!contractId)
+            continue;
+        const id = `route:${route.file}#${route.exportName}`;
+        routeIds.set(contractId, id);
+        addNode({
+            id,
+            kind: "route",
+            name: `${route.method} ${route.path}`,
+            ...(featureForFile(route.file, featuresPath)
+                ? { feature: featureForFile(route.file, featuresPath) }
+                : {}),
+            source: {
+                file: route.handlerFile ?? route.file,
+                exportName: route.handlerExport,
+            },
+            status: route.handlerSource === "missing" ? "missing" : "registered",
+            details: {
+                method: route.method,
+                path: route.path,
+                handlerSource: route.handlerSource,
+            },
+        });
+        addEdge(exactEdge("binds", id, contractId, route.file));
+        if (route.handlerFile) {
+            const entrypointId = `entrypoint:${route.handlerFile}`;
+            addNode({
+                id: entrypointId,
+                kind: "entrypoint",
+                name: route.handlerFile,
+                source: { file: route.handlerFile },
+                status: "registered",
+                details: { type: route.handlerSource },
+            });
+            addEdge(exactEdge("exposes", entrypointId, id, route.handlerFile));
+        }
+    }
+    if (workspace.fileSet.has(workspace.config.paths.server)) {
+        addNode({
+            id: `entrypoint:${workspace.config.paths.server}`,
+            kind: "entrypoint",
+            name: workspace.config.paths.server,
+            source: { file: workspace.config.paths.server },
+            status: "registered",
+            details: { type: "server" },
+        });
+    }
+    const sourceFiles = workspace.files.filter(isTypeScriptSource);
+    for (const file of sourceFiles) {
+        const sourceFile = await workspace.readSourceFile(file);
+        for (const { exportName, declaration } of exportedVariableDeclarations(sourceFile)) {
+            const initializer = declaration.initializer;
+            if (!initializer)
+                continue;
+            const useCaseCall = findCall(initializer, new Set(["command", "query"]));
+            if (useCaseCall) {
+                const runtimeName = literalText(useCaseCall.arguments[0]);
+                if (runtimeName) {
+                    const kind = callMemberName(useCaseCall);
+                    const feature = featureForFile(file, featuresPath);
+                    const id = `use-case:${runtimeName}`;
+                    const node = {
+                        id,
+                        kind: "use-case",
+                        name: exportName,
+                        runtimeName,
+                        ...(feature ? { feature } : {}),
+                        source: await sourceIndex.sourceLocation(file, declaration, exportName),
+                        status: "declared",
+                        details: { kind },
+                    };
+                    addNode(node);
+                    const record = {
+                        node,
+                        file,
+                        exportName,
+                        declaration,
+                        call: useCaseCall,
+                    };
+                    if (!definitions.has(id))
+                        definitions.set(id, record);
+                    definitionBySource.set(symbolKey(file, exportName), id);
+                    if (feature) {
+                        addEdge(exactEdge("owns", featureId(feature), id, file));
+                    }
+                }
+            }
+            const definitionCall = findCall(initializer, new Set(Object.keys(definitionCalls)));
+            if (definitionCall) {
+                const call = callMemberName(definitionCall);
+                const kind = call
+                    ? definitionCalls[call]
+                    : undefined;
+                const runtimeName = definitionRuntimeName(call, definitionCall);
+                if (kind && runtimeName) {
+                    const feature = featureForFile(file, featuresPath);
+                    const id = `${kind}:${runtimeName}`;
+                    const status = definitionStatus(kind, file, exportName, inspection.diagnostics);
+                    const node = {
+                        id,
+                        kind,
+                        name: exportName,
+                        runtimeName,
+                        ...(feature ? { feature } : {}),
+                        source: await sourceIndex.sourceLocation(file, declaration, exportName),
+                        status,
+                    };
+                    addNode(node);
+                    if (!definitions.has(id)) {
+                        definitions.set(id, {
+                            node,
+                            file,
+                            exportName,
+                            declaration,
+                            call: definitionCall,
+                        });
+                    }
+                    definitionBySource.set(symbolKey(file, exportName), id);
+                    if (feature) {
+                        addEdge(exactEdge("owns", featureId(feature), id, file));
+                    }
+                }
+            }
+            const policyCall = findCall(initializer, new Set(["definePolicy"]));
+            if (policyCall && ts.isObjectLiteralExpression(policyCall.arguments[0])) {
+                const feature = featureForFile(file, featuresPath);
+                const policyId = `policy:${file}#${exportName}`;
+                addNode({
+                    id: policyId,
+                    kind: "policy",
+                    name: exportName,
+                    ...(feature ? { feature } : {}),
+                    source: await sourceIndex.sourceLocation(file, declaration, exportName),
+                    status: "declared",
+                });
+                if (feature) {
+                    addEdge(exactEdge("owns", featureId(feature), policyId, file));
+                }
+                for (const property of policyCall.arguments[0].properties) {
+                    const name = property.name ? propertyName(property.name) : undefined;
+                    if (!name)
+                        continue;
+                    const id = abilityId(name);
+                    addNode({
+                        id,
+                        kind: "ability",
+                        name,
+                        runtimeName: name,
+                        ...(feature ? { feature } : {}),
+                        source: await sourceIndex.sourceLocation(file, property),
+                        status: "declared",
+                    });
+                    addEdge(exactEdge("registers", policyId, id, file));
+                }
+            }
+            const registry = await registryRecord({
+                workspace,
+                sourceIndex,
+                file,
+                exportName,
+                declaration,
+            });
+            if (registry) {
+                addNode(registry.node);
+                registries.push(registry);
+            }
+        }
+    }
+    for (const definition of definitions.values()) {
+        if (definition.node.kind === "listener") {
+            const options = definition.call.arguments[1];
+            if (options && ts.isObjectLiteralExpression(options)) {
+                const event = propertyAssignment(options, "event")?.initializer;
+                if (event) {
+                    const target = await sourceIndex.resolveExpression(definition.file, event);
+                    const targetId = target
+                        ? definitionBySource.get(symbolKey(target.file, target.exportName))
+                        : undefined;
+                    if (targetId) {
+                        addEdge(await nodeEdge("listens-to", definition.node.id, targetId, definition.file, event, workspace));
+                    }
+                }
+            }
+        }
+        visitCalls(definition.declaration, (call) => {
+            const name = callMemberName(call);
+            if (name === "authorize") {
+                const ability = literalText(call.arguments[0]);
+                if (ability) {
+                    addEdge(sourceNodeEdge("authorizes", definition.node.id, abilityId(ability), definition.file, call));
+                }
+            }
+        });
+        const emits = findCall(definition.declaration.initializer, new Set(["emits"]));
+        const emitsArray = emits?.arguments[0];
+        if (emitsArray && ts.isArrayLiteralExpression(emitsArray)) {
+            for (const element of emitsArray.elements) {
+                if (!ts.isExpression(element))
+                    continue;
+                const target = await sourceIndex.resolveExpression(definition.file, element);
+                const targetId = target
+                    ? definitionBySource.get(symbolKey(target.file, target.exportName))
+                    : undefined;
+                if (targetId) {
+                    addEdge(await nodeEdge("emits", definition.node.id, targetId, definition.file, element, workspace));
+                }
+            }
+        }
+        const interactionCalls = [];
+        visitCalls(definition.declaration, (call) => {
+            const name = callMemberName(call);
+            if (["dispatch", "publish", "run", "send"].includes(name ?? "")) {
+                interactionCalls.push(call);
+            }
+        });
+        for (const call of interactionCalls) {
+            const name = callMemberName(call);
+            const targetExpression = name === "run" && ts.isPropertyAccessExpression(call.expression)
+                ? call.expression.expression
+                : call.arguments[0];
+            if (!targetExpression)
+                continue;
+            const target = await sourceIndex.resolveExpression(definition.file, targetExpression);
+            const targetId = target
+                ? definitionBySource.get(symbolKey(target.file, target.exportName))
+                : undefined;
+            if (!targetId)
+                continue;
+            const edgeKind = name === "dispatch"
+                ? "dispatches"
+                : name === "send"
+                    ? "sends"
+                    : name === "publish"
+                        ? "publishes"
+                        : "executes";
+            addEdge(sourceNodeEdge(edgeKind, definition.node.id, targetId, definition.file, call));
+        }
+    }
+    for (const registry of registries) {
+        for (const value of registry.values) {
+            const target = await sourceIndex.resolveExpression(registry.file, value);
+            const targetId = target
+                ? (definitionBySource.get(symbolKey(target.file, target.exportName)) ??
+                    registryIdForReference(target))
+                : undefined;
+            if (targetId && nodes.has(targetId)) {
+                addEdge(await nodeEdge("registers", registry.node.id, targetId, registry.file, value, workspace));
+                const targetNode = nodes.get(targetId);
+                if (targetNode?.status === "declared") {
+                    nodes.set(targetId, { ...targetNode, status: "registered" });
+                }
+            }
+        }
+    }
+    await addRouteGroups({
+        workspace,
+        sourceIndex,
+        addNode,
+        addEdge,
+        unresolved,
+        nodes,
+        contractIds,
+        contractIdsByExport,
+        routeIds,
+        definitionBySource,
+        featuresPath,
+        diagnostics: inspection.diagnostics,
+    });
+    await addOpenApiSurface({
+        workspace,
+        inspection,
+        contractIds,
+        addNode,
+        addEdge,
+    });
+    await addPorts({
+        workspace,
+        sourceIndex,
+        addNode,
+        addEdge,
+    });
+    await addTables({ workspace, sourceIndex, addNode });
+    await addFeatureDependencies({
+        workspace,
+        featuresPath,
+        addEdge,
+        featureNames: new Set(featureNames),
+    });
+    for (const provider of providerAudit.providers) {
+        const id = `provider:${provider.packageName}`;
+        const sourceFile = "package.json";
+        addNode({
+            id,
+            kind: "provider",
+            name: provider.packageName,
+            source: { file: sourceFile },
+            status: provider.registration === "registered"
+                ? provider.variants.some((variant) => variant.registration === "inactive")
+                    ? "conditional"
+                    : "registered"
+                : provider.registration === "missing"
+                    ? "missing"
+                    : "declared",
+            details: {
+                displayName: provider.displayName,
+                metadataSource: provider.metadata.source
+                    ? `${provider.packageName}/package.json`
+                    : undefined,
+                registration: provider.registration,
+                requiredEnv: provider.requiredEnv,
+                requiredTables: provider.requiredTables,
+                appPorts: provider.appPorts,
+                variants: provider.variants,
+                watchers: provider.watchers,
+                registrationSources: provider.registrationSources,
+            },
+        });
+        for (const port of provider.appPorts.required) {
+            const portNodeId = portId(port.name);
+            if (nodes.has(portNodeId)) {
+                addEdge(exactEdge("provides", id, portNodeId, sourceFile));
+            }
+        }
+    }
+    const finalNodes = [...nodes.values()].sort(compareNodes);
+    const nodeIds = new Set(finalNodes.map((node) => node.id));
+    const finalEdges = dedupeEdges(edges.filter((edge) => {
+        const valid = nodeIds.has(edge.from) && nodeIds.has(edge.to);
+        if (!valid) {
+            unresolved.push({
+                code: "dangling_edge",
+                message: `Could not materialize ${edge.kind} edge ${edge.from} -> ${edge.to}.`,
+                source: {
+                    file: edge.evidence.file,
+                    line: edge.evidence.line,
+                    column: edge.evidence.column,
+                },
+            });
+        }
+        return valid;
+    })).sort(compareEdges);
+    unresolved.sort((left, right) => `${left.source.file}:${left.source.line ?? 0}:${left.code}`.localeCompare(`${right.source.file}:${right.source.line ?? 0}:${right.code}`));
+    return {
+        schemaVersion: 1,
+        targetDir: workspace.targetDir,
+        app: {
+            framework: workspace.config.framework,
+            convention: inspection.convention.kind,
+            ...(workspace.config.configFile
+                ? { configFile: workspace.config.configFile }
+                : {}),
+        },
+        summary: summarize(finalNodes, inspection.diagnostics, lint.diagnostics, unresolved),
+        nodes: finalNodes,
+        edges: finalEdges,
+        diagnostics: {
+            doctor: inspection.diagnostics,
+            lint: lint.diagnostics,
+        },
+        unresolved,
+    };
+}
+/** Select a token-bounded view of a full app map. */
+export function projectAppMap(result, options = {}) {
+    const requestedKinds = options.kinds ? new Set(options.kinds) : undefined;
+    let nodes = result.nodes.filter((node) => (!options.feature ||
+        node.feature === options.feature ||
+        node.id === featureId(options.feature)) &&
+        (!requestedKinds || requestedKinds.has(node.kind)));
+    const selectedIds = new Set(nodes.map((node) => node.id));
+    let edges = result.edges.filter((edge) => selectedIds.has(edge.from) && selectedIds.has(edge.to));
+    if (options.feature && !requestedKinds) {
+        const oneHopIds = new Set(selectedIds);
+        for (const edge of result.edges) {
+            if (selectedIds.has(edge.from))
+                oneHopIds.add(edge.to);
+            if (selectedIds.has(edge.to))
+                oneHopIds.add(edge.from);
+        }
+        nodes = result.nodes.filter((node) => oneHopIds.has(node.id));
+        edges = result.edges.filter((edge) => oneHopIds.has(edge.from) && oneHopIds.has(edge.to));
+    }
+    const files = new Set(nodes.map((node) => node.source.file));
+    const doctor = options.includeDiagnostics === false
+        ? []
+        : result.diagnostics.doctor.filter((diagnostic) => !diagnostic.file ||
+            files.has(diagnostic.file) ||
+            nodes.some((node) => diagnostic.message.includes(node.source.file)));
+    const lint = options.includeDiagnostics === false
+        ? []
+        : result.diagnostics.lint.filter((diagnostic) => files.has(diagnostic.file));
+    const unresolved = result.unresolved.filter((item) => files.has(item.source.file));
+    return {
+        ...result,
+        summary: summarize(nodes, doctor, lint, unresolved),
+        nodes,
+        edges,
+        diagnostics: { doctor, lint },
+        unresolved,
+    };
+}
+/** Format a compact human-readable inventory of a Beignet app map. */
+export function formatAppMap(result) {
+    const featureRows = result.nodes
+        .filter((node) => node.kind === "feature")
+        .map((feature) => {
+        const ownedIds = new Set(result.edges
+            .filter((edge) => edge.kind === "owns" && edge.from === feature.id)
+            .map((edge) => edge.to));
+        const owned = result.nodes.filter((node) => ownedIds.has(node.id));
+        const details = feature.details ?? {};
+        return [
+            feature.name,
+            String(owned.filter((node) => node.kind === "contract").length),
+            String(owned.filter((node) => node.kind === "use-case").length),
+            String(owned.filter((node) => workflowKinds.has(node.kind)).length),
+            String(owned.filter((node) => node.kind === "port").length),
+            Number(details.components ?? 0) > 0 ? "yes" : "no",
+            String(details.tests ?? 0),
+        ];
+    });
+    return [
+        `Beignet app map for ${result.targetDir}`,
+        `Framework: ${result.app.framework} (${result.app.convention})`,
+        `Features: ${result.summary.features}  Routes: ${result.summary.routes}  Workflows: ${result.summary.workflows}  Providers: ${result.summary.providers}  OpenAPI: ${result.summary.openApiDocuments}`,
+        "",
+        ...(featureRows.length > 0
+            ? [
+                formatTable([
+                    [
+                        "FEATURE",
+                        "HTTP",
+                        "USE CASES",
+                        "WORKFLOWS",
+                        "PORTS",
+                        "UI",
+                        "TESTS",
+                    ],
+                    ...featureRows,
+                ]),
+            ]
+            : ["No feature folders found."]),
+        "",
+        `Diagnostics: ${result.summary.diagnostics}  Unresolved references: ${result.summary.unresolved}`,
+        "Run beignet map --json for the complete graph.",
+    ].join("\n");
+}
+async function addRouteGroups(args) {
+    const routeFiles = args.workspace.files.filter((file) => featureForFile(file, args.featuresPath) !== undefined &&
+        file.endsWith("/routes.ts"));
+    for (const file of routeFiles) {
+        const sourceFile = await args.workspace.readSourceFile(file);
+        for (const { exportName, declaration } of exportedVariableDeclarations(sourceFile)) {
+            const call = declaration.initializer
+                ? findCall(declaration.initializer, new Set(["defineRouteGroup"]))
+                : undefined;
+            const options = call?.arguments[0];
+            if (!call || !options || !ts.isObjectLiteralExpression(options))
+                continue;
+            const feature = featureForFile(file, args.featuresPath);
+            const groupName = literalText(propertyAssignment(options, "name")?.initializer);
+            const id = `route-group:${file}#${exportName}`;
+            const missing = args.diagnostics.some((diagnostic) => diagnostic.code === "BEIGNET_ROUTE_GROUP_UNREGISTERED" &&
+                diagnostic.message.includes(file) &&
+                diagnostic.message.includes(exportName));
+            args.addNode({
+                id,
+                kind: "route-group",
+                name: groupName ?? exportName,
+                ...(feature ? { feature } : {}),
+                source: await args.sourceIndex.sourceLocation(file, declaration, exportName),
+                status: missing ? "missing" : "registered",
+            });
+            if (feature) {
+                args.addEdge(exactEdge("owns", featureId(feature), id, file));
+            }
+            const routes = propertyAssignment(options, "routes")?.initializer;
+            if (!routes || !ts.isArrayLiteralExpression(routes))
+                continue;
+            for (const element of routes.elements) {
+                if (!ts.isObjectLiteralExpression(element)) {
+                    args.unresolved.push({
+                        code: "dynamic_route_entry",
+                        message: `${exportName} contains a route entry that cannot be resolved statically.`,
+                        source: await args.sourceIndex.sourceLocation(file, element),
+                    });
+                    continue;
+                }
+                const contractExpression = propertyAssignment(element, "contract")?.initializer;
+                if (!contractExpression)
+                    continue;
+                const contractReference = await args.sourceIndex.resolveExpression(file, contractExpression);
+                const contractId = contractReference
+                    ? (args.contractIds.get(symbolKey(contractReference.file, contractReference.exportName)) ??
+                        uniqueValue(args.contractIdsByExport.get(contractReference.exportName)))
+                    : undefined;
+                if (!contractId) {
+                    args.unresolved.push({
+                        code: "route_contract_unresolved",
+                        message: `Could not resolve a contract reference in ${exportName}.`,
+                        source: await args.sourceIndex.sourceLocation(file, contractExpression),
+                    });
+                    continue;
+                }
+                const routeId = args.routeIds.get(contractId);
+                if (routeId) {
+                    args.addEdge(await nodeEdge("registers", id, routeId, file, contractExpression, args.workspace));
+                }
+                const useCaseExpression = propertyAssignment(element, "useCase")?.initializer;
+                if (!useCaseExpression || !routeId)
+                    continue;
+                const useCaseReference = await args.sourceIndex.resolveExpression(file, useCaseExpression);
+                const useCaseId = useCaseReference
+                    ? args.definitionBySource.get(symbolKey(useCaseReference.file, useCaseReference.exportName))
+                    : undefined;
+                if (useCaseId) {
+                    args.addEdge(await nodeEdge("executes", routeId, useCaseId, file, useCaseExpression, args.workspace));
+                }
+                else {
+                    args.unresolved.push({
+                        code: "route_use_case_unresolved",
+                        message: `Could not resolve the use case for a route in ${exportName}.`,
+                        source: await args.sourceIndex.sourceLocation(file, useCaseExpression),
+                    });
+                }
+            }
+        }
+    }
+}
+async function addPorts(args) {
+    const portsFile = args.workspace.config.paths.ports;
+    if (!args.workspace.fileSet.has(portsFile))
+        return;
+    const sourceFile = await args.workspace.readSourceFile(portsFile);
+    const aliases = new Map();
+    for (const statement of sourceFile.statements) {
+        if (ts.isTypeAliasDeclaration(statement)) {
+            aliases.set(statement.name.text, statement.type);
+        }
+    }
+    const appPorts = aliases.get("AppPorts");
+    if (!appPorts)
+        return;
+    const bindings = await readPortBindings(args.workspace);
+    const properties = collectTypeProperties(appPorts, aliases);
+    for (const property of properties) {
+        const name = propertyName(property.name);
+        if (!name)
+            continue;
+        const feature = await portFeature(property.type, portsFile, args.workspace.config.paths.features, args.sourceIndex);
+        const id = portId(name);
+        args.addNode({
+            id,
+            kind: "port",
+            name,
+            ...(feature ? { feature } : {}),
+            source: await args.sourceIndex.sourceLocation(portsFile, property),
+            status: bindings.bound.has(name) || bindings.deferred.has(name)
+                ? "registered"
+                : "missing",
+            details: {
+                binding: bindings.bound.has(name)
+                    ? "bound"
+                    : bindings.deferred.has(name)
+                        ? "deferred"
+                        : "unresolved",
+                type: property.type?.getText(sourceFile),
+            },
+        });
+        if (feature) {
+            args.addEdge(exactEdge("owns", featureId(feature), id, portsFile));
+        }
+        if (bindings.bound.has(name)) {
+            const bindingId = `provider:app:${name}`;
+            args.addNode({
+                id: bindingId,
+                kind: "provider",
+                name: `${name} app binding`,
+                source: { file: args.workspace.config.paths.portWiring },
+                status: "registered",
+                details: { sourceType: "app-binding" },
+            });
+            args.addEdge(exactEdge("provides", bindingId, id, args.workspace.config.paths.portWiring));
+        }
+    }
+}
+async function addOpenApiSurface(args) {
+    const file = args.workspace.config.paths.openapiRoute;
+    if (!args.workspace.fileSet.has(file))
+        return;
+    const drift = args.inspection.diagnostics.filter((diagnostic) => diagnostic.file === file && diagnostic.code.includes("OPENAPI"));
+    const omittedContracts = new Set(drift
+        .filter((diagnostic) => diagnostic.code === "BEIGNET_OPENAPI_MISSING")
+        .flatMap((diagnostic) => diagnostic.contract ? [diagnostic.contract] : []));
+    const explicitlyDocumented = new Set(drift
+        .filter((diagnostic) => diagnostic.code === "BEIGNET_OPENAPI_UNROUTED")
+        .flatMap((diagnostic) => diagnostic.contract ? [diagnostic.contract] : []));
+    const documented = args.inspection.contracts.filter((contract) => (args.inspection.routes.some((route) => route.file === contract.file &&
+        route.exportName === contract.exportName) &&
+        !omittedContracts.has(contract.exportName)) ||
+        explicitlyDocumented.has(contract.exportName));
+    const id = `openapi:${file}`;
+    args.addNode({
+        id,
+        kind: "openapi",
+        name: "OpenAPI document",
+        source: { file },
+        status: drift.length > 0 ? "conditional" : "registered",
+        details: {
+            contracts: documented.length,
+            drift: drift.map((diagnostic) => diagnostic.code),
+        },
+    });
+    for (const contract of documented) {
+        const contractId = args.contractIds.get(symbolKey(contract.file, contract.exportName));
+        if (contractId) {
+            args.addEdge({
+                kind: "exposes",
+                from: id,
+                to: contractId,
+                evidence: { file, confidence: "partial" },
+                details: { inferredFrom: "registered-route-surface" },
+            });
+        }
+    }
+}
+async function addTables(args) {
+    const schemaSources = args.workspace.config.database.schemaSources;
+    const infraDir = directoryPath(path.dirname(args.workspace.config.paths.portWiring));
+    const schemaPrefix = `${infraDir}/db/schema/`;
+    const files = args.workspace.files.filter((file) => isTypeScriptSource(file) &&
+        (file.startsWith(schemaPrefix) ||
+            schemaSources.some((source) => file.startsWith(staticPathPrefix(source)))));
+    for (const file of files) {
+        const sourceFile = await args.workspace.readSourceFile(file);
+        for (const { exportName, declaration } of exportedVariableDeclarations(sourceFile)) {
+            const call = declaration.initializer
+                ? findCall(declaration.initializer, new Set(["sqliteTable", "pgTable", "mysqlTable"]))
+                : undefined;
+            const tableName = call ? literalText(call.arguments[0]) : undefined;
+            if (!call || !tableName)
+                continue;
+            args.addNode({
+                id: `table:${tableName}`,
+                kind: "table",
+                name: tableName,
+                runtimeName: tableName,
+                source: await args.sourceIndex.sourceLocation(file, declaration, exportName),
+                status: "declared",
+                details: { dialect: callMemberName(call) },
+            });
+        }
+    }
+}
+async function addFeatureDependencies(args) {
+    const dependencies = new Map();
+    for (const file of args.workspace.files.filter(isTypeScriptSource)) {
+        const from = featureForFile(file, args.featuresPath);
+        if (!from || !args.featureNames.has(from))
+            continue;
+        for (const reference of await localImportReferences(args.workspace, file)) {
+            const to = featureForFile(reference.resolvedFile, args.featuresPath);
+            if (!to || to === from || !args.featureNames.has(to))
+                continue;
+            const key = `${from}->${to}`;
+            const current = dependencies.get(key) ?? {
+                from,
+                to,
+                file,
+                line: reference.line,
+                column: reference.column,
+                valueImports: 0,
+                typeImports: 0,
+                files: new Set(),
+            };
+            if (reference.kind === "type")
+                current.typeImports += 1;
+            else
+                current.valueImports += 1;
+            current.files.add(file);
+            dependencies.set(key, current);
+        }
+    }
+    for (const dependency of dependencies.values()) {
+        args.addEdge({
+            kind: "depends-on",
+            from: featureId(dependency.from),
+            to: featureId(dependency.to),
+            evidence: {
+                file: dependency.file,
+                line: dependency.line,
+                column: dependency.column,
+                confidence: "exact",
+            },
+            details: {
+                valueImports: dependency.valueImports,
+                typeImports: dependency.typeImports,
+                files: [...dependency.files].sort(),
+            },
+        });
+    }
+}
+async function registryRecord(args) {
+    const initializer = args.declaration.initializer;
+    if (!initializer)
+        return undefined;
+    const values = registryValues(initializer, args.exportName);
+    if (!values)
+        return undefined;
+    const feature = featureForFile(args.file, directoryPath(args.workspace.config.paths.features));
+    return {
+        file: args.file,
+        declaration: args.declaration,
+        values,
+        node: {
+            id: registryId(args.file, args.exportName),
+            kind: "registry",
+            name: args.exportName,
+            ...(feature ? { feature } : {}),
+            source: await args.sourceIndex.sourceLocation(args.file, args.declaration, args.exportName),
+            status: "registered",
+        },
+    };
+}
+function registryValues(initializer, exportName) {
+    const expression = unwrapExpression(initializer);
+    if (ts.isArrayLiteralExpression(expression) && isRegistryName(exportName)) {
+        return arrayExpressions(expression);
+    }
+    if (!ts.isCallExpression(expression))
+        return undefined;
+    const name = callMemberName(expression);
+    if (name === "defineTasks" ||
+        name === "defineNotificationRegistry" ||
+        name === "defineAgentCapabilityRegistry") {
+        const first = expression.arguments[0];
+        return first && ts.isArrayLiteralExpression(unwrapExpression(first))
+            ? arrayExpressions(unwrapExpression(first))
+            : [];
+    }
+    if (name === "defineOutboxRegistry" &&
+        ts.isObjectLiteralExpression(expression.arguments[0])) {
+        const object = expression.arguments[0];
+        return ["events", "jobs"].flatMap((property) => {
+            const value = propertyAssignment(object, property)?.initializer;
+            return value && ts.isArrayLiteralExpression(unwrapExpression(value))
+                ? arrayExpressions(unwrapExpression(value))
+                : [];
+        });
+    }
+    if (name === "defineUploads" &&
+        ts.isObjectLiteralExpression(expression.arguments[0])) {
+        return expression.arguments[0].properties.flatMap((property) => ts.isPropertyAssignment(property) ? [property.initializer] : []);
+    }
+    return undefined;
+}
+function arrayExpressions(array) {
+    return array.elements.flatMap((element) => {
+        if (ts.isSpreadElement(element))
+            return [element.expression];
+        return ts.isExpression(element) ? [element] : [];
+    });
+}
+function collectTypeProperties(type, aliases, visited = new Set()) {
+    if (ts.isTypeLiteralNode(type)) {
+        return type.members.filter(ts.isPropertySignature);
+    }
+    if (ts.isIntersectionTypeNode(type)) {
+        return type.types.flatMap((member) => collectTypeProperties(member, aliases, visited));
+    }
+    if (ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName)) {
+        const name = type.typeName.text;
+        if (visited.has(name))
+            return [];
+        const target = aliases.get(name);
+        if (!target)
+            return [];
+        visited.add(name);
+        return collectTypeProperties(target, aliases, visited);
+    }
+    return [];
+}
+async function readPortBindings(workspace) {
+    const result = { bound: new Set(), deferred: new Set() };
+    const file = workspace.config.paths.portWiring;
+    if (!workspace.fileSet.has(file))
+        return result;
+    const sourceFile = await workspace.readSourceFile(file);
+    visitCalls(sourceFile, (call) => {
+        const object = call.arguments.find(ts.isObjectLiteralExpression);
+        if (!object?.properties.some((property) => property.name !== undefined &&
+            propertyName(property.name) === "bound")) {
+            return;
+        }
+        const bound = propertyAssignment(object, "bound")?.initializer;
+        if (bound && ts.isObjectLiteralExpression(bound)) {
+            for (const property of bound.properties) {
+                const name = property.name ? propertyName(property.name) : undefined;
+                if (name)
+                    result.bound.add(name);
+            }
+        }
+        const deferred = propertyAssignment(object, "deferred")?.initializer;
+        if (deferred && ts.isArrayLiteralExpression(deferred)) {
+            for (const element of deferred.elements) {
+                const name = literalText(element);
+                if (name)
+                    result.deferred.add(name);
+            }
+        }
+    });
+    return result;
+}
+function discoverFeatureNames(workspace, featuresPath) {
+    const names = new Set();
+    const prefix = `${featuresPath}/`;
+    for (const file of workspace.files) {
+        if (!file.startsWith(prefix))
+            continue;
+        const feature = file.slice(prefix.length).split("/")[0];
+        if (feature && feature !== "shared")
+            names.add(feature);
+    }
+    return [...names].sort();
+}
+function filesForFeature(files, featuresPath, feature) {
+    const prefix = `${featuresPath}/${feature}/`;
+    return files.filter((file) => file.startsWith(prefix));
+}
+function summarizeFeatureFiles(files) {
+    return {
+        files: files.length,
+        client: files.filter((file) => file.includes("/client/")).length,
+        components: files.filter((file) => file.includes("/components/")).length,
+        domain: files.filter((file) => file.includes("/domain/")).length,
+        tests: files.filter(isTestFile).length,
+    };
+}
+function featureForFile(file, featuresPath) {
+    const prefix = `${featuresPath}/`;
+    if (!file.startsWith(prefix))
+        return undefined;
+    const feature = file.slice(prefix.length).split("/")[0];
+    return feature && feature !== "shared" ? feature : undefined;
+}
+async function portFeature(type, file, featuresPath, sourceIndex) {
+    if (!type ||
+        !ts.isTypeReferenceNode(type) ||
+        !ts.isIdentifier(type.typeName)) {
+        return undefined;
+    }
+    const target = await sourceIndex.resolveName(file, type.typeName.text);
+    return target
+        ? featureForFile(target.file, directoryPath(featuresPath))
+        : undefined;
+}
+function definitionStatus(kind, file, exportName, diagnostics) {
+    const codes = {
+        listener: ["BEIGNET_LISTENER_UNREGISTERED"],
+        schedule: ["BEIGNET_SCHEDULE_UNREGISTERED"],
+        task: ["BEIGNET_TASK_UNREGISTERED"],
+        event: ["BEIGNET_OUTBOX_EVENT_UNREGISTERED"],
+        job: ["BEIGNET_OUTBOX_JOB_UNREGISTERED"],
+    };
+    const relevant = codes[kind];
+    if (!relevant)
+        return "declared";
+    return diagnostics.some((diagnostic) => relevant.includes(diagnostic.code) &&
+        diagnostic.message.includes(file) &&
+        diagnostic.message.includes(exportName))
+        ? "missing"
+        : "registered";
+}
+function definitionRuntimeName(callName, call) {
+    if (callName !== "defineNotificationDeliveryJob") {
+        return literalText(call.arguments[0]);
+    }
+    const options = call.arguments[0];
+    return options && ts.isObjectLiteralExpression(options)
+        ? (literalText(propertyAssignment(options, "name")?.initializer) ??
+            "notifications.deliver")
+        : "notifications.deliver";
+}
+function findCall(node, names) {
+    if (!node)
+        return undefined;
+    let found;
+    visitCalls(node, (call) => {
+        if (!found && names.has(callMemberName(call) ?? ""))
+            found = call;
+    });
+    return found;
+}
+function callMemberName(call) {
+    if (ts.isIdentifier(call.expression))
+        return call.expression.text;
+    if (ts.isPropertyAccessExpression(call.expression)) {
+        return call.expression.name.text;
+    }
+    return undefined;
+}
+function unwrapExpression(expression) {
+    if (ts.isAsExpression(expression) ||
+        ts.isTypeAssertionExpression(expression) ||
+        ts.isParenthesizedExpression(expression) ||
+        ts.isSatisfiesExpression(expression)) {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+}
+function isRegistryName(name) {
+    return (["listeners", "schedules", "tasks", "events", "jobs"].includes(name) ||
+        /(Events|Jobs|Listeners|Schedules|Tasks)$/.test(name));
+}
+function registryId(file, exportName) {
+    return `registry:${file}#${exportName}`;
+}
+function registryIdForReference(reference) {
+    return registryId(reference.file, reference.exportName);
+}
+function featureId(feature) {
+    return `feature:${feature}`;
+}
+function abilityId(ability) {
+    return `ability:${ability}`;
+}
+function portId(port) {
+    return `port:${port}`;
+}
+function symbolKey(file, exportName) {
+    return `${file}#${exportName}`;
+}
+function sourceKey(source) {
+    return `${source.file}#${source.exportName ?? ""}`;
+}
+function exactEdge(kind, from, to, file) {
+    return { kind, from, to, evidence: { file, confidence: "exact" } };
+}
+async function nodeEdge(kind, from, to, file, node, workspace) {
+    const sourceFile = await workspace.readSourceFile(file);
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    return {
+        kind,
+        from,
+        to,
+        evidence: {
+            file,
+            line: position.line + 1,
+            column: position.character + 1,
+            confidence: "exact",
+        },
+    };
+}
+function sourceNodeEdge(kind, from, to, file, node) {
+    const sourceFile = node.getSourceFile();
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    return {
+        kind,
+        from,
+        to,
+        evidence: {
+            file,
+            line: position.line + 1,
+            column: position.character + 1,
+            confidence: "exact",
+        },
+    };
+}
+function isTestFile(file) {
+    return /\.(test|spec)\.(ts|tsx|mts|cts)$/.test(file);
+}
+function isTypeScriptSource(file) {
+    return /\.(ts|tsx|mts|cts)$/.test(file) && !file.endsWith(".d.ts");
+}
+function staticPathPrefix(pattern) {
+    const wildcard = pattern.search(/[?*[{]/);
+    return wildcard === -1 ? pattern : pattern.slice(0, wildcard);
+}
+function uniqueValue(values) {
+    return values?.length === 1 ? values[0] : undefined;
+}
+function summarize(nodes, doctor, lint, unresolved) {
+    const count = (kind) => nodes.filter((node) => node.kind === kind).length;
+    return {
+        features: count("feature"),
+        contracts: count("contract"),
+        routes: count("route"),
+        useCases: count("use-case"),
+        workflows: nodes.filter((node) => workflowKinds.has(node.kind)).length,
+        ports: count("port"),
+        providers: count("provider"),
+        openApiDocuments: count("openapi"),
+        agentCapabilities: count("agent-capability"),
+        diagnostics: doctor.length + lint.length,
+        unresolved: unresolved.length,
+    };
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    return edges.filter((edge) => {
+        const key = `${edge.kind}:${edge.from}:${edge.to}:${JSON.stringify(edge.details ?? {})}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function compareNodes(left, right) {
+    return `${left.kind}:${left.id}`.localeCompare(`${right.kind}:${right.id}`);
+}
+function compareEdges(left, right) {
+    return `${left.kind}:${left.from}:${left.to}`.localeCompare(`${right.kind}:${right.from}:${right.to}`);
+}
+function formatTable(rows) {
+    const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column]?.length ?? 0)));
+    return rows
+        .map((row) => row
+        .map((cell, column) => cell.padEnd(widths[column]))
+        .join("  ")
+        .trimEnd())
+        .join("\n");
+}
+//# sourceMappingURL=app-map.js.map