@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/services/application/ApplicationStackService.d.ts

@@ -5,9 +5,18 @@ import type { ResourceEvent } from "../../types/events.js";
 import type { DeploymentContext } from "../../types/deployment/DeploymentTypes.js";
 import { type ApplicationStack } from "../../types/operations.js";
 import type { ParallelDeploymentResult } from "../../types/deployment/parallel.js";
-import { type AppResourceFlags } from "../../types/patternDetection.js";
+import type { AppResourceFlags } from "../../types/patternDetection.js";
 import { type Result } from "@fjall/generator";
 import { ApplicationError, type StackDeploymentData } from "../../types/application/ApplicationServiceTypes.js";
+interface StackCallbacks {
+    onOutput?: (chunk: string) => void;
+    onResourceProgress?: (event: ResourceEvent) => void;
+}
+interface ParallelStackCallbacks {
+    onOutput?: (chunk: string, stackId: ApplicationStack) => void;
+    onResourceProgress?: (event: ResourceEvent, stackId: ApplicationStack) => void;
+    onStackComplete?: (stack: ApplicationStack, success: boolean, duration: number, error?: Error) => void;
+}
 /**
  * Service for deploying and destroying individual CloudFormation stacks.
  *
@@ -20,33 +29,26 @@ import { ApplicationError, type StackDeploymentData } from "../../types/applicat
 export declare class ApplicationStackService {
     private cdkService;
     private cloudFormationService;
-    private aws;
-    constructor(cdkService: CdkService, cloudFormationService: CloudFormationService);
-    setAwsContext(aws: AwsProvider | undefined): void;
+    private aws?;
+    constructor(cdkService: CdkService, cloudFormationService: CloudFormationService, aws?: AwsProvider | undefined);
+    /**
+     * Delegate to CdkService.runCdkSynth — exposed for destroyAllStacks orchestration.
+     */
+    runCdkSynth(context: DeploymentContext): ReturnType<CdkService["runCdkSynth"]>;
     /**
      * Deploy a specific stack type for an application
      */
-    deployStack(stackType: ApplicationStack, context: DeploymentContext, callbacks?: {
-        onOutput?: (chunk: string) => void;
-        onResourceProgress?: (event: ResourceEvent) => void;
-    }): Promise<Result<StackDeploymentData, ApplicationError>>;
+    deployStack(stackType: ApplicationStack, context: DeploymentContext, callbacks?: StackCallbacks): Promise<Result<StackDeploymentData, ApplicationError>>;
     /**
      * Deploy multiple stacks in parallel within a deployment phase.
      *
      * Uses Promise.allSettled to ensure all stacks are attempted even if some fail.
      */
-    deployStacksInParallel(stacks: readonly ApplicationStack[], context: DeploymentContext, callbacks?: {
-        onOutput?: (chunk: string, stackId: ApplicationStack) => void;
-        onResourceProgress?: (event: ResourceEvent, stackId: ApplicationStack) => void;
-        onStackComplete?: (stack: ApplicationStack, success: boolean, duration: number, error?: Error) => void;
-    }): Promise<Result<ParallelDeploymentResult[], ApplicationError>>;
+    deployStacksInParallel(stacks: readonly ApplicationStack[], context: DeploymentContext, callbacks?: ParallelStackCallbacks): Promise<Result<ParallelDeploymentResult[], ApplicationError>>;
     /**
      * Destroy a specific stack type
      */
-    destroyStack(stackType: ApplicationStack, context: DeploymentContext, callbacks?: {
-        onOutput?: (chunk: string) => void;
-        onResourceProgress?: (event: ResourceEvent) => void;
-    }, useCdkOut?: boolean): Promise<Result<StackDeploymentData, ApplicationError>>;
+    destroyStack(stackType: ApplicationStack, context: DeploymentContext, callbacks?: StackCallbacks, useCdkOut?: boolean): Promise<Result<StackDeploymentData, ApplicationError>>;
     /**
      * Destroy multiple stacks in parallel within a destroy phase.
      *
@@ -54,11 +56,7 @@ export declare class ApplicationStackService {
      * be run beforehand. Multiple CDK commands cannot run in parallel because they
      * all try to synthesise to the same cdk.out directory.
      */
