@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/types/application/ApplicationServiceTypes.js

@@ -1,30 +1 @@
-import { BaseServiceError } from "../errors/ServiceError.js";
-import { getErrorMessage } from "@fjall/util";
-/**
- * Wraps an error into an ApplicationError with consistent formatting.
- */
-export function wrapApplicationError(message, errorType, appName, operation, error) {
-    const errorMsg = getErrorMessage(error);
-    return new ApplicationError(`${message}: ${errorMsg}`, {
-        errorType,
-        appName,
-        operation,
-        details: error
-    });
-}
-/**
- * Application-specific error with typed error categories
- */
-export class ApplicationError extends BaseServiceError {
-    errorType;
-    appName;
-    operation;
-    stackType;
-    constructor(message, options) {
-        super(`APPLICATION_${options.errorType.toUpperCase()}`, message, options.details, options.recoverable ?? false);
-        this.errorType = options.errorType;
-        this.appName = options.appName;
-        this.operation = options.operation;
-        this.stackType = options.stackType;
-    }
-}
+import{BaseServiceError as s}from"../errors/ServiceError.js";import{getErrorMessage as c}from"@fjall/util";function m(a,e,r,t,p){const o=c(p);return new i(`${a}: ${o}`,{errorType:e,appName:r,operation:t,details:p})}class i extends s{errorType;appName;operation;stackType;constructor(e,r){super(`APPLICATION_${r.errorType.toUpperCase()}`,e,r.details,r.recoverable??!1),this.errorType=r.errorType,this.appName=r.appName,this.operation=r.operation,this.stackType=r.stackType}}export{i as ApplicationError,m as wrapApplicationError};

package/dist/src/types/application/index.js

@@ -1 +1 @@
-export { ApplicationError, wrapApplicationError } from "./ApplicationServiceTypes.js";
+import{ApplicationError as p,wrapApplicationError as i}from"./ApplicationServiceTypes.js";export{p as ApplicationError,i as wrapApplicationError};

package/dist/src/types/callbacks.d.ts

@@ -1,4 +1,5 @@
 import type { ProgressEvent, ResourceEvent, AwsAuthResult, CascadeDeploymentResult, CascadePhase } from "./events.js";
