@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/orchestration/applicationDeploy.js

@@ -1,11 +1,11 @@
 import { success, failure } from "@fjall/generator";
-import { logger } from "@fjall/util";
-import { APPLICATION_STACKS, getApplicationDeployOrder, getApplicationStackName, getApplicationStepName, getApplicationStepId, PARALLEL_DEPLOY_GROUPS } from "../types/operations.js";
+import { logger } from "@fjall/util/logger";
+import { stubCallerIdentity } from "../types/deployment/index.js";
+import { getApplicationDeployOrder, getApplicationStackName, getApplicationStepName, getApplicationStepId } from "../types/operations.js";
 import { CdkContextBuilder } from "../services/supporting/CdkContextBuilder.js";
-import { emitProgress } from "../services/supporting/helpers.js";
-import { buildParamsContext } from "./contextHelpers.js";
+import { buildParamsContext, bootstrapOrFail } from "./contextHelpers.js";
 import { runDetectionPipeline } from "./detectionPipeline.js";
-import { detectPattern } from "../types/patternDetection.js";
+import { getParallelPhase2Stacks, deployParallelPhase, deployStackSequential, runDockerPreCompute, deployAllStacks, createBuildCallbacks } from "./applicationDeployHelpers.js";
 /**
  * Core application deployment orchestration.
  *
@@ -21,20 +21,34 @@ export async function deployApplication(params, services, operation) {
         target: operation.appName,
         path: operation.path,
         region: services.awsProvider.getRegion(),
-        callerIdentity: {
-            Account: services.awsProvider.getAccountId(),
-            Arn: "",
-            UserId: ""
-        },
-        ...buildParamsContext(params)
+        callerIdentity: stubCallerIdentity(services.awsProvider.getAccountId()),
+        ...buildParamsContext({
+            orgConfig: params.orgConfig,
+            identity: params.identity,
+            skipOidc: params.options?.skipOidc
+        })
     }, {
         verbose: options?.verbose,
         infraOnly: options?.infraOnly
     }, params.orgConfig);
+    // 1b. Resolve framework builder and run build (if applicable — runs before detection)
+    const resolved = services.frameworkRegistry.resolve({
+        appPath: operation.path
+    });
+    let plan;
+    if (resolved) {
+        plan = resolved.builder.plan({ appPath: operation.path }, resolved.detection);
+        const buildCallbacks = createBuildCallbacks(callbacks);
+        const buildResult = await resolved.builder.build(operation.path, plan, buildCallbacks, { skipBuild: options?.skipBuild, infraOnly: options?.infraOnly });
+        if (!buildResult.success) {
+            callbacks.onError?.(buildResult.error);
+            return failure(buildResult.error);
+        }
+    }
     // deployOnly: skip detection pipeline, deploy all stacks unconditionally
     if (options?.deployOnly) {
         callbacks.onLog?.("Deploy-only mode — skipping change detection", "info");
-        return deployAllStacks(params, services, operation, context, startTime);
+        return deployAllStacks(params, services, operation, context, startTime, plan);
     }
     // 2. Run detection pipeline
     callbacks.onLog?.("Analysing infrastructure…", "info");
@@ -44,6 +58,12 @@ export async function deployApplication(params, services, operation) {
         return failure(detectionResult.error);
     }
     const detection = detectionResult.data;
+    // 2b. Notify callers of detection results (resource flags, pattern, etc.)
+    // Awaited so callers can run post-detection hooks (e.g. secrets validation).
+    await callbacks.onDetectionComplete?.({
+        ...detection,
+        builderName: resolved?.builder.name ?? "unknown"
+    });
     // 3. Early exit if no differences
     if (!detection.hasDifferences && !options?.force) {
         callbacks.onLog?.("No infrastructure changes detected", "info");
@@ -54,20 +74,16 @@ export async function deployApplication(params, services, operation) {
         });
     }
     // 4. Bootstrap AWS environment
-    callbacks.onCDKBootstrap?.("bootstrapping");
-    const bootstrapResult = await services.cdkService.runCdkBootstrap(context, (chunk) => callbacks.onOutput?.(chunk));
-    if (!bootstrapResult.success) {
-        callbacks.onCDKBootstrap?.("failed");
-        const error = new Error(`Bootstrap failed: ${bootstrapResult.error}`);
-        callbacks.onError?.(error);
-        return failure(error);
-    }
-    callbacks.onCDKBootstrap?.("complete");
-    // 5. Determine deploy order
-    const deployOrder = getApplicationDeployOrder({
-        pattern: detection.pattern,
-        resources: detection.resources
-    });
+    const bsResult = await bootstrapOrFail(services, context, callbacks);
+    if (!bsResult.success)
+        return bsResult;
+    // 5. Determine deploy order (prefer plan from registry, fall back to legacy)
+    const deployOrder = plan
+        ? plan.deployOrder
+        : getApplicationDeployOrder({
+            pattern: detection.pattern,
+            resources: detection.resources
+        });
     const totalSteps = deployOrder.length;
     // 6. Deploy stacks
     const allOutputs = {};
@@ -95,14 +111,10 @@ export async function deployApplication(params, services, operation) {
             i += parallelStacks.length - 1;
             continue;
         }
-        // Docker build before Compute stack
-        if (stack === APPLICATION_STACKS.COMPUTE &&
-            detection.hasDockerfile &&
-            params.dockerProvider) {
-            const dockerResult = await runDockerBuild(params, services, operation, callbacks);
-            if (!dockerResult.success)
-                return failure(dockerResult.error);
-        }
+        // Docker operations before Compute stack
+        const dockerFailed = await runDockerPreCompute(stack, params, services, operation, callbacks, detection.hasDockerfile);
+        if (dockerFailed)
+            return dockerFailed;
         // Sequential deployment
         const deployResult = await deployStackSequential(stack, services, context, callbacks, i, totalSteps, allOutputs);
         if (!deployResult.success)
@@ -135,198 +147,3 @@ export async function deployApplication(params, services, operation) {
         durationMs: Date.now() - startTime
     });
 }
-/**
- * Identify Phase 2 stacks (Storage, Messaging, Database) that are consecutive
- * in the deploy order and have changes. Returns them for parallel deployment
- * only if there are at least 2.
- */
-function getParallelPhase2Stacks(deployOrder, currentIndex, stackChanges, force) {
-    const phase2Set = new Set(PARALLEL_DEPLOY_GROUPS.PHASE_2.stacks);
-    const candidates = [];
-    for (let j = currentIndex; j < deployOrder.length; j++) {
-        if (phase2Set.has(deployOrder[j])) {
-            candidates.push(deployOrder[j]);
-        }
-        else {
-            break;
-        }
-    }
-    if (candidates.length < 2)
-        return [];
-    // Only include stacks that actually have changes (unless forced)
-    if (!force) {
-        const withChanges = candidates.filter((stack) => {
-            // stackChanges is keyed by full stack name but we only have the type here;
-            // since we don't know the app name, check all entries ending with the stack type
-            for (const [key, changed] of stackChanges) {
-                if (key.endsWith(stack) && !changed)
-                    return false;
-            }
-            return true;
-        });
-        return withChanges.length >= 2 ? withChanges : [];
-    }
-    return candidates;
-}
-/**
- * Deploy a group of stacks in parallel, reporting step events for each.
- */
-async function deployParallelPhase(stacks, operation, services, context, callbacks, startIndex, totalSteps, detection, allOutputs, deployedHashes) {
-    // Emit step start for each parallel stack
-    for (let k = 0; k < stacks.length; k++) {
-        const stack = stacks[k];
-        const stepId = getApplicationStepId(stack, "deploy");
-        const stepName = getApplicationStepName(stack, "deploy");
-        callbacks.onStepStart?.(stepId, stepName, startIndex + k, totalSteps);
-    }
-    emitProgress(callbacks, "Deploying infrastructure in parallel…");
-    const parallelResult = await services.stackService.deployStacksInParallel(stacks, context, {
-        onOutput: (chunk) => callbacks.onOutput?.(chunk),
-        onResourceProgress: (event) => callbacks.onResourceProgress?.(event),
-        onStackComplete: (stack, stackSuccess, _duration, error) => {
-            const stepId = getApplicationStepId(stack, "deploy");
-            const stepName = getApplicationStepName(stack, "deploy");
-            const idx = startIndex + stacks.indexOf(stack);
-            callbacks.onStepComplete?.(stepId, stepName, stackSuccess ? "completed" : "error", idx, totalSteps);
-            if (!stackSuccess && error) {
-                callbacks.onError?.(error);
-            }
-        }
-    });
-    if (!parallelResult.success) {
-        return failure(parallelResult.error);
-    }
-    // Check for any failures
-    const failures = parallelResult.data.filter((r) => !r.success);
-    if (failures.length > 0) {
-        const failedStacks = failures.map((f) => f.stack).join(", ");
-        const errorDetails = failures
-            .map((f) => `${f.stack}: ${f.error?.message ?? "Unknown error"}`)
-            .join("\n");
-        return failure(new Error(`Failed to deploy stacks: ${failedStacks}\n\n${errorDetails}`));
-    }
-    // Collect outputs and track hashes for successful parallel stacks
-    for (const result of parallelResult.data) {
-        if (result.success && result.outputs) {
-            for (const [key, value] of Object.entries(result.outputs)) {
-                allOutputs[key] = String(value);
-            }
-        }
-        const stackName = getApplicationStackName(operation.appName, result.stack);
-        const hash = detection.currentHashes.get(stackName);
-        if (hash) {
-            deployedHashes.set(stackName, hash);
-        }
-    }
-    return success(undefined);
-}
-/**
- * Run Docker build and push before deploying the Compute stack.
- * Initialises ECR if needed, then builds and pushes the image.
- */
-async function runDockerBuild(params, services, operation, callbacks) {
-    const dockerProvider = params.dockerProvider;
-    if (!dockerProvider)
-        return success(undefined);
-    const accountId = services.awsProvider.getAccountId();
-    if (!accountId) {
-        callbacks.onLog?.("Skipping Docker build — account ID not available", "warn");
-        return success(undefined);
-    }
-    const region = services.awsProvider.getRegion();
-    // Initialise ECR repository (non-fatal — CDK creates it if needed)
-    callbacks.onLog?.("Initialising ECR repository…", "info");
-    const ecrResult = await dockerProvider.initialiseECR({
-        appName: operation.appName,
-        region,
-        accountId
-    });
-    if (!ecrResult.success) {
-        callbacks.onLog?.(`ECR initialisation failed: ${ecrResult.error.message}`, "warn");
-    }
-    // Build and push Docker image
-    callbacks.onLog?.("Building and pushing Docker image…", "info");
-    const buildResult = await dockerProvider.buildAndPush({
-        appName: operation.appName,
-        appPath: operation.path,
-        region,
-        accountId
-    });
-    if (!buildResult.success) {
-        callbacks.onError?.(buildResult.error);
-        return failure(buildResult.error);
-    }
-    callbacks.onLog?.(`Docker image pushed: ${buildResult.data.imageUri}`, "info");
-    return success(undefined);
-}
-/**
- * Deploy a single stack with step lifecycle events and output collection.
- */
-async function deployStackSequential(stack, services, context, callbacks, stepIndex, totalSteps, allOutputs) {
-    const stepId = getApplicationStepId(stack, "deploy");
-    const stepName = getApplicationStepName(stack, "deploy");
-    callbacks.onStepStart?.(stepId, stepName, stepIndex, totalSteps);
-    const result = await services.stackService.deployStack(stack, context, {
-        onOutput: (chunk) => callbacks.onOutput?.(chunk),
-        onResourceProgress: (event) => callbacks.onResourceProgress?.(event)
-    });
-    if (!result.success) {
-        callbacks.onStepComplete?.(stepId, stepName, "error", stepIndex, totalSteps);
-        callbacks.onError?.(result.error);
-        return failure(result.error);
-    }
-    callbacks.onStepComplete?.(stepId, stepName, "completed", stepIndex, totalSteps);
-    if (result.data.outputs) {
-        for (const [key, value] of Object.entries(result.data.outputs)) {
-            allOutputs[key] = String(value);
-        }
-    }
-    return success(undefined);
-}
-/**
- * Deploy all stacks unconditionally (deployOnly mode).
- * Skips CDK synth/hash comparison — uses filesystem pattern detection only
- * to determine deploy order, then deploys every stack sequentially.
- */
-async function deployAllStacks(params, services, operation, context, startTime) {
-    const { callbacks } = params;
-    // Lightweight pattern detection (filesystem only, no CDK synth)
-    const { pattern } = detectPattern(operation.path);
-    const deployOrder = getApplicationDeployOrder({ pattern });
-    const totalSteps = deployOrder.length;
-    // Bootstrap
-    callbacks.onCDKBootstrap?.("bootstrapping");
-    const bootstrapResult = await services.cdkService.runCdkBootstrap(context, (chunk) => callbacks.onOutput?.(chunk));
-    if (!bootstrapResult.success) {
-        callbacks.onCDKBootstrap?.("failed");
-        const error = new Error(`Bootstrap failed: ${bootstrapResult.error}`);
-        callbacks.onError?.(error);
-        return failure(error);
-    }
-    callbacks.onCDKBootstrap?.("complete");
-    // Deploy all stacks sequentially
-    const allOutputs = {};
-    for (let i = 0; i < deployOrder.length; i++) {
-        const stack = deployOrder[i];
-        // Docker build before Compute stack
-        if (stack === APPLICATION_STACKS.COMPUTE && params.dockerProvider) {
-            const dockerResult = await runDockerBuild(params, services, operation, callbacks);
-            if (!dockerResult.success)
-                return failure(dockerResult.error);
-        }
-        const deployResult = await deployStackSequential(stack, services, context, callbacks, i, totalSteps, allOutputs);
-        if (!deployResult.success)
-            return failure(deployResult.error);
-    }
-    // Resolve website URL
-    const websiteUrl = await services.stackService.resolveWebsiteUrl(operation.appName);
-    if (websiteUrl) {
-        allOutputs.websiteUrl = websiteUrl;
-    }
-    return success({
-        target: operation.appName,
-        deploymentType: "application",
-        outputs: Object.keys(allOutputs).length > 0 ? allOutputs : undefined,
-        durationMs: Date.now() - startTime
-    });
-}