-    destroyStacksInParallel(stacks: readonly ApplicationStack[], context: DeploymentContext, callbacks?: {
-        onOutput?: (chunk: string, stackId: ApplicationStack) => void;
-        onResourceProgress?: (event: ResourceEvent, stackId: ApplicationStack) => void;
-        onStackComplete?: (stack: ApplicationStack, success: boolean, duration: number, error?: Error) => void;
-    }, useCdkOut?: boolean): Promise<Result<ParallelDeploymentResult[], ApplicationError>>;
+    destroyStacksInParallel(stacks: readonly ApplicationStack[], context: DeploymentContext, callbacks?: ParallelStackCallbacks, useCdkOut?: boolean): Promise<Result<ParallelDeploymentResult[], ApplicationError>>;
     /**
      * Get stack outputs for a deployed stack
      */
@@ -82,12 +80,5 @@ export declare class ApplicationStackService {
     }, resources?: AppResourceFlags): Promise<Result<{
         message: string;
     }, ApplicationError>>;
-    /**
-     * Convert "doesn't exist" errors to success for destroy operations.
-     */
-    private convertDestroyResultIfNotExists;
-    /**
-     * Handle destroy errors and determine if we should continue or fail
-     */
-    private handleDestroyError;
 }
+export {};

package/dist/src/services/application/ApplicationStackService.js

@@ -1,10 +1,10 @@
-import { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH, INFRASTRUCTURE_FILENAME } from "../../types/constants.js";
-import { APPLICATION_STACKS, getApplicationStackName, getApplicationDestroyOrder, getParallelDestroyGroups } from "../../types/operations.js";
-import { detectPattern, isOpenNextPattern } from "../../types/patternDetection.js";
-import { success, failure, isFailure } from "@fjall/generator";
+import { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH } from "../../types/constants.js";
+import { getApplicationStackName } from "../../types/operations.js";
+import { success, failure } from "@fjall/generator";
 import { ApplicationError } from "../../types/application/ApplicationServiceTypes.js";
-import { logger } from "@fjall/util";
+import { logger } from "@fjall/util/logger";
 import { convertCloudFormationOutputsToRecord } from "../supporting/helpers.js";
+import { destroyAllStacks, mapSettledResults, resolveWebsiteUrl } from "./applicationStackHelpers.js";
 /**
  * Service for deploying and destroying individual CloudFormation stacks.
  *
@@ -18,13 +18,17 @@ export class ApplicationStackService {
     cdkService;
     cloudFormationService;
     aws;
-    constructor(cdkService, cloudFormationService) {
+    constructor(cdkService, cloudFormationService, aws) {
         this.cdkService = cdkService;
         this.cloudFormationService = cloudFormationService;
-    }
-    setAwsContext(aws) {
         this.aws = aws;
     }
+    /**
+     * Delegate to CdkService.runCdkSynth — exposed for destroyAllStacks orchestration.
+     */
+    async runCdkSynth(context) {
+        return this.cdkService.runCdkSynth(context);
+    }
     /**
      * Deploy a specific stack type for an application
      */
@@ -111,20 +115,7 @@ export class ApplicationStackService {
             onStackCompleteCallback?.(stack, result.success, duration, result.success ? undefined : result.error);
             return deploymentResult;
         }));
