@dataparade/cli 0.0.1

package/dist/src/config/validate-scan-ai.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAiInferenceCredentials = validateAiInferenceCredentials;
+exports.resolveAiMode = resolveAiMode;
+function validateAiInferenceCredentials(config) {
+    const errors = [];
+    if (!config.enableAiInference)
+        return errors;
+    const hasByok = Boolean(config.aiProvider?.trim()) &&
+        Boolean(config.aiModel?.trim()) &&
+        Boolean(config.aiApiKey?.trim());
+    const hasWorkspace = Boolean(config.workspaceApiKey?.trim());
+    if (hasByok && hasWorkspace) {
+        errors.push("ai-inference: set either SCAN_BYOK_* (your LLM provider) or DATAPARADE_WORKSPACE_API_KEY (platform AI), not both");
+        return errors;
+    }
+    if (!hasByok && !hasWorkspace) {
+        errors.push("ai-inference: LLM inference requires SCAN_BYOK_PROVIDER, SCAN_BYOK_MODEL, and SCAN_BYOK_API_KEY, or DATAPARADE_WORKSPACE_API_KEY for platform AI");
+    }
+    if (hasWorkspace && !config.cliQuotaJobId) {
+        errors.push("ai-inference: platform AI requires a quota preflight job id (pass DATAPARADE_WORKSPACE_API_KEY and ensure preflight succeeded)");
+    }
+    return errors;
+}
+function resolveAiMode(config) {
+    if (!config.enableAiInference)
+        return "none";
+    if (config.aiApiKey?.trim())
+        return "byok";
+    if (config.workspaceApiKey?.trim())
+        return "platform";
+    return "none";
+}

package/dist/src/core/pipeline/ai-orchestrator-options.d.ts

@@ -0,0 +1,6 @@
+import type { ScanConfiguration } from "../types";
+import type { AgentOrchestratorOptions } from "../../ai-enrichment/agent-orchestrator";
+export declare function buildAgentOrchestratorOptions(config: ScanConfiguration, opts: {
+    llmEnabled: boolean;
+    skipStructuralHeuristics: boolean;
+}): AgentOrchestratorOptions;

package/dist/src/core/pipeline/ai-orchestrator-options.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentOrchestratorOptions = buildAgentOrchestratorOptions;
+const validate_scan_ai_1 = require("../../config/validate-scan-ai");
+const dataparade_api_base_url_1 = require("../../platform-api/dataparade-api-base-url");
+function buildAgentOrchestratorOptions(config, opts) {
+    const aiMode = (0, validate_scan_ai_1.resolveAiMode)(config);
+    const platformProvider = process.env.SCAN_WORKER_LLM_PROVIDER?.trim() ||
+        "openai";
+    const platformModel = process.env.SCAN_WORKER_LLM_MODEL?.trim() ||
+        config.aiModel?.trim() ||
+        "gpt-4o-mini";
+    const base = {
+        provider: aiMode === "platform"
+            ? platformProvider
+            : (config.aiProvider ?? "openai"),
+        model: aiMode === "platform"
+            ? platformModel
+            : (config.aiModel ?? "gpt-4o-mini"),
+        endpoint: config.aiEndpoint,
+        apiKey: config.aiApiKey,
+        maxTokens: config.aiMaxTokens,
+        temperature: config.aiTemperature,
+        providerConcurrency: config.aiProviderConcurrency,
+        toolLoopMaxRounds: config.aiToolLoopMaxRounds,
+        toolLoopMaxFiles: config.aiToolLoopMaxFiles,
+        toolLoopMaxSearches: config.aiToolLoopMaxSearches,
+        llmEnabled: opts.llmEnabled,
+        skipStructuralHeuristics: opts.skipStructuralHeuristics,
+    };
+    if (aiMode === "platform" &&
+        config.workspaceApiKey?.trim() &&
+        config.cliQuotaJobId?.trim()) {
+        base.platformProxy = {
+            apiBaseUrl: config.platformApiBaseUrl ?? (0, dataparade_api_base_url_1.getDataparadeApiBaseUrl)(),
+            workspaceApiKey: config.workspaceApiKey.trim(),
+            jobId: config.cliQuotaJobId.trim(),
+        };
+        base.apiKey = undefined;
+        // HTTP API → Lambda integration timeout is 30s. Parallel infer calls each spin up
+        // a VPC cold start (~8–10s) plus helper latency and can exceed that limit even when
+        // the helper succeeds (client sees 503 "Service Unavailable").
+        base.providerConcurrency = 1;
+    }
+    return base;
+}