package/dist/src/orchestration/applicationDeployHelpers.d.ts

@@ -0,0 +1,39 @@
+import { type Result } from "@fjall/generator";
+import type { DeployParams, DeployResult } from "../types/params.js";
+import type { DeploymentContext } from "../types/deployment/DeploymentTypes.js";
+import type { DeployCallbacks } from "../types/callbacks.js";
+import type { ApplicationOperation, ApplicationStack } from "../types/operations.js";
+import type { DeployServices } from "./serviceFactory.js";
+import type { DetectionResult } from "./detectionPipeline.js";
+import type { BuildCallbacks, BuildPlan } from "../types/frameworkBuilder.js";
+/**
+ * Identify Phase 2 stacks (Storage, Messaging, Database) that are consecutive
+ * in the deploy order and have changes. Returns them for parallel deployment
+ * only if there are at least 2.
+ */
+export declare function getParallelPhase2Stacks(deployOrder: readonly ApplicationStack[], currentIndex: number, stackChanges: Map<string, boolean>, force?: boolean): ApplicationStack[];
+/**
+ * Deploy a group of stacks in parallel, reporting step events for each.
+ */
+export declare function deployParallelPhase(stacks: ApplicationStack[], operation: ApplicationOperation, services: DeployServices, context: DeploymentContext, callbacks: DeployCallbacks, startIndex: number, totalSteps: number, detection: DetectionResult, allOutputs: Record<string, string>, deployedHashes: Map<string, string>): Promise<Result<void>>;
+/**
+ * Deploy a single stack with step lifecycle events and output collection.
+ */
+export declare function deployStackSequential(stack: ApplicationStack, services: DeployServices, context: DeploymentContext, callbacks: DeployCallbacks, stepIndex: number, totalSteps: number, allOutputs: Record<string, string>): Promise<Result<void>>;
+/**
+ * Run Docker build/push or welcome image setup before the Compute stack.
+ * Returns a failure Result if Docker operations fail, or null if not applicable/successful.
+ */
+export declare function runDockerPreCompute(stack: ApplicationStack, params: DeployParams, services: DeployServices, operation: ApplicationOperation, callbacks: DeployCallbacks, hasDockerfileOnDisk: boolean): Promise<Result<DeployResult> | null>;
+/**
+ * Deploy all stacks unconditionally (deployOnly mode).
+ * Skips CDK synth/hash comparison — uses the framework registry to determine
+ * deploy order, then deploys every stack sequentially.
+ */
+export declare function deployAllStacks(params: DeployParams, services: DeployServices, operation: ApplicationOperation, context: DeploymentContext, startTime: number, plan?: BuildPlan): Promise<Result<DeployResult>>;
+/**
+ * Bridge DeployCallbacks to BuildCallbacks.
+ * Fires both legacy OpenNext-specific callbacks and generic build callbacks
+ * for backwards compatibility during the transition period.
+ */
+export declare function createBuildCallbacks(callbacks: DeployCallbacks): BuildCallbacks;