+import type { DetectionResult } from "./detection.js";
 export type StepCompleteStatus = "completed" | "skipped" | "error";
 /**
  * Unified callback interface for deployment progress.
@@ -8,29 +9,100 @@ export type StepCompleteStatus = "completed" | "skipped" | "error";
  *
  * All callbacks are optional. Omitting a callback means that
  * event type is silently ignored.
+ *
+ * Each callback is annotated with `@emittedBy` to indicate whether the
+ * engine (deploy-core) or the caller (CLI/webapp) is responsible for
+ * invoking it.
  */
 export interface DeployCallbacks {
+    /** @emittedBy engine — fired for each infrastructure stack start. */
     onStepStart?: (stepId: string, stepName: string, stepIndex?: number, stepTotal?: number) => void;
+    /** @emittedBy engine — fired for each infrastructure stack completion. */
     onStepComplete?: (stepId: string, stepName: string, status: StepCompleteStatus, stepIndex?: number, stepTotal?: number) => void;
+    /** @emittedBy engine */
     onProgress?: (event: ProgressEvent) => void;
+    /** @emittedBy engine */
     onLog?: (message: string, level?: "info" | "debug" | "warn") => void;
+    /** @emittedBy engine */
     onOutput?: (chunk: string) => void;
+    /** @emittedBy engine — per-resource CFN events during sequential stack deployment. */
     onResourceProgress?: (event: ResourceEvent) => void;
+    /** @emittedBy engine — fired when the engine begins a parallel phase (multiple stacks at once). */
+    onParallelPhaseStart?: (stacks: readonly string[], description: string) => void;
+    /** @emittedBy engine — fired when a parallel phase completes. */
+    onParallelPhaseComplete?: (results: Array<{
+        stack: string;
+        success: boolean;
+        error?: Error;
+    }>) => void;
+    /**
+     * @emittedBy engine — per-stack resource progress during a parallel phase.
+     * Includes the stack identifier so consumers can route events
+     * to the correct panel.
+     */
+    onParallelStackResourceProgress?: (stack: string, event: ResourceEvent) => void;
+    /**
+     * @emittedBy engine — Docker build/push progress.
+     * deploy-core wires this through to DockerProvider.buildAndPush().
+     */
     onDockerProgress?: (message: string, percentage?: number, layerId?: string, status?: string) => void;
+    /**
+     * @emittedBy caller — ECS rolling update status.
+     * ECS service stabilisation is a post-CDK-deploy concern.
+     * deploy-core does not monitor ECS services.
+     */
     onECSUpdate?: (status: string, service?: string) => void;
+    /**
+     * @emittedBy caller — ECS rolling update progress with percentage.
+     * deploy-core does not monitor ECS services.
+     */
     onECSProgress?: (message: string, percentage?: number) => void;
+    /** @emittedBy engine */
     onCDKBootstrap?: (status: string) => void;
-    onCDKDiff?: (hasDifferences: boolean) => void;
+    /** @emittedBy engine */
     onCdkOutput?: (output: string, type: "synth" | "diff") => void;
+    /** @emittedBy engine */
     onCascadeStart?: () => void;
+    /** @emittedBy engine */
     onCascadePhaseStart?: (phase: CascadePhase) => void;
-    onCascadeAccountStart?: (operationKey: string, accountId: string, region: string) => void;
-    onCascadeAccountPhaseChange?: (operationKey: string, phase: "synth" | "deploy" | "destroy", region?: string) => void;
+    /** @emittedBy engine — fired when a cascade phase completes. */
+    onCascadePhaseComplete?: (phase: CascadePhase) => void;
+    /** @emittedBy engine */
+    onCascadeAccountStart?: (operationKey: string, accountId: string, region: string, deployType?: string) => void;
+    /** @emittedBy engine — per-account bootstrap/synth/deploy/destroy phase transitions. */
+    onCascadeAccountPhaseChange?: (operationKey: string, phase: "bootstrap" | "synth" | "deploy" | "destroy", region?: string) => void;
+    /** @emittedBy engine — per-account CFN resource events during cascade. */
     onCascadeAccountResourceProgress?: (operationKey: string, event: ResourceEvent, region?: string) => void;
-    onCascadeAccountComplete?: (operationKey: string, success: boolean, error?: string, region?: string) => void;
+    /** @emittedBy engine */
+    onCascadeAccountComplete?: (operationKey: string, success: boolean, error?: string, region?: string, outputs?: Record<string, string>) => void;
+    /** @emittedBy engine */
     onCascadeComplete?: (result: CascadeDeploymentResult) => void;
+    /** @emittedBy engine — progress during failed-state stack cleanup (S3 emptying, deletion). */
+    onStackCleanupProgress?: (stackName: string, phase: "emptying-bucket" | "deleting-stack" | "waiting" | "complete" | "error") => void;
+    /**
+     * @emittedBy engine — fired after the detection pipeline completes with full analysis results.
+     * May be async — engine awaits the return value so callers can run post-detection
+     * hooks (e.g. secrets validation) before deployment begins.
+     */
+    onDetectionComplete?: (result: DetectionResult) => void | Promise<void>;
+    /**
+     * @emittedBy engine — fired at each phase boundary of the detection pipeline.
+     * Replaces fragile string matching on onLog messages for pre-deployment progress.
+     */
+    onDetectionPhaseChange?: (phase: "detect" | "synth" | "hash" | "validate", status: "started" | "completed") => void;
+    /** @emittedBy caller — CLI fires during SSO/OIDC auth flows. */
     onSSOUrl?: (url: string | null) => void;
+    /** @emittedBy caller — CLI fires after credential resolution. */
     onAuthComplete?: (result: AwsAuthResult | null) => void;
+    /** @emittedBy engine — fired when OpenNext build starts (Next.js/Payload apps). */
+    onOpenNextBuildStart?: () => void;
+    /** @emittedBy engine — OpenNext build progress output. */
+    onOpenNextProgress?: (message: string) => void;
+    /** @emittedBy engine — fired when OpenNext build completes successfully. */
+    onOpenNextBuildComplete?: () => void;
+    /** @emittedBy engine — fired when OpenNext build fails. */
+    onOpenNextBuildError?: (error: string) => void;
+    /** @emittedBy engine */
     onError?: (error: Error) => void;
     verbose?: boolean;
 }