package/dist/src/core/pipeline/classifier-phase.d.ts

@@ -0,0 +1,7 @@
+import type { DetectedComponent, RawFinding } from "../types";
+import type { ServiceSection } from "../sectioning/discover-service-sections";
+export interface ClassifierPhaseOptions {
+    projectName: string;
+    minimumConfidence: number;
+}
+export declare function runClassifierPhase(findings: RawFinding[], sections: ServiceSection[], options: ClassifierPhaseOptions): DetectedComponent[];

package/dist/src/core/pipeline/classifier-phase.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runClassifierPhase = runClassifierPhase;
+const classify_1 = require("../../classifier/classify");
+const enhance_1 = require("../../classifier/enhance");
+const frontend_frameworks_1 = require("../../patterns/frontend-frameworks");
+function frameworkValues(value) {
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+    }
+    return [];
+}
+function mergeUniqueStringValues(current, incoming) {
+    const existing = frameworkValues(current);
+    const merged = Array.from(new Set([...existing, ...incoming]));
+    if (merged.length === 0)
+        return current;
+    return merged;
+}
+function collapseManifestFrontendFrameworkAssets(components) {
+    if (components.length === 0)
+        return components;
+    const mainBySection = new Map();
+    for (const component of components) {
+        if (component.type !== "asset")
+            continue;
+        if (component.properties?.isMainApplication === true ||
+            component.properties?.isMainApplication === "true") {
+            const sectionId = typeof component.properties?.section_id === "string"
+                ? component.properties.section_id
+                : "";
+            if (sectionId)
+                mainBySection.set(sectionId, component);
+        }
+    }
+    const removeIds = new Set();
+    const updatesById = new Map();
+    for (const component of components) {
+        if (component.type !== "asset" || component.subType !== "api")
+            continue;
+        if (component.properties?.sourceContext !== "dependency_manifest")
+            continue;
+        const sectionId = typeof component.properties?.section_id === "string"
+            ? component.properties.section_id
+            : "";
+        if (!sectionId)
+            continue;
+        const main = mainBySection.get(sectionId);
+        if (!main || main.id === component.id)
+            continue;
+        const frameworks = frameworkValues(component.properties?.framework).filter((fw) => frontend_frameworks_1.FRONTEND_FRAMEWORK_HINTS_SET.has(fw.toLowerCase()));
+        if (frameworks.length === 0)
+            continue;
+        const currentMain = updatesById.get(main.id) ?? main;
+        const nextProps = { ...currentMain.properties };
+        nextProps.framework = mergeUniqueStringValues(nextProps.framework, frameworks);
+        nextProps.technology_stack = mergeUniqueStringValues(nextProps.technology_stack, frameworks);
+        updatesById.set(main.id, { ...currentMain, properties: nextProps });
+        removeIds.add(component.id);
+    }
+    return components
+        .filter((component) => !removeIds.has(component.id))
+        .map((component) => updatesById.get(component.id) ?? component);
+}
+function runClassifierPhase(findings, sections, options) {
+    const classified = (0, classify_1.classifyRawFindings)(findings);
+    const dedupedComponents = (0, classify_1.dedupeComponents)(classified);
+    const compactedAuthComponents = (0, classify_1.compactAuthServiceComponents)(dedupedComponents);
+    const mergedDbComponents = (0, classify_1.mergeDatabaseAssetsByType)(compactedAuthComponents);
+    const withPerSectionApplication = (0, classify_1.injectApplicationAssetsPerSectionIfMissing)(mergedDbComponents, sections, { projectName: options.projectName });
+    const withApplication = (0, classify_1.injectApplicationAssetIfMissing)(withPerSectionApplication, { projectName: options.projectName });
+    const enhanced = (0, enhance_1.enhanceComponents)(withApplication);
+    const mergedFrameworkHelpers = collapseManifestFrontendFrameworkAssets(enhanced);
+    const withSectionApiNodes = (0, classify_1.synthesizeSectionApiNodes)(mergedFrameworkHelpers);
+    return (0, classify_1.injectActorIfMissing)(withSectionApiNodes).filter((component) => component.confidence >= options.minimumConfidence);
+}