-        const deployResults = results.map((settledResult, index) => {
-            if (settledResult.status === "fulfilled") {
-                return settledResult.value;
-            }
-            return {
-                stack: stacks[index],
-                success: false,
-                error: settledResult.reason instanceof Error
-                    ? settledResult.reason
-                    : new Error(String(settledResult.reason)),
-                duration: 0
-            };
-        });
-        return success(deployResults);
+        return success(mapSettledResults(results, stacks));
     }
     /**
      * Destroy a specific stack type
@@ -191,20 +182,7 @@ export class ApplicationStackService {
             onStackCompleteCallback?.(stack, destroyResult.success, duration, destroyResult.success ? undefined : destroyResult.error);
             return destroyResult;
         }));
-        const destroyResults = results.map((settledResult, index) => {
-            if (settledResult.status === "fulfilled") {
-                return settledResult.value;
-            }
-            return {
-                stack: stacks[index],
-                success: false,
-                error: settledResult.reason instanceof Error
-                    ? settledResult.reason
-                    : new Error(String(settledResult.reason)),
-                duration: 0
-            };
-        });
-        return success(destroyResults);
+        return success(mapSettledResults(results, stacks));
     }
     /**
      * Get stack outputs for a deployed stack
@@ -228,209 +206,13 @@ export class ApplicationStackService {
      * Checks Compute stack for LoadBalancer URL, then CDN stack for CloudFront distribution.
      */
     async resolveWebsiteUrl(appName) {
-        try {
-            const computeStackName = getApplicationStackName(appName, APPLICATION_STACKS.COMPUTE);
-            const computeOutputs = await this.cloudFormationService.getStackOutputs(computeStackName);
-            if (computeOutputs.success && computeOutputs.data.length > 0) {
-                const lbUrl = computeOutputs.data.find((o) => o.OutputKey?.includes("LoadBalancerUrl"));
-                if (lbUrl?.OutputValue) {
-                    return lbUrl.OutputValue.toLowerCase();
-                }
-                const lbDns = computeOutputs.data.find((o) => o.OutputKey?.includes("LoadBalancerDnsName"));
-                if (lbDns?.OutputValue) {
-                    return `http://${lbDns.OutputValue.toLowerCase()}`;
-                }
-            }
-            const cdnStackName = getApplicationStackName(appName, APPLICATION_STACKS.CDN);
-            const cdnOutputs = await this.cloudFormationService.getStackOutputs(cdnStackName);
-            if (cdnOutputs.success && cdnOutputs.data.length > 0) {
-                const dist = cdnOutputs.data.find((o) => o.OutputKey?.includes("DistributionDomainName"));
-                if (dist?.OutputValue) {
-                    return `https://${dist.OutputValue.toLowerCase()}`;
-                }
-            }
-            return undefined;
-        }
-        catch (error) {
-            logger.debug("ApplicationStackService", "URL resolution failed", {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return undefined;
-        }
+        return resolveWebsiteUrl(appName, this.cloudFormationService);
     }
     /**
      * Destroy all stacks for an application in reverse order.
      * Supports parallel destruction for OpenNext patterns (nextjs/payload).
      */
     async destroyAllStacks(context, callbacks, resources) {
-        const patternResult = detectPattern(context.path);
-        const pattern = patternResult.pattern;
-        const appName = context.target;
-        if (isOpenNextPattern(pattern)) {
-            const destroyGroups = getParallelDestroyGroups();
-            for (const group of destroyGroups) {
-                const stacks = group.stacks;
-                if (stacks.length === 1) {
-                    const stackType = stacks[0];
-                    const stackName = getApplicationStackName(appName, stackType);
-                    callbacks?.onStackStart?.(stackType, stackName);
-                    const result = await this.destroyStack(stackType, context, {
-                        onOutput: callbacks?.onOutput
-                            ? (chunk) => callbacks.onOutput?.(chunk, stackType)
-                            : undefined,
-                        onResourceProgress: callbacks?.onResourceProgress
-                            ? (event) => callbacks.onResourceProgress?.(event, stackType)
-                            : undefined
-                    });
-                    const finalResult = this.convertDestroyResultIfNotExists(result, stackType, appName);
-                    if (callbacks?.onStackComplete) {
-                        await callbacks.onStackComplete(stackType, finalResult);
-                    }
-                    const errorResult = this.handleDestroyError(finalResult, stackType);
-                    if (errorResult) {
-                        if (errorResult.continue)
-                            continue;
-                        return errorResult.result;
-                    }
-                }
-                else {
-                    const synthResult = await this.cdkService.runCdkSynth(context);
-                    if (!synthResult.success) {
-                        return failure(new ApplicationError(synthResult.error, {
-                            errorType: "synth_failed",
-                            appName,
-                            operation: "destroy-parallel-synth"
-                        }));
-                    }
-                    callbacks?.onParallelPhaseStart?.(stacks, group.description);
-                    for (const stackType of stacks) {
-                        callbacks?.onStackStart?.(stackType, getApplicationStackName(appName, stackType));
-                    }
-                    const parallelResult = await this.destroyStacksInParallel(stacks, context, {
-                        onOutput: callbacks?.onOutput,
-                        onResourceProgress: callbacks?.onResourceProgress,
-                        onStackComplete: async (stack, stackSuccess, _duration, error) => {
-                            const result = stackSuccess
-                                ? success({
-                                    stackName: `${appName}${stack}`,
-                                    stackType: stack,
-                                    outputs: {}
-                                })
-                                : failure(error instanceof ApplicationError
-                                    ? error
-                                    : new ApplicationError(error?.message ?? "Stack destruction failed", {
-                                        errorType: "destroy_failed",
-                                        appName,
-                                        operation: `destroy-${stack}`
-                                    }));
-                            await callbacks?.onStackComplete?.(stack, result);
-                        }
-                    }, true);
-                    if (parallelResult.success) {
-                        callbacks?.onParallelPhaseComplete?.(parallelResult.data);
-                        const failures = parallelResult.data.filter((r) => !r.success);
-                        if (failures.length > 0) {
-                            const realFailures = failures.filter((f) => f.error &&
-                                !f.error.message.includes(STACK_NOT_FOUND_PATTERN) &&
-                                !f.error.message.includes(CDK_NO_STACKS_MATCH));
-                            if (realFailures.length > 0) {
-                                const failedStacks = realFailures
-                                    .map((f) => f.stack)
-                                    .join(", ");
-                                const errorDetails = realFailures
-                                    .map((f) => `${f.stack}: ${f.error?.message || "Unknown error"}`)
-                                    .join("\n");
-                                return failure(new ApplicationError(`Failed to destroy stacks: ${failedStacks}\n\n${errorDetails}`, {
-                                    errorType: "destroy_failed",
-                                    appName,
-                                    operation: "destroy-parallel"
-                                }));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            const stackOrder = getApplicationDestroyOrder({ pattern, resources });
-            for (const stackType of stackOrder) {
-                const stackName = getApplicationStackName(appName, stackType);
-                callbacks?.onStackStart?.(stackType, stackName);
-                const result = await this.destroyStack(stackType, context, {
-                    onOutput: callbacks?.onOutput
-                        ? (chunk) => callbacks.onOutput?.(chunk, stackType)
-                        : undefined,
-                    onResourceProgress: callbacks?.onResourceProgress
-                        ? (event) => callbacks.onResourceProgress?.(event, stackType)
-                        : undefined
-                });
-                const finalResult = this.convertDestroyResultIfNotExists(result, stackType, appName);
-                if (callbacks?.onStackComplete) {
-                    await callbacks.onStackComplete(stackType, finalResult);
-                }
-                const errorResult = this.handleDestroyError(finalResult, stackType);
-                if (errorResult) {
-                    if (errorResult.continue)
-                        continue;
-                    return errorResult.result;
-                }
-            }
-        }
-        return success({ message: "All stacks destroyed" });
-    }
-    /**
-     * Convert "doesn't exist" errors to success for destroy operations.
-     */
-    convertDestroyResultIfNotExists(result, stackType, appName) {
-        if (result.success)
-            return result;
-        const errorMessage = isFailure(result) ? result.error.message : "";
-        const isAlreadyDeleted = errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
-            errorMessage.includes(CDK_NO_STACKS_MATCH);
-        if (isAlreadyDeleted) {
-            return success({
-                stackName: getApplicationStackName(appName, stackType),
-                stackType,
-                outputs: {}
-            });
-        }
-        return result;
-    }
-    /**
-     * Handle destroy errors and determine if we should continue or fail
-     */
-    handleDestroyError(result, stackType) {
-        if (result.success)
-            return null;
-        const errorMessage = isFailure(result) ? result.error.message : "";
-        if (errorMessage.includes("TSError") ||
-            errorMessage.includes("Unable to compile TypeScript") ||
-            errorMessage.includes("Subprocess exited with error")) {
-            const tsErrorMatch = errorMessage.match(/infrastructure\.ts\(\d+,\d+\): error TS\d+: .+/);
-            const errorDetail = tsErrorMatch
-                ? tsErrorMatch[0]
-                : `Check ${INFRASTRUCTURE_FILENAME} for syntax errors`;
-            return {
-                continue: false,
-                result: failure(new ApplicationError(`CDK synthesis failed: ${errorDetail}`, {
-                    errorType: "synth_failed",
-                    operation: `destroy-${stackType}`
-                }))
-            };
-        }
-        if (errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
-            errorMessage.includes(CDK_NO_STACKS_MATCH)) {
-            return {
-                continue: true,
-                result: success({ message: "Stack already deleted" })
-            };
-        }
-        return {
-            continue: false,
-            result: failure(new ApplicationError(`Failed to destroy ${stackType} stack: ${errorMessage}`, {
-                errorType: "destroy_failed",
-                operation: `destroy-${stackType}`
-            }))
-        };
+        return destroyAllStacks(this, context, callbacks, resources);
     }
 }

package/dist/src/services/application/applicationStackHelpers.d.ts

@@ -0,0 +1,46 @@
+import type { ResourceEvent } from "../../types/events.js";
+import type { DeploymentContext } from "../../types/deployment/DeploymentTypes.js";
+import { type ApplicationStack } from "../../types/operations.js";
+import type { ParallelDeploymentResult } from "../../types/deployment/parallel.js";
+import type { AppResourceFlags } from "../../types/patternDetection.js";
+import { type Result } from "@fjall/generator";
+import { ApplicationError, type StackDeploymentData } from "../../types/application/ApplicationServiceTypes.js";
+import type { ApplicationStackService } from "./ApplicationStackService.js";
+import type { CloudFormationService } from "../infrastructure/CloudFormationService.js";
+/**
+ * Convert "doesn't exist" errors to success for destroy operations.
+ */
+export declare function convertDestroyResultIfNotExists(result: Result<StackDeploymentData, ApplicationError>, stackType: ApplicationStack, appName: string): Result<StackDeploymentData, ApplicationError>;
+/**
+ * Handle destroy errors and determine if we should continue or fail
+ */
+export declare function handleDestroyError(result: Result<StackDeploymentData, ApplicationError>, stackType: ApplicationStack): {
+    continue: boolean;
+    result: Result<{
+        message: string;
+    }, ApplicationError>;
+} | null;
+/**
+ * Destroy all stacks for an application in reverse order.
+ * Supports parallel destruction for OpenNext patterns (nextjs/payload).
+ */
+export declare function destroyAllStacks(service: ApplicationStackService, context: DeploymentContext, callbacks?: {
+    onOutput?: (chunk: string, stackId?: ApplicationStack) => void;
+    onResourceProgress?: (event: ResourceEvent, stackId?: ApplicationStack) => void;
+    onStackStart?: (stackType: ApplicationStack, stackName: string) => void;
+    onStackComplete?: (stackType: ApplicationStack, result: Result<StackDeploymentData, ApplicationError>) => void | Promise<void>;
+    onParallelPhaseStart?: (stacks: readonly ApplicationStack[], description: string) => void;
+    onParallelPhaseComplete?: (results: ParallelDeploymentResult[]) => void;
+}, resources?: AppResourceFlags): Promise<Result<{
+    message: string;
+}, ApplicationError>>;
+/**
+ * Map Promise.allSettled results to ParallelDeploymentResult[], handling
+ * rejected promises with a fallback stack identity.
+ */
+export declare function mapSettledResults(settled: Array<PromiseSettledResult<ParallelDeploymentResult>>, stacks: readonly ApplicationStack[]): ParallelDeploymentResult[];
+/**
+ * Resolve the website URL for an application from CloudFormation stack outputs.
+ * Checks Compute stack for LoadBalancer URL, then CDN stack for CloudFront distribution.
+ */
+export declare function resolveWebsiteUrl(appName: string, cloudFormationService: CloudFormationService): Promise<string | undefined>;

package/dist/src/services/application/applicationStackHelpers.js

@@ -0,0 +1,248 @@
+import { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH, INFRASTRUCTURE_FILENAME } from "../../types/constants.js";
+import { APPLICATION_STACKS, getApplicationStackName, getApplicationDestroyOrder, getParallelDestroyGroups } from "../../types/operations.js";
+import { FrameworkRegistry } from "../../orchestration/builders/frameworkRegistry.js";
+import { success, failure, isFailure } from "@fjall/generator";
+import { ApplicationError } from "../../types/application/ApplicationServiceTypes.js";
+import { logger } from "@fjall/util/logger";
+/**
+ * Convert "doesn't exist" errors to success for destroy operations.
+ */
+export function convertDestroyResultIfNotExists(result, stackType, appName) {
+    if (result.success)
+        return result;
+    const errorMessage = isFailure(result) ? result.error.message : "";
+    const isAlreadyDeleted = errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
+        errorMessage.includes(CDK_NO_STACKS_MATCH);
+    if (isAlreadyDeleted) {
+        return success({
+            stackName: getApplicationStackName(appName, stackType),
+            stackType,
+            outputs: {},
+            skipped: true
+        });
+    }
+    return result;
+}
+/**
+ * Handle destroy errors and determine if we should continue or fail
+ */
+export function handleDestroyError(result, stackType) {
+    if (result.success)
+        return null;
+    const errorMessage = isFailure(result) ? result.error.message : "";
+    if (errorMessage.includes("TSError") ||
+        errorMessage.includes("Unable to compile TypeScript") ||
+        errorMessage.includes("Subprocess exited with error")) {
+        const tsErrorMatch = errorMessage.match(/infrastructure\.ts\(\d+,\d+\): error TS\d+: .+/);
+        const errorDetail = tsErrorMatch
+            ? tsErrorMatch[0]
+            : `Check ${INFRASTRUCTURE_FILENAME} for syntax errors`;
+        return {
+            continue: false,
+            result: failure(new ApplicationError(`CDK synthesis failed: ${errorDetail}`, {
+                errorType: "synth_failed",
+                operation: `destroy-${stackType}`
+            }))
+        };
+    }
+    if (errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
+        errorMessage.includes(CDK_NO_STACKS_MATCH)) {
+        return {
+            continue: true,
+            result: success({ message: "Stack already deleted" })
+        };
+    }
+    return {
+        continue: false,
+        result: failure(new ApplicationError(`Failed to destroy ${stackType} stack: ${errorMessage}`, {
+            errorType: "destroy_failed",
+            operation: `destroy-${stackType}`
+        }))
+    };
+}
+/**
+ * Destroy all stacks for an application in reverse order.
+ * Supports parallel destruction for OpenNext patterns (nextjs/payload).
+ */
+export async function destroyAllStacks(service, context, callbacks, resources) {
+    const appName = context.target;
+    // Use FrameworkRegistry to resolve builder and plan
+    const registry = FrameworkRegistry.createDefault();
+    const resolved = registry.resolve({ appPath: context.path });
+    // Determine destroy strategy from builder plan if available, else fall back to pattern detection
+    let useParallelDestroy;
+    let destroyOrder;
+    if (resolved) {
+        const plan = resolved.builder.plan({ appPath: context.path }, resolved.detection);
+        useParallelDestroy = plan.parallelDestroy;
+        destroyOrder = plan.destroyOrder;
+    }
+    else {
+        // No builder matched — infrastructure.ts missing. Use sequential destroy with default order.
+        useParallelDestroy = false;
+        destroyOrder = getApplicationDestroyOrder({ pattern: null, resources });
+    }
+    if (useParallelDestroy) {
+        const destroyGroups = getParallelDestroyGroups();
+        for (const group of destroyGroups) {
+            const stacks = group.stacks;
+            if (stacks.length === 1) {
+                const stackType = stacks[0];
+                const stackName = getApplicationStackName(appName, stackType);
+                callbacks?.onStackStart?.(stackType, stackName);
+                const result = await service.destroyStack(stackType, context, {
+                    onOutput: callbacks?.onOutput
+                        ? (chunk) => callbacks.onOutput?.(chunk, stackType)
+                        : undefined,
+                    onResourceProgress: callbacks?.onResourceProgress
+                        ? (event) => callbacks.onResourceProgress?.(event, stackType)
+                        : undefined
+                });
+                const finalResult = convertDestroyResultIfNotExists(result, stackType, appName);
+                if (callbacks?.onStackComplete) {
+                    await callbacks.onStackComplete(stackType, finalResult);
+                }
+                const errorResult = handleDestroyError(finalResult, stackType);
+                if (errorResult) {
+                    if (errorResult.continue)
+                        continue;
+                    return errorResult.result;
+                }
+            }
+            else {
+                const synthResult = await service.runCdkSynth(context);
+                if (!synthResult.success) {
+                    return failure(new ApplicationError(synthResult.error, {
+                        errorType: "synth_failed",
+                        appName,
+                        operation: "destroy-parallel-synth"
+                    }));
+                }
+                callbacks?.onParallelPhaseStart?.(stacks, group.description);
+                for (const stackType of stacks) {
+                    callbacks?.onStackStart?.(stackType, getApplicationStackName(appName, stackType));
+                }
+                const parallelResult = await service.destroyStacksInParallel(stacks, context, {
+                    onOutput: callbacks?.onOutput,
+                    onResourceProgress: callbacks?.onResourceProgress,
+                    onStackComplete: async (stack, stackSuccess, _duration, error) => {
+                        const result = stackSuccess
+                            ? success({
+                                stackName: getApplicationStackName(appName, stack),
+                                stackType: stack,
+                                outputs: {}
+                            })
+                            : failure(error instanceof ApplicationError
+                                ? error
+                                : new ApplicationError(error?.message ?? "Stack destruction failed", {
+                                    errorType: "destroy_failed",
+                                    appName,
+                                    operation: `destroy-${stack}`
+                                }));
+                        await callbacks?.onStackComplete?.(stack, result);
+                    }
+                }, true);
+                if (parallelResult.success) {
+                    callbacks?.onParallelPhaseComplete?.(parallelResult.data);
+                    const failures = parallelResult.data.filter((r) => !r.success);
+                    if (failures.length > 0) {
+                        const realFailures = failures.filter((f) => f.error &&
+                            !f.error.message.includes(STACK_NOT_FOUND_PATTERN) &&
+                            !f.error.message.includes(CDK_NO_STACKS_MATCH));
+                        if (realFailures.length > 0) {
+                            const failedStacks = realFailures.map((f) => f.stack).join(", ");
+                            const errorDetails = realFailures
+                                .map((f) => `${f.stack}: ${f.error?.message || "Unknown error"}`)
+                                .join("\n");
+                            return failure(new ApplicationError(`Failed to destroy stacks: ${failedStacks}\n\n${errorDetails}`, {
+                                errorType: "destroy_failed",
+                                appName,
+                                operation: "destroy-parallel"
+                            }));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        for (const stackType of destroyOrder) {
+            const stackName = getApplicationStackName(appName, stackType);
+            callbacks?.onStackStart?.(stackType, stackName);
+            const result = await service.destroyStack(stackType, context, {
+                onOutput: callbacks?.onOutput
+                    ? (chunk) => callbacks.onOutput?.(chunk, stackType)
+                    : undefined,
+                onResourceProgress: callbacks?.onResourceProgress
+                    ? (event) => callbacks.onResourceProgress?.(event, stackType)
+                    : undefined
+            });
+            const finalResult = convertDestroyResultIfNotExists(result, stackType, appName);
+            if (callbacks?.onStackComplete) {
+                await callbacks.onStackComplete(stackType, finalResult);
+            }
+            const errorResult = handleDestroyError(finalResult, stackType);
+            if (errorResult) {
+                if (errorResult.continue)
+                    continue;
+                return errorResult.result;
+            }
+        }
+    }
+    return success({ message: "All stacks destroyed" });
+}
+/**
+ * Map Promise.allSettled results to ParallelDeploymentResult[], handling
+ * rejected promises with a fallback stack identity.
+ */
+export function mapSettledResults(settled, stacks) {
+    return settled.map((settledResult, index) => {
+        if (settledResult.status === "fulfilled") {
+            return settledResult.value;
+        }
+        const stack = stacks[index] ?? APPLICATION_STACKS.NETWORK;
+        return {
+            stack,
+            success: false,
+            error: settledResult.reason instanceof Error
+                ? settledResult.reason
+                : new Error(String(settledResult.reason)),
+            duration: 0
+        };
+    });
+}
+/**
+ * Resolve the website URL for an application from CloudFormation stack outputs.
+ * Checks Compute stack for LoadBalancer URL, then CDN stack for CloudFront distribution.
+ */
+export async function resolveWebsiteUrl(appName, cloudFormationService) {
+    try {
+        const computeStackName = getApplicationStackName(appName, APPLICATION_STACKS.COMPUTE);
+        const computeOutputs = await cloudFormationService.getStackOutputs(computeStackName);
+        if (computeOutputs.success && computeOutputs.data.length > 0) {
+            const lbUrl = computeOutputs.data.find((o) => o.OutputKey?.includes("LoadBalancerUrl"));
+            if (lbUrl?.OutputValue) {
+                return lbUrl.OutputValue.toLowerCase();
+            }
+            const lbDns = computeOutputs.data.find((o) => o.OutputKey?.includes("LoadBalancerDnsName"));
+            if (lbDns?.OutputValue) {
+                return `http://${lbDns.OutputValue.toLowerCase()}`;
+            }
+        }
+        const cdnStackName = getApplicationStackName(appName, APPLICATION_STACKS.CDN);
+        const cdnOutputs = await cloudFormationService.getStackOutputs(cdnStackName);
+        if (cdnOutputs.success && cdnOutputs.data.length > 0) {
+            const dist = cdnOutputs.data.find((o) => o.OutputKey?.includes("DistributionDomainName"));
+            if (dist?.OutputValue) {
+                return `https://${dist.OutputValue.toLowerCase()}`;
+            }
+        }
+        return undefined;
+    }
+    catch (error) {
+        logger.warn("ApplicationStackService", "URL resolution failed", {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return undefined;
+    }
+}