package/dist/src/types/callbacks.js

@@ -1 +0,0 @@
-export {};

package/dist/src/types/constants.d.ts

@@ -1,5 +1,7 @@
 /** CloudFormation error pattern indicating a stack doesn't exist */
 export declare const STACK_NOT_FOUND_PATTERN = "does not exist";
+/** CDK error pattern indicating a stack is in a failed state */
+export declare const STACK_FAILED_STATE_PATTERN = "is in a failed state";
 /** CDK error pattern indicating no stacks matched the provided name */
 export declare const CDK_NO_STACKS_MATCH = "No stacks match the name(s)";
 /** The canonical name for generated infrastructure files */

package/dist/src/types/constants.js

@@ -1,6 +1 @@
-/** CloudFormation error pattern indicating a stack doesn't exist */
-export const STACK_NOT_FOUND_PATTERN = "does not exist";
-/** CDK error pattern indicating no stacks matched the provided name */
-export const CDK_NO_STACKS_MATCH = "No stacks match the name(s)";
-/** The canonical name for generated infrastructure files */
-export const INFRASTRUCTURE_FILENAME = "infrastructure.ts";
+const t="does not exist",s="is in a failed state",T="No stacks match the name(s)",e="infrastructure.ts";export{T as CDK_NO_STACKS_MATCH,e as INFRASTRUCTURE_FILENAME,s as STACK_FAILED_STATE_PATTERN,t as STACK_NOT_FOUND_PATTERN};

package/dist/src/types/credentials.js

@@ -1 +0,0 @@
-export {};

package/dist/src/types/deployment/DeploymentServiceTypes.d.ts

@@ -1,6 +1,5 @@
 import type { DeploymentContext } from "./DeploymentTypes.js";
 import type { StackOutputsRecord } from "./cloudformation.js";
-export type { StackOutput, StackOutputsRecord } from "./cloudformation.js";
 /**
  * Extended deployment context for application deployments
  */
@@ -20,4 +19,8 @@ export interface CallerIdentity {
     UserId: string;
     Arn: string;
 }
-export type { ValidationResult } from "../validation.js";
+/**
+ * Build a stub CallerIdentity with only the Account field populated.
+ * Used when the full STS identity isn't available (e.g. cascade accounts).
+ */
+export declare function stubCallerIdentity(accountId: string): CallerIdentity;

package/dist/src/types/deployment/DeploymentServiceTypes.js

@@ -1 +1 @@
-export {};
+function n(t){return{Account:t,Arn:"",UserId:""}}export{n as stubCallerIdentity};

package/dist/src/types/deployment/DeploymentTypes.js

@@ -1 +0,0 @@
-export {};

package/dist/src/types/deployment/cloudformation.js

@@ -1 +0,0 @@
-export {};

package/dist/src/types/deployment/index.d.ts

@@ -1,5 +1,7 @@
 export type { StackOutput, StackOutputsRecord } from "./cloudformation.js";
 export type { DeploymentContext, StepOutput } from "./DeploymentTypes.js";
-export type { ApplicationDeploymentContext, CallerIdentity, ValidationResult } from "./DeploymentServiceTypes.js";
+export type { ApplicationDeploymentContext, CallerIdentity } from "./DeploymentServiceTypes.js";
+export type { ValidationResult } from "../validation.js";
+export { stubCallerIdentity } from "./DeploymentServiceTypes.js";
 export type { ParallelDeploymentResult, ParallelDeployGroup, ParallelOperation, ParallelOperationType, ParallelOperationState } from "./parallel.js";
 export { PARALLEL_OPERATION_TYPES } from "./parallel.js";

package/dist/src/types/deployment/index.js