package/dist/src/core/pipeline/dataflow-phase.d.ts

@@ -0,0 +1,7 @@
+import type { DetectedComponent, DetectedDataFlow, FileInfo, RawFinding } from "../types";
+import type { ServiceSection } from "../sectioning/discover-service-sections";
+export interface DataFlowPhaseOptions {
+    enableDataFlowDetection: boolean;
+    minimumConfidence: number;
+}
+export declare function runDataFlowPhase(files: FileInfo[], components: DetectedComponent[], findings: RawFinding[], sections: ServiceSection[], options: DataFlowPhaseOptions): DetectedDataFlow[];

package/dist/src/core/pipeline/dataflow-phase.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDataFlowPhase = runDataFlowPhase;
+const data_flow_1 = require("../../data-flow");
+function runDataFlowPhase(files, components, findings, sections, options) {
+    if (!options.enableDataFlowDetection)
+        return [];
+    const flows = (0, data_flow_1.detectDataFlows)(files, components, findings, sections);
+    return flows.filter((flow) => flow.confidence >= options.minimumConfidence);
+}

package/dist/src/core/pipeline/diagram-layout/app-section-layout.d.ts

@@ -0,0 +1,7 @@
+import type { DiagramNodeSchema } from "../../schema";
+import type { ComponentByIdMap } from "./types";
+/**
+ * Monorepo app sections: actor → main app → section API → integrations;
+ * managed sub-services are positioned beside their provider hub afterward.
+ */
+export declare function applyAppSectionStackLayout(nodes: DiagramNodeSchema[], componentsById: ComponentByIdMap, sectionIds: string[]): void;

package/dist/src/core/pipeline/diagram-layout/app-section-layout.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAppSectionStackLayout = applyAppSectionStackLayout;
+const constants_1 = require("./constants");
+const section_helpers_1 = require("./section-helpers");
+/**
+ * Monorepo app sections: actor → main app → section API → integrations;
+ * managed sub-services are positioned beside their provider hub afterward.
+ */
+function applyAppSectionStackLayout(nodes, componentsById, sectionIds) {
+    const allComponents = [...componentsById.values()];
+    for (const sectionId of sectionIds) {
+        const sectionIndex = sectionIds.indexOf(sectionId);
+        const baseX = Math.max(0, sectionIndex) * constants_1.SECTION_BLOCK_WIDTH;
+        const sectionComponents = allComponents.filter((c) => (0, section_helpers_1.getSectionIdFromComponent)(c) === sectionId);
+        if ((0, section_helpers_1.sectionQualifiesForTerraformLaneLayout)(sectionComponents))
+            continue;
+        const sectionNodes = (0, section_helpers_1.filterSectionNodes)(nodes, componentsById, sectionId);
+        if (sectionNodes.length === 0)
+            continue;
+        const actors = [];
+        const mains = [];
+        const sectionApis = [];
+        const integrations = [];
+        const otherAssets = [];
+        for (const node of sectionNodes) {
+            const c = componentsById.get(node.id);
+            if (!c)
+                continue;
+            if (c.type === "actor")
+                actors.push(node);
+            else if (c.type === "asset" && (0, section_helpers_1.isMainApplicationComponent)(c)) {
+                mains.push(node);
+            }
+            else if ((0, section_helpers_1.isSectionApiNodeComponent)(c)) {
+                sectionApis.push(node);
+            }
+            else if ((0, section_helpers_1.isManagedSubserviceComponent)(c))
+                continue;
+            else if (c.type === "third_party")
+                integrations.push(node);
+            else
+                otherAssets.push(node);
+        }
+        actors.sort(section_helpers_1.sortNodesByLabel);
+        mains.sort(section_helpers_1.sortNodesByLabel);
+        sectionApis.sort(section_helpers_1.sortNodesByLabel);
+        integrations.sort(section_helpers_1.sortNodesByLabel);
+        otherAssets.sort(section_helpers_1.sortNodesByLabel);
+        const integrationColumnX = baseX + 3 * constants_1.TERRAFORM_LANE_X_STEP;
+        actors.forEach((node, i) => {
+            node.position = { x: baseX, y: i * constants_1.NODE_VERTICAL_SPACING };
+        });
+        mains.forEach((node, i) => {
+            node.position = {
+                x: baseX + constants_1.TERRAFORM_LANE_X_STEP,
+                y: i * constants_1.NODE_VERTICAL_SPACING,
+            };
+        });
+        sectionApis.forEach((node, i) => {
+            node.position = {
+                x: baseX + 2 * constants_1.TERRAFORM_LANE_X_STEP,
+                y: i * constants_1.NODE_VERTICAL_SPACING,
+            };
+        });
+        const integrationStack = [...integrations, ...otherAssets];
+        integrationStack.forEach((node, i) => {
+            node.position = {
+                x: integrationColumnX,
+                y: i * constants_1.NODE_VERTICAL_SPACING,
+            };
+        });
+    }
+}