package/dist/src/orchestration/applicationDeployHelpers.js

@@ -0,0 +1,223 @@
+import { success, failure } from "@fjall/generator";
+import { APPLICATION_STACKS, getApplicationDeployOrder, getApplicationStackName, getApplicationStepName, getApplicationStepId, PARALLEL_DEPLOY_GROUPS } from "../types/operations.js";
+import { emitProgress } from "../services/supporting/helpers.js";
+import { bootstrapOrFail, forwardOutput, forwardResourceProgress } from "./contextHelpers.js";
+import { hasDockerfile } from "../util/dockerfileDetection.js";
+import { runDockerBuild } from "./dockerBuildHelper.js";
+import { runWelcomeImageSetup } from "./welcomeImageHelper.js";
+/**
+ * Identify Phase 2 stacks (Storage, Messaging, Database) that are consecutive
+ * in the deploy order and have changes. Returns them for parallel deployment
+ * only if there are at least 2.
+ */
+export function getParallelPhase2Stacks(deployOrder, currentIndex, stackChanges, force) {
+    const phase2Set = new Set(PARALLEL_DEPLOY_GROUPS.PHASE_2.stacks);
+    const candidates = [];
+    for (let j = currentIndex; j < deployOrder.length; j++) {
+        if (phase2Set.has(deployOrder[j])) {
+            candidates.push(deployOrder[j]);
+        }
+        else {
+            break;
+        }
+    }
+    if (candidates.length < 2)
+        return [];
+    // Only include stacks that actually have changes (unless forced)
+    if (!force) {
+        const withChanges = candidates.filter((stack) => {
+            // stackChanges is keyed by full stack name but we only have the type here;
+            // since we don't know the app name, check all entries ending with the stack type
+            for (const [key, changed] of stackChanges) {
+                if (key.endsWith(stack) && !changed)
+                    return false;
+            }
+            return true;
+        });
+        return withChanges.length >= 2 ? withChanges : [];
+    }
+    return candidates;
+}
+/**
+ * Deploy a group of stacks in parallel, reporting step events for each.
+ */
+export async function deployParallelPhase(stacks, operation, services, context, callbacks, startIndex, totalSteps, detection, allOutputs, deployedHashes) {
+    // Emit step start for each parallel stack
+    for (let k = 0; k < stacks.length; k++) {
+        const stack = stacks[k];
+        const stepId = getApplicationStepId(stack, "deploy");
+        const stepName = getApplicationStepName(stack, "deploy");
+        callbacks.onStepStart?.(stepId, stepName, startIndex + k, totalSteps);
+    }
+    emitProgress(callbacks, "Deploying infrastructure in parallel…");
+    callbacks.onParallelPhaseStart?.(stacks, "Storage and database resources (parallel)");
+    const parallelResult = await services.stackService.deployStacksInParallel(stacks, context, {
+        onOutput: forwardOutput(callbacks),
+        onResourceProgress: (event, stackId) => {
+            callbacks.onResourceProgress?.(event);
+            if (stackId) {
+                callbacks.onParallelStackResourceProgress?.(stackId, event);
+            }
+        },
+        onStackComplete: (stack, stackSuccess, _duration, error) => {
+            const stepId = getApplicationStepId(stack, "deploy");
+            const stepName = getApplicationStepName(stack, "deploy");
+            const idx = startIndex + stacks.indexOf(stack);
+            callbacks.onStepComplete?.(stepId, stepName, stackSuccess ? "completed" : "error", idx, totalSteps);
+            if (!stackSuccess && error) {
+                callbacks.onError?.(error);
+            }
+        }
+    });
+    if (!parallelResult.success) {
+        callbacks.onParallelPhaseComplete?.([]);
+        return failure(parallelResult.error);
+    }
+    // Check for any failures
+    const failures = parallelResult.data.filter((r) => !r.success);
+    callbacks.onParallelPhaseComplete?.(parallelResult.data.map((r) => ({
+        stack: r.stack,
+        success: r.success,
+        error: r.error
+    })));
+    if (failures.length > 0) {
+        const failedStacks = failures.map((f) => f.stack).join(", ");
+        const errorDetails = failures
+            .map((f) => `${f.stack}: ${f.error?.message ?? "Unknown error"}`)
+            .join("\n");
+        return failure(new Error(`Failed to deploy stacks: ${failedStacks}\n\n${errorDetails}`));
+    }
+    // Collect outputs and track hashes for successful parallel stacks
+    for (const result of parallelResult.data) {
+        if (result.success && result.outputs) {
+            for (const [key, value] of Object.entries(result.outputs)) {
+                allOutputs[key] = String(value);
+            }
+        }
+        const stackName = getApplicationStackName(operation.appName, result.stack);
+        const hash = detection.currentHashes.get(stackName);
+        if (hash) {
+            deployedHashes.set(stackName, hash);
+        }
+    }
+    return success(undefined);
+}
+/**
+ * Deploy a single stack with step lifecycle events and output collection.
+ */
+export async function deployStackSequential(stack, services, context, callbacks, stepIndex, totalSteps, allOutputs) {
+    const stepId = getApplicationStepId(stack, "deploy");
+    const stepName = getApplicationStepName(stack, "deploy");
+    callbacks.onStepStart?.(stepId, stepName, stepIndex, totalSteps);
+    const result = await services.stackService.deployStack(stack, context, {
+        onOutput: forwardOutput(callbacks),
+        onResourceProgress: forwardResourceProgress(callbacks)
+    });
+    if (!result.success) {
+        callbacks.onStepComplete?.(stepId, stepName, "error", stepIndex, totalSteps);
+        callbacks.onError?.(result.error);
+        return failure(result.error);
+    }
+    callbacks.onStepComplete?.(stepId, stepName, "completed", stepIndex, totalSteps);
+    if (result.data.outputs) {
+        for (const [key, value] of Object.entries(result.data.outputs)) {
+            allOutputs[key] = String(value);
+        }
+    }
+    return success(undefined);
+}
+/**
+ * Run Docker build/push or welcome image setup before the Compute stack.
+ * Returns a failure Result if Docker operations fail, or null if not applicable/successful.
+ */
+export async function runDockerPreCompute(stack, params, services, operation, callbacks, hasDockerfileOnDisk) {
+    if (stack !== APPLICATION_STACKS.COMPUTE || !params.dockerProvider)
+        return null;
+    if (hasDockerfileOnDisk) {
+        const dockerResult = await runDockerBuild(params, services, operation, callbacks);
+        if (!dockerResult.success)
+            return failure(dockerResult.error);
+    }
+    else {
+        const ecrInitResult = await runWelcomeImageSetup(params, services, operation, callbacks);
+        if (!ecrInitResult.success)
+            return failure(ecrInitResult.error);
+    }
+    return null;
+}
+/**
+ * Deploy all stacks unconditionally (deployOnly mode).
+ * Skips CDK synth/hash comparison — uses the framework registry to determine
+ * deploy order, then deploys every stack sequentially.
+ */
+export async function deployAllStacks(params, services, operation, context, startTime, plan) {
+    const { callbacks } = params;
+    // Use plan from registry if available, otherwise resolve now
+    let deployOrder;
+    if (plan) {
+        deployOrder = plan.deployOrder;
+    }
+    else {
+        const resolved = services.frameworkRegistry.resolve({
+            appPath: operation.path
+        });
+        if (resolved) {
+            const freshPlan = resolved.builder.plan({ appPath: operation.path }, resolved.detection);
+            deployOrder = freshPlan.deployOrder;
+        }
+        else {
+            deployOrder = getApplicationDeployOrder();
+        }
+    }
+    const totalSteps = deployOrder.length;
+    // Bootstrap
+    const bsResult = await bootstrapOrFail(services, context, callbacks);
+    if (!bsResult.success)
+        return bsResult;
+    // Deploy all stacks sequentially
+    const allOutputs = {};
+    for (let i = 0; i < deployOrder.length; i++) {
+        const stack = deployOrder[i];
+        // Docker operations before Compute stack
+        const dockerFailed = await runDockerPreCompute(stack, params, services, operation, callbacks, hasDockerfile(operation.path));
+        if (dockerFailed)
+            return dockerFailed;
+        const deployResult = await deployStackSequential(stack, services, context, callbacks, i, totalSteps, allOutputs);
+        if (!deployResult.success)
+            return failure(deployResult.error);
+    }
+    // Resolve website URL
+    const websiteUrl = await services.stackService.resolveWebsiteUrl(operation.appName);
+    if (websiteUrl) {
+        allOutputs.websiteUrl = websiteUrl;
+    }
+    return success({
+        target: operation.appName,
+        deploymentType: "application",
+        outputs: Object.keys(allOutputs).length > 0 ? allOutputs : undefined,
+        durationMs: Date.now() - startTime
+    });
+}
+/**
+ * Bridge DeployCallbacks to BuildCallbacks.
+ * Fires both legacy OpenNext-specific callbacks and generic build callbacks
+ * for backwards compatibility during the transition period.
+ */
+export function createBuildCallbacks(callbacks) {
+    return {
+        onBuildStart: (builderName) => {
+            callbacks.onOpenNextBuildStart?.();
+            callbacks.onLog?.(`${builderName} build started`, "info");
+        },
+        onBuildProgress: (_builderName, message) => {
+            callbacks.onOpenNextProgress?.(message);
+        },
+        onBuildComplete: (builderName) => {
+            callbacks.onOpenNextBuildComplete?.();
+            callbacks.onLog?.(`${builderName} build complete`, "info");
+        },
+        onBuildError: (_builderName, error) => {
+            callbacks.onOpenNextBuildError?.(error);
+        }
+    };
+}

package/dist/src/orchestration/applicationDestroy.d.ts

@@ -0,0 +1,14 @@
+import { type Result } from "@fjall/generator";
+import type { DestroyParams, DestroyResult } from "../types/params.js";
+import type { ApplicationOperation } from "../types/operations.js";
+import type { DeployServices } from "./serviceFactory.js";
+/**
+ * Core application destruction orchestration.
+ *
+ * Detects application pattern, determines destroy order (reverse of deploy),
+ * then destroys stacks sequentially or in parallel groups. Delegates all
+ * CDK operations to the ApplicationStackService.destroyAllStacks() method,
+ * which handles "stack doesn't exist" → success conversion and parallel
+ * phase orchestration for OpenNext patterns.
+ */
+export declare function destroyApplication(params: DestroyParams, services: DeployServices, operation: ApplicationOperation): Promise<Result<DestroyResult>>;