@@ -1 +1 @@
-export { PARALLEL_OPERATION_TYPES } from "./parallel.js";
+import{stubCallerIdentity as e}from"./DeploymentServiceTypes.js";import{PARALLEL_OPERATION_TYPES as A}from"./parallel.js";export{A as PARALLEL_OPERATION_TYPES,e as stubCallerIdentity};

package/dist/src/types/deployment/parallel.js

@@ -1,10 +1 @@
-/**
- * Type definitions for parallel deployment operations
- */
-/**
- * Special parallel operations that aren't CloudFormation stacks
- */
-export const PARALLEL_OPERATION_TYPES = {
-    BUILD: "build",
-    DOCKER: "docker"
-};
+const E={BUILD:"build",DOCKER:"docker"};export{E as PARALLEL_OPERATION_TYPES};

package/dist/src/types/deploymentEventSchema.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Canonical deployment event schema — the single source of truth for events
+ * sent between the deployment engine, CLI, and webapp.
+ *
+ * Both CLI and webapp previously maintained independent copies of this schema.
+ * This unified version is the UNION of all event types from both, with the
+ * webapp's .max() security constraints preserved for safe server-side parsing.
+ *
+ * Usage:
+ *   - Server-side (validation): import { DeploymentEventSchema } from "@fjall/deploy-core"
+ *   - Client-side (types only): import type { DeploymentEvent } from "@fjall/deploy-core"
+ */
+import { z } from "zod";
+export declare const DEPLOYMENT_EVENT_RESOURCE_CATEGORIES: readonly ["security", "network", "compute", "database", "storage", "monitoring", "dns", "identity", "bootstrap", "events", "registry", "backup"];
+export type DeploymentEventResourceCategory = (typeof DEPLOYMENT_EVENT_RESOURCE_CATEGORIES)[number];
+export declare const CASCADE_PHASES: readonly ["platform", "domains", "accounts"];
+export declare const CASCADE_ACCOUNT_STATUSES: readonly ["started", "deploying", "completed", "failed"];
+export declare const DEPLOYMENT_EVENT_TYPES: readonly ["step", "resource", "docker", "ecs", "error", "complete", "cascade_phase", "cascade_account", "parallel_phase", "detection", "log"];
+export type DeploymentEventType = (typeof DEPLOYMENT_EVENT_TYPES)[number];
+export type DeploymentEventCascadePhase = (typeof CASCADE_PHASES)[number];
+export type DeploymentEventCascadeAccountStatus = (typeof CASCADE_ACCOUNT_STATUSES)[number];
+export declare const DeploymentEventSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        step: "step";
+        resource: "resource";
+        docker: "docker";
+        ecs: "ecs";
+        error: "error";
+        complete: "complete";
+        cascade_phase: "cascade_phase";
+        cascade_account: "cascade_account";
+        parallel_phase: "parallel_phase";
+        detection: "detection";
+        log: "log";
+    }>;
+    timestamp: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        index: z.ZodNumber;
+        total: z.ZodNumber;
+        status: z.ZodString;
+    }, z.core.$strict>>;
+    resource: z.ZodOptional<z.ZodObject<{
+        logicalId: z.ZodString;
+        resourceType: z.ZodString;
+        category: z.ZodEnum<{
+            security: "security";
+            network: "network";
+            compute: "compute";
+            database: "database";
+            storage: "storage";
+            monitoring: "monitoring";
+            dns: "dns";
+            identity: "identity";
+            bootstrap: "bootstrap";
+            events: "events";
+            registry: "registry";
+            backup: "backup";
+        }>;
+        group: z.ZodOptional<z.ZodString>;
+        constructPath: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodString;
+        status: z.ZodString;
+        statusReason: z.ZodOptional<z.ZodString>;
+        physicalId: z.ZodOptional<z.ZodString>;
+        expectedDurationSeconds: z.ZodOptional<z.ZodNumber>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    docker: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        percentage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    ecs: z.ZodOptional<z.ZodObject<{
+        status: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        percentage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodOptional<z.ZodString>;
+        remediation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    message: z.ZodOptional<z.ZodString>;
+    cascadePhase: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodEnum<{
+            platform: "platform";
+            domains: "domains";
+            accounts: "accounts";
+        }>;
+        status: z.ZodEnum<{
+            started: "started";
+            completed: "completed";
+        }>;
+    }, z.core.$strict>>;
+    cascadeAccount: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodString;
+        region: z.ZodString;
+        operationKey: z.ZodString;
+        status: z.ZodEnum<{
+            started: "started";
+            deploying: "deploying";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            bootstrap: "bootstrap";
+            synth: "synth";
+            deploy: "deploy";
+            destroy: "destroy";
+        }>>;
+        cascadePhase: z.ZodOptional<z.ZodEnum<{
+            platform: "platform";
+            domains: "domains";
+            accounts: "accounts";
+        }>>;
+    }, z.core.$strict>>;
+    parallelPhase: z.ZodOptional<z.ZodObject<{
+        stacks: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            started: "started";
+            completed: "completed";
+        }>;
+        results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            stack: z.ZodString;
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    detection: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodNullable<z.ZodString>;
+        hasDockerfile: z.ZodBoolean;
+        hasDifferences: z.ZodBoolean;
+        resources: z.ZodObject<{
+            hasNetwork: z.ZodBoolean;
+            hasCompute: z.ZodBoolean;
+            hasDatabase: z.ZodBoolean;
+            hasStorage: z.ZodBoolean;
+            hasMessaging: z.ZodBoolean;
+            hasCdn: z.ZodBoolean;
+        }, z.core.$strict>;
+        requiredSecrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    log: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        level: z.ZodEnum<{
+            info: "info";
+            debug: "debug";
+            warn: "warn";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Inferred type — safe for client-side import via `import type`. */
+export type DeploymentEvent = z.infer<typeof DeploymentEventSchema>;
+/** Map a deploy type to its cascade phase value for event emission. */
+export declare function toCascadePhase(deployType: string): DeploymentEventCascadePhase | undefined;

package/dist/src/types/deploymentEventSchema.js

@@ -0,0 +1 @@
+import{z as e}from"zod";const r=["security","network","compute","database","storage","monitoring","dns","identity","bootstrap","events","registry","backup"],n=["platform","domains","accounts"],c=["started","deploying","completed","failed"],i=["step","resource","docker","ecs","error","complete","cascade_phase","cascade_account","parallel_phase","detection","log"],l={step:"step",resource:"resource",docker:"docker",ecs:"ecs",error:"error",complete:null,cascade_phase:"cascadePhase",cascade_account:"cascadeAccount",parallel_phase:"parallelPhase",detection:"detection",log:"log"},m=e.object({type:e.enum(i),timestamp:e.string().max(64),sequence:e.number().int().nonnegative().optional(),step:e.object({id:e.string().max(256),name:e.string().max(256),index:e.number(),total:e.number(),status:e.string().max(64)}).strict().optional(),resource:e.object({logicalId:e.string().max(256),resourceType:e.string().max(256),category:e.enum(r),group:e.string().max(128).optional(),constructPath:e.string().max(512).optional(),displayName:e.string().max(256),status:e.string().max(64),statusReason:e.string().max(2048).optional(),physicalId:e.string().max(2048).optional(),expectedDurationSeconds:e.number().optional(),stack:e.string().max(256).optional()}).strict().optional(),docker:e.object({message:e.string().max(2048),percentage:e.number().optional()}).strict().optional(),ecs:e.object({status:e.string().max(64),message:e.string().max(2048).optional(),percentage:e.number().optional()}).strict().optional(),error:e.object({message:e.string().max(4096),category:e.string().max(128).optional(),remediation:e.array(e.string().max(1024)).max(10).optional()}).strict().optional(),message:e.string().max(2048).optional(),cascadePhase:e.object({phase:e.enum(n),status:e.enum(["started","completed"])}).strict().optional(),cascadeAccount:e.object({accountId:e.string().max(32),region:e.string().max(32),operationKey:e.string().max(256),status:e.enum(c),error:e.string().max(2048).optional(),phase:e.enum(["bootstrap","synth","deploy","destroy"]).optional(),cascadePhase:e.enum(n).optional()}).strict().optional(),parallelPhase:e.object({stacks:e.array(e.string().max(256)).max(20),status:e.enum(["started","completed"]),results:e.array(e.object({stack:e.string().max(256),success:e.boolean(),error:e.string().max(2048).optional()}).strict()).max(20).optional()}).strict().optional(),detection:e.object({pattern:e.string().max(128).nullable(),hasDockerfile:e.boolean(),hasDifferences:e.boolean(),resources:e.object({hasNetwork:e.boolean(),hasCompute:e.boolean(),hasDatabase:e.boolean(),hasStorage:e.boolean(),hasMessaging:e.boolean(),hasCdn:e.boolean()}).strict(),requiredSecrets:e.array(e.string().max(512)).max(100).optional()}).strict().optional(),log:e.object({message:e.string().max(2048),level:e.enum(["info","debug","warn"])}).strict().optional()}).strict().superRefine((t,o)=>{const a=l[t.type],s=a?t[a]:void 0;a&&s==null&&o.addIssue({code:e.ZodIssueCode.custom,message:`"${a}" is required when type is "${t.type}"`,path:[a]}),t.type==="complete"&&!t.message&&o.addIssue({code:e.ZodIssueCode.custom,message:'"message" is required when type is "complete"',path:["message"]})});function u(t){if(t==="platform")return"platform";if(t==="account")return"accounts"}export{c as CASCADE_ACCOUNT_STATUSES,n as CASCADE_PHASES,r as DEPLOYMENT_EVENT_RESOURCE_CATEGORIES,i as DEPLOYMENT_EVENT_TYPES,m as DeploymentEventSchema,u as toCascadePhase};

package/dist/src/types/detection.d.ts

@@ -0,0 +1,22 @@
+import type { PatternType } from "@fjall/generator";
+import type { AppResourceFlags } from "./patternTypes.js";
+/**
+ * Result of the pre-deployment detection pipeline.
+ *
+ * Contains pattern, resource flags, hash comparison, and Dockerfile detection.
+ * Used by applicationDeploy to decide deploy order and by callers (via
+ * onDetectionComplete callback) to update UI step lists.
+ */
+export interface DetectionResult {
+    pattern: PatternType | null;
+    hasDatabase: boolean;
+    hasDifferences: boolean;
+    stackChanges: Map<string, boolean>;
+    currentHashes: Map<string, string>;
+    resources: AppResourceFlags;
+    hasDockerfile: boolean;
+    /** SSM parameter paths required by the application, parsed from the CDK manifest. */
+    requiredSecrets: string[];
+    /** Name of the framework builder that resolved this app (e.g. "opennext", "docker"). */
+    builderName?: string;
+}

package/dist/src/types/detection.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/entitlements.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Full entitlements contract returned by GET /api/entitlements.
+ *
+ * Single source of truth — imported by both the CLI (API consumer)
+ * and the webapp (API producer). See also EntitlementsData in
+ * apiClient.ts which is a minimal subset used by the deploy engine.
+ */
+export interface Entitlements {
+    plan: "free" | "trial" | "starter" | "pro" | "enterprise";
+    limits: {
+        applications: number;
+        users: number;
+        awsAccounts: number;
+        maxOrganisations: number;
+    };
+    usage?: {
+        applications: number;
+        awsAccounts: number;
+    };
+    features: {
+        organisations: boolean;
+        allowedTiers: string[];
+        assetManagement: boolean;
+        complianceAudit: "none" | "basic" | "full";
+    };
+    metricsRetentionHours: number;
+    /** "full" = all visible, "limited" = top 1 only, rest blurred */
+    costRecommendations: "full" | "limited";
+    /** "full" = all details visible, "limited" = top 1 detail only, rest title-only */
+    warningDetail: "full" | "limited";
+}

package/dist/src/types/errors/CdkError.js

@@ -1,20 +1 @@
-/**
- * CDK-specific error types
- */
-import { BaseServiceError } from "./ServiceError.js";
-/**
- * CDK operation error
- */
-export class CdkError extends BaseServiceError {
-    errorType;
-    stackName;
-    exitCode;
-    output;
-    constructor(message, errorType, stackName, exitCode, output, details, recoverable = false) {
-        super(`CDK_${errorType.toUpperCase()}`, message, details, recoverable);
-        this.errorType = errorType;
-        this.stackName = stackName;
-        this.exitCode = exitCode;
-        this.output = output;
-    }
-}
+import{BaseServiceError as p}from"./ServiceError.js";class C extends p{errorType;stackName;exitCode;output;constructor(t,e,r,s,o,a,i=!1){super(`CDK_${e.toUpperCase()}`,t,a,i),this.errorType=e,this.stackName=r,this.exitCode=s,this.output=o}}export{C as CdkError};

package/dist/src/types/errors/ServiceError.d.ts

@@ -1,7 +1,8 @@
 /**
  * Standardised error details type used across all services.
+ * Typically an Error, Record, or string — but accepts unknown for catch blocks.
  */
-export type ServiceErrorDetails = Error | Record<string, unknown> | string | unknown | undefined;
+export type ServiceErrorDetails = unknown;
 /**
  * Base service error with full context
  */

package/dist/src/types/errors/ServiceError.js

@@ -1,119 +1 @@
-/**
- * Base implementation of ServiceError
- */
-export class BaseServiceError extends Error {
-    code;
-    details;
-    recoverable;
-    cause;
-    constructor(code, message, details, recoverable = false, cause) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.recoverable = recoverable;
-        this.cause = cause;
-        this.name = this.constructor.name;
-        // Maintain proper stack trace
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-}
-/**
- * Validation-specific errors
- */
-export class ValidationError extends BaseServiceError {
-    fields;
-    rules;
-    constructor(message, fields, rules, details) {
-        super("VALIDATION_ERROR", message, details, false);
-        this.fields = fields;
-        this.rules = rules;
-    }
-}
-/**
- * Authentication/Authorization errors
- */
-export class AuthError extends BaseServiceError {
-    account;
-    reason;
-    constructor(message, account, reason, details) {
-        super("AUTH_ERROR", message, details, false);
-        this.account = account;
-        this.reason = reason;
-    }
-}
-/**
- * AWS-specific errors
- */
-export class AwsError extends BaseServiceError {
-    service;
-    operation;
-    awsErrorCode;
-    constructor(message, service, operation, awsErrorCode, details, recoverable = false) {
-        super("AWS_ERROR", message, details, recoverable);
-        this.service = service;
-        this.operation = operation;
-        this.awsErrorCode = awsErrorCode;
-    }
-}
-/**
- * CDK/CloudFormation errors
- */
-export class DeploymentError extends BaseServiceError {
-    stackName;
-    deploymentPhase;
-    constructor(message, stackName, deploymentPhase, details, recoverable = false) {
-        super("DEPLOYMENT_ERROR", message, details, recoverable);
-        this.stackName = stackName;
-        this.deploymentPhase = deploymentPhase;
-    }
-}
-/**
- * Network/connectivity errors
- */
-export class NetworkError extends BaseServiceError {
-    endpoint;
-    statusCode;
-    constructor(message, endpoint, statusCode, cause) {
-        super("NETWORK_ERROR", message, undefined, true, cause);
-        this.endpoint = endpoint;
-        this.statusCode = statusCode;
-    }
-}
-/**
- * File system errors
- */
-export class FileSystemError extends BaseServiceError {
-    path;
-    operation;
-    constructor(message, path, operation, cause) {
-        super("FILESYSTEM_ERROR", message, { path, operation }, false, cause);
-        this.path = path;
-        this.operation = operation;
-    }
-}
-/**
- * Configuration errors
- */
-export class ConfigError extends BaseServiceError {
-    configKey;
-    configPath;
-    constructor(message, configKey, configPath, details) {
-        super("CONFIG_ERROR", message, details, false);
-        this.configKey = configKey;
-        this.configPath = configPath;
-    }
-}
-/**
- * Convert unknown errors to ServiceError
- */
-export function toServiceError(error, code = "UNKNOWN_ERROR") {
-    if (error instanceof BaseServiceError) {
-        return error;
-    }
-    if (error instanceof Error) {
-        return new BaseServiceError(code, error.message, { name: error.name }, false, error);
-    }
-    return new BaseServiceError(code, String(error), { rawError: error }, false);
-}
+class a extends Error{code;details;recoverable;cause;constructor(e,t,r,o=!1,c){super(t),this.code=e,this.details=r,this.recoverable=o,this.cause=c,this.name=this.constructor.name,Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}}class i extends a{fields;rules;constructor(e,t,r,o){super("VALIDATION_ERROR",e,o,!1),this.fields=t,this.rules=r}}class u extends a{account;reason;constructor(e,t,r,o){super("AUTH_ERROR",e,o,!1),this.account=t,this.reason=r}}class l extends a{service;operation;awsErrorCode;constructor(e,t,r,o,c,n=!1){super("AWS_ERROR",e,c,n),this.service=t,this.operation=r,this.awsErrorCode=o}}class h extends a{stackName;deploymentPhase;constructor(e,t,r,o,c=!1){super("DEPLOYMENT_ERROR",e,o,c),this.stackName=t,this.deploymentPhase=r}}class E extends a{endpoint;statusCode;constructor(e,t,r,o){super("NETWORK_ERROR",e,void 0,!0,o),this.endpoint=t,this.statusCode=r}}class p extends a{path;operation;constructor(e,t,r,o){super("FILESYSTEM_ERROR",e,{path:t,operation:r},!1,o),this.path=t,this.operation=r}}class R extends a{configKey;configPath;constructor(e,t,r,o){super("CONFIG_ERROR",e,o,!1),this.configKey=t,this.configPath=r}}function d(s,e="UNKNOWN_ERROR"){return s instanceof a?s:s instanceof Error?new a(e,s.message,{name:s.name},!1,s):new a(e,String(s),{rawError:s},!1)}export{u as AuthError,l as AwsError,a as BaseServiceError,R as ConfigError,h as DeploymentError,p as FileSystemError,E as NetworkError,i as ValidationError,d as toServiceError};

package/dist/src/types/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { CdkError } from "./CdkError.js";
+export { type ServiceErrorDetails, type ServiceError, BaseServiceError, ValidationError, AuthError, AwsError, DeploymentError, NetworkError, FileSystemError, ConfigError, toServiceError } from "./ServiceError.js";

package/dist/src/types/errors/index.js

@@ -0,0 +1 @@
+import{CdkError as e}from"./CdkError.js";import{BaseServiceError as t,ValidationError as i,AuthError as m,AwsError as a,DeploymentError as f,NetworkError as l,FileSystemError as n,ConfigError as p,toServiceError as s}from"./ServiceError.js";export{m as AuthError,a as AwsError,t as BaseServiceError,e as CdkError,p as ConfigError,f as DeploymentError,n as FileSystemError,l as NetworkError,i as ValidationError,s as toServiceError};

package/dist/src/types/events.d.ts

@@ -2,6 +2,7 @@
  * Progress event types emitted by the deployment engine.
  * These flow to the caller via DeployCallbacks.
  */
+import type { DeploymentEventCascadePhase } from "./deploymentEventSchema.js";
 export type ProgressEventType = "step" | "info" | "spinner" | "warning" | "debug" | "error";
 export interface ProgressEvent {
     type: ProgressEventType;
@@ -14,14 +15,7 @@ export interface ProgressEvent {
         totalSteps?: number;
     };
 }
-export interface ResourceEvent {
-    logicalId: string;
-    physicalId?: string;
-    resourceType: string;
-    status: string;
-    statusReason?: string;
-    timestamp: Date;
-}
+export type { ResourceEvent } from "@fjall/util/aws";
 export interface AwsAuthResult {
     accountId: string;
     region: string;
@@ -37,4 +31,4 @@ export interface CascadeDeploymentResult {
         error: string;
     }>;
 }
-export type CascadePhase = "platform" | "domains" | "accounts";
+export type CascadePhase = DeploymentEventCascadePhase;