package/dist/src/core/pipeline/diagram-layout/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const NODE_HORIZONTAL_SPACING = 350;
+export declare const NODE_VERTICAL_SPACING = 200;
+export declare const NODES_PER_ROW = 4;
+export declare const MANAGED_NODE_X_OFFSET = 320;
+export declare const MANAGED_NODE_Y_BASE_OFFSET = 40;
+/** Match {@link NODE_VERTICAL_SPACING} so managed service cards do not overlap. */
+export declare const MANAGED_NODE_Y_STEP = 200;
+/** Horizontal step between Terraform layout lanes (single-section TF scans). */
+export declare const TERRAFORM_LANE_X_STEP = 400;
+/** Horizontal space per section (TF lanes + optional managed column beside provider). */
+export declare const SECTION_BLOCK_WIDTH: number;

package/dist/src/core/pipeline/diagram-layout/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECTION_BLOCK_WIDTH = exports.TERRAFORM_LANE_X_STEP = exports.MANAGED_NODE_Y_STEP = exports.MANAGED_NODE_Y_BASE_OFFSET = exports.MANAGED_NODE_X_OFFSET = exports.NODES_PER_ROW = exports.NODE_VERTICAL_SPACING = exports.NODE_HORIZONTAL_SPACING = void 0;
+exports.NODE_HORIZONTAL_SPACING = 350;
+exports.NODE_VERTICAL_SPACING = 200;
+exports.NODES_PER_ROW = 4;
+exports.MANAGED_NODE_X_OFFSET = 320;
+exports.MANAGED_NODE_Y_BASE_OFFSET = 40;
+/** Match {@link NODE_VERTICAL_SPACING} so managed service cards do not overlap. */
+exports.MANAGED_NODE_Y_STEP = exports.NODE_VERTICAL_SPACING;
+/** Horizontal step between Terraform layout lanes (single-section TF scans). */
+exports.TERRAFORM_LANE_X_STEP = 400;
+/** Horizontal space per section (TF lanes + optional managed column beside provider). */
+exports.SECTION_BLOCK_WIDTH = Math.max(exports.NODES_PER_ROW * exports.NODE_HORIZONTAL_SPACING, 5 * exports.TERRAFORM_LANE_X_STEP + exports.MANAGED_NODE_X_OFFSET + 120);

package/dist/src/core/pipeline/diagram-layout/edge-handles.d.ts

@@ -0,0 +1,3 @@
+import type { DetectedComponent } from "../../types";
+import type { DiagramEdgeSchema } from "../../schema";
+export declare function applyDirectionalEdgeHandles(edge: DiagramEdgeSchema, sourceComponent: DetectedComponent | undefined, targetComponent: DetectedComponent | undefined): void;

package/dist/src/core/pipeline/diagram-layout/edge-handles.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDirectionalEdgeHandles = applyDirectionalEdgeHandles;
+const main_application_selection_1 = require("../../../classifier/main-application-selection");
+const component_predicates_1 = require("../../terraform/component-predicates");
+const section_helpers_1 = require("./section-helpers");
+function applyDirectionalEdgeHandles(edge, sourceComponent, targetComponent) {
+    const isProviderToManagedServiceEdge = sourceComponent?.type === "third_party" &&
+        typeof targetComponent?.properties?.managed_by_provider === "string" &&
+        targetComponent.properties.managed_by_provider === sourceComponent?.id;
+    const isProviderToModuleShellEdge = sourceComponent !== undefined &&
+        targetComponent !== undefined &&
+        (0, component_predicates_1.isTerraformProviderComponent)(sourceComponent) &&
+        (0, main_application_selection_1.isTerraformModuleCallShellAsset)(targetComponent);
+    const isHubToIntegrationEdge = sourceComponent !== undefined &&
+        targetComponent?.type === "third_party" &&
+        ((sourceComponent.type === "asset" &&
+            (0, section_helpers_1.isMainApplicationComponent)(sourceComponent)) ||
+            (0, section_helpers_1.isSectionApiNodeComponent)(sourceComponent));
+    if (isProviderToManagedServiceEdge ||
+        isProviderToModuleShellEdge ||
+        isHubToIntegrationEdge) {
+        edge.sourceHandle = "right-source";
+        edge.targetHandle = "left-target";
+    }
+}

package/dist/src/core/pipeline/diagram-layout/managed-provider-layout.d.ts

@@ -0,0 +1,3 @@
+import type { DiagramNodeSchema } from "../../schema";
+import type { ComponentByIdMap } from "./types";
+export declare function repositionManagedProviderNodes(nodes: DiagramNodeSchema[], componentsById: ComponentByIdMap): void;

package/dist/src/core/pipeline/diagram-layout/managed-provider-layout.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repositionManagedProviderNodes = repositionManagedProviderNodes;
+const constants_1 = require("./constants");
+function repositionManagedProviderNodes(nodes, componentsById) {
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    const managedByProvider = new Map();
+    for (const component of componentsById.values()) {
+        const providerId = component.properties?.managed_by_provider;
+        if (typeof providerId !== "string" || !providerId.trim())
+            continue;
+        const list = managedByProvider.get(providerId) ?? [];
+        list.push(component);
+        managedByProvider.set(providerId, list);
+    }
+    for (const [providerId, managedComponents] of managedByProvider.entries()) {
+        const providerNode = nodeById.get(providerId);
+        if (!providerNode)
+            continue;
+        const sortedManaged = [...managedComponents].sort((a, b) => {
+            const aKey = String(a.properties?.managed_service_key ?? a.name ?? "");
+            const bKey = String(b.properties?.managed_service_key ?? b.name ?? "");
+            const keyCmp = aKey.localeCompare(bKey);
+            if (keyCmp !== 0)
+                return keyCmp;
+            return a.id.localeCompare(b.id);
+        });
+        sortedManaged.forEach((managedComponent, index) => {
+            const managedNode = nodeById.get(managedComponent.id);
+            if (!managedNode)
+                return;
+            managedNode.position = {
+                x: providerNode.position.x + constants_1.MANAGED_NODE_X_OFFSET,
+                y: providerNode.position.y +
+                    constants_1.MANAGED_NODE_Y_BASE_OFFSET +
+                    index * constants_1.MANAGED_NODE_Y_STEP,
+            };
+        });
+    }
+}

package/dist/src/core/pipeline/diagram-layout/minimal-terraform-layout.d.ts

@@ -0,0 +1,6 @@
+import type { DiagramNodeSchema } from "../../schema";
+import type { ComponentByIdMap } from "./types";
+/**
+ * Minimal Terraform view: User (0) → main app + ECS shells (1) → provider (2).
+ */
+export declare function applyTerraformMinimalServiceDiagramLayout(nodes: DiagramNodeSchema[], componentsById: ComponentByIdMap): void;

package/dist/src/core/pipeline/diagram-layout/minimal-terraform-layout.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTerraformMinimalServiceDiagramLayout = applyTerraformMinimalServiceDiagramLayout;
+const terraform_minimal_services_1 = require("../terraform-minimal-services");
+const constants_1 = require("./constants");
+const section_helpers_1 = require("./section-helpers");
+/**
+ * Minimal Terraform view: User (0) → main app + ECS shells (1) → provider (2).
+ */
+function applyTerraformMinimalServiceDiagramLayout(nodes, componentsById) {
+    const actorNodes = [];
+    const mainNodes = [];
+    const ecsNodes = [];
+    const providerNodes = [];
+    for (const node of nodes) {
+        const c = componentsById.get(node.id);
+        const bucket = (0, terraform_minimal_services_1.terraformMinimalLayoutBucket)(c);
+        if (bucket === "actor")
+            actorNodes.push(node);
+        else if (bucket === "main")
+            mainNodes.push(node);
+        else if (bucket === "ecs")
+            ecsNodes.push(node);
+        else if (bucket === "provider")
+            providerNodes.push(node);
+    }
+    actorNodes.sort(section_helpers_1.sortNodesByLabel);
+    mainNodes.sort(section_helpers_1.sortNodesByLabel);
+    ecsNodes.sort(section_helpers_1.sortNodesByLabel);
+    providerNodes.sort(section_helpers_1.sortNodesByLabel);
+    actorNodes.forEach((node, i) => {
+        node.position = { x: 0 * constants_1.TERRAFORM_LANE_X_STEP, y: i * constants_1.NODE_VERTICAL_SPACING };
+    });
+    mainNodes.forEach((node, i) => {
+        node.position = {
+            x: 1 * constants_1.TERRAFORM_LANE_X_STEP,
+            y: i * constants_1.NODE_VERTICAL_SPACING,
+        };
+    });
+    const mainCount = mainNodes.length;
+    ecsNodes.forEach((node, i) => {
+        node.position = {
+            x: 1 * constants_1.TERRAFORM_LANE_X_STEP,
+            y: (mainCount + i) * constants_1.NODE_VERTICAL_SPACING,
+        };
+    });
+    providerNodes.forEach((node, i) => {
+        node.position = {
+            x: 2 * constants_1.TERRAFORM_LANE_X_STEP,
+            y: i * constants_1.NODE_VERTICAL_SPACING,
+        };
+    });
+}

package/dist/src/core/pipeline/diagram-layout/section-helpers.d.ts

@@ -0,0 +1,30 @@
+import type { DetectedComponent } from "../../types";
+import type { ComponentByIdMap } from "./types";
+export declare function getSectionIdFromComponent(component: DetectedComponent): string;
+export declare function getSectionLabelFromComponent(component: DetectedComponent): string;
+export declare function componentSortKey(component: DetectedComponent): string;
+/** Lane layout applies only to sections with Terraform resources (not every User actor). */
+export declare function sectionQualifiesForTerraformLaneLayout(sectionComponents: DetectedComponent[]): boolean;
+export declare function isMainApplicationComponent(component: DetectedComponent): boolean;
+export declare function isSectionApiNodeComponent(component: DetectedComponent): boolean;
+export declare function isManagedSubserviceComponent(component: DetectedComponent): boolean;
+export declare function sortNodesByLabel(a: {
+    id: string;
+    data?: {
+        label?: string;
+    };
+}, b: {
+    id: string;
+    data?: {
+        label?: string;
+    };
+}): number;
+export declare function filterSectionNodes(nodes: Array<{
+    id: string;
+}>, componentsById: ComponentByIdMap, sectionId: string): Array<{
+    id: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+}>;

package/dist/src/core/pipeline/diagram-layout/section-helpers.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSectionIdFromComponent = getSectionIdFromComponent;
+exports.getSectionLabelFromComponent = getSectionLabelFromComponent;
+exports.componentSortKey = componentSortKey;
+exports.sectionQualifiesForTerraformLaneLayout = sectionQualifiesForTerraformLaneLayout;
+exports.isMainApplicationComponent = isMainApplicationComponent;
+exports.isSectionApiNodeComponent = isSectionApiNodeComponent;
+exports.isManagedSubserviceComponent = isManagedSubserviceComponent;
+exports.sortNodesByLabel = sortNodesByLabel;
+exports.filterSectionNodes = filterSectionNodes;
+const component_predicates_1 = require("../../terraform/component-predicates");
+function getSectionIdFromComponent(component) {
+    const sid = component.properties?.section_id;
+    return typeof sid === "string" && sid.trim() ? sid.trim() : "<unsectioned>";
+}
+function getSectionLabelFromComponent(component) {
+    const label = component.properties?.section_label;
+    if (typeof label === "string" && label.trim())
+        return label.trim();
+    return getSectionIdFromComponent(component);
+}
+function componentSortKey(component) {
+    const managedBy = String(component.properties?.managed_by_provider ?? "");
+    const managedKey = String(component.properties?.managed_service_key ?? "");
+    if (managedBy) {
+        return `2|${managedBy}|${managedKey}|${component.name}`;
+    }
+    if (component.type === "third_party") {
+        return `1|${component.id}|${component.name}`;
+    }
+    return `0|${component.id}|${component.name}`;
+}
+/** Lane layout applies only to sections with Terraform resources (not every User actor). */
+function sectionQualifiesForTerraformLaneLayout(sectionComponents) {
+    return (0, component_predicates_1.scanHasTerraformAddress)(sectionComponents);
+}
+function isMainApplicationComponent(component) {
+    const v = component.properties?.isMainApplication;
+    return v === true || v === "true";
+}
+function isSectionApiNodeComponent(component) {
+    return (component.type === "asset" &&
+        component.subType === "api" &&
+        (component.properties?.isSectionApiNode === true ||
+            component.properties?.isSectionApiNode === "true"));
+}
+function isManagedSubserviceComponent(component) {
+    const providerId = component.properties?.managed_by_provider;
+    return typeof providerId === "string" && providerId.trim().length > 0;
+}
+function sortNodesByLabel(a, b) {
+    const la = String(a.data?.label ?? a.id);
+    const lb = String(b.data?.label ?? b.id);
+    return la.localeCompare(lb);
+}
+function filterSectionNodes(nodes, componentsById, sectionId) {
+    return nodes.filter((n) => {
+        const c = componentsById.get(n.id);
+        return c && getSectionIdFromComponent(c) === sectionId;
+    });
+}

package/dist/src/core/pipeline/diagram-layout/terraform-lane-layout.d.ts

@@ -0,0 +1,3 @@
+import type { DiagramNodeSchema } from "../../schema";
+import type { ComponentByIdMap } from "./types";
+export declare function applyTerraformLaneLayout(nodes: DiagramNodeSchema[], componentsById: ComponentByIdMap, sectionIds: string[]): void;

package/dist/src/core/pipeline/diagram-layout/terraform-lane-layout.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTerraformLaneLayout = applyTerraformLaneLayout;
+const main_application_selection_1 = require("../../../classifier/main-application-selection");
+const component_predicates_1 = require("../../terraform/component-predicates");
+const constants_1 = require("./constants");
+const section_helpers_1 = require("./section-helpers");
+/**
+ * Mixed-app Terraform root: only `provider.*` + `module.*` shells (no actor/main).
+ */
+function sectionUsesProviderHubBeforeModuleShells(sectionComponents) {
+    let hasProvider = false;
+    let hasModuleShell = false;
+    for (const c of sectionComponents) {
+        if (c.type === "actor")
+            return false;
+        if (c.type === "asset" && (0, section_helpers_1.isMainApplicationComponent)(c))
+            return false;
+        if ((0, component_predicates_1.isTerraformProviderComponent)(c))
+            hasProvider = true;
+        else if ((0, main_application_selection_1.isTerraformModuleCallShellAsset)(c))
+            hasModuleShell = true;
+    }
+    return hasProvider && hasModuleShell;
+}
+function terraformLaneTier(component, opts) {
+    if (component.type === "actor")
+        return 0;
+    if (component.type === "asset" && (0, section_helpers_1.isMainApplicationComponent)(component)) {
+        return 1;
+    }
+    if (opts?.providerBeforeModuleShells) {
+        if ((0, component_predicates_1.isTerraformProviderComponent)(component))
+            return 2;
+        if ((0, main_application_selection_1.isTerraformModuleCallShellAsset)(component))
+            return 3;
+        if (component.type === "asset")
+            return 4;
+        return undefined;
+    }
+    if ((0, main_application_selection_1.isTerraformModuleCallShellAsset)(component))
+        return 2;
+    if (component.type === "third_party")
+        return 3;
+    if (component.type === "asset")
+        return 4;
+    return undefined;
+}
+function applyTerraformLaneLayout(nodes, componentsById, sectionIds) {
+    const allComponents = [...componentsById.values()];
+    const targetSectionIds = sectionIds.length <= 1
+        ? sectionIds
+        : sectionIds.filter((sid) => {
+            const inSection = allComponents.filter((c) => (0, section_helpers_1.getSectionIdFromComponent)(c) === sid);
+            return (0, section_helpers_1.sectionQualifiesForTerraformLaneLayout)(inSection);
+        });
+    if (targetSectionIds.length === 0)
+        return;
+    for (const sectionId of targetSectionIds) {
+        const sectionIndex = sectionIds.indexOf(sectionId);
+        const baseX = Math.max(0, sectionIndex) * constants_1.SECTION_BLOCK_WIDTH;
+        const sectionNodes = nodes.filter((n) => {
+            const c = componentsById.get(n.id);
+            return c && (0, section_helpers_1.getSectionIdFromComponent)(c) === sectionId;
+        });
+        if (sectionNodes.length === 0)
+            continue;
+        const sectionComponents = sectionNodes
+            .map((n) => componentsById.get(n.id))
+            .filter((c) => Boolean(c));
+        if (!(0, section_helpers_1.sectionQualifiesForTerraformLaneLayout)(sectionComponents))
+            continue;
+        const providerBeforeModuleShells = sectionUsesProviderHubBeforeModuleShells(sectionComponents);
+        const byTier = new Map();
+        for (const node of sectionNodes) {
+            const c = componentsById.get(node.id);
+            if (!c)
+                continue;
+            const tier = terraformLaneTier(c, { providerBeforeModuleShells });
+            if (tier === undefined)
+                continue;
+            const list = byTier.get(tier) ?? [];
+            list.push(node);
+            byTier.set(tier, list);
+        }
+        const tierOrder = [0, 1, 2, 3, 4];
+        for (const tier of tierOrder) {
+            const list = byTier.get(tier);
+            if (!list)
+                continue;
+            list.sort((a, b) => {
+                const ca = componentsById.get(a.id);
+                const cb = componentsById.get(b.id);
+                const na = ca?.name ?? a.id;
+                const nb = cb?.name ?? b.id;
+                const cmp = na.localeCompare(nb);
+                if (cmp !== 0)
+                    return cmp;
+                return a.id.localeCompare(b.id);
+            });
+            list.forEach((node, idx) => {
+                node.position = {
+                    x: baseX + tier * constants_1.TERRAFORM_LANE_X_STEP,
+                    y: idx * constants_1.NODE_VERTICAL_SPACING,
+                };
+            });
+        }
+    }
+}