@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/steps/stepRegistry.js

@@ -0,0 +1,505 @@
+import { APPLICATION_STACKS, APPLICATION_DEPLOY_ORDER, getApplicationStepName, getApplicationStepId } from "../types/index.js";
+import { STEP_IDS, STEP_NAMES, INFRA_STEP_NAME } from "../types/index.js";
+/**
+ * Map from stack type to destroy step ID
+ */
+const DESTROY_STEP_MAP = {
+    Network: STEP_IDS.NETWORK_DESTROY,
+    Storage: STEP_IDS.STORAGE_DESTROY,
+    Messaging: STEP_IDS.MESSAGING_DESTROY,
+    Database: STEP_IDS.DATABASE_DESTROY,
+    Compute: STEP_IDS.COMPUTE_DESTROY,
+    Cdn: STEP_IDS.CDN_DESTROY
+};
+/**
+ * Get the destroy step ID for a given stack type
+ */
+export function getDestroyStepId(stackType) {
+    return DESTROY_STEP_MAP[stackType] ?? `${stackType.toLowerCase()}-destroy`;
+}
+/**
+ * Step registry providing step filtering and registry logic.
+ * Step definitions (STEP_IDS, STEP_NAMES, StepDefinition, StepContext)
+ * live in types/stepDefinitions.ts — the single source of truth.
+ *
+ * This class was moved from CLI to deploy-core so both CLI and webapp
+ * can use the same step registry.
+ */
+export class StepRegistry {
+    /**
+     * Unified deployment steps for ALL deployment types
+     * Key format: "{deploymentType}-{operation}"
+     */
+    static DEPLOYMENT_STEPS = new Map([
+        [
+            "application-deploy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                {
+                    id: STEP_IDS.DETECT_CONFIG,
+                    name: STEP_NAMES.PREPARE_DEPLOY
+                },
+                {
+                    id: STEP_IDS.BOOTSTRAP,
+                    name: STEP_NAMES.BOOTSTRAP,
+                    conditions: { requiresInfra: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.NETWORK, "deploy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.NETWORK, "deploy"),
+                    conditions: { requiresInfra: true, requiresNetwork: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.STORAGE, "deploy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.STORAGE, "deploy"),
+                    conditions: { requiresInfra: true, requiresStorage: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.MESSAGING, "deploy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.MESSAGING, "deploy"),
+                    conditions: { requiresInfra: true, requiresMessaging: true }
+                },
+                {
+                    id: STEP_IDS.DOCKER_OPERATIONS,
+                    name: "Docker operations", // Dynamic name will be set by context
+                    conditions: {
+                        requiresDocker: true,
+                        requiresCompute: true,
+                        skipForInfraOnly: true
+                    }
+                },
+                {
+                    id: STEP_IDS.TAG_ECR_IMAGES,
+                    name: "Tagging container images",
+                    conditions: {
+                        requiresImageTagging: true,
+                        requiresCompute: true,
+                        skipForInfraOnly: true
+                    }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.DATABASE, "deploy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.DATABASE, "deploy"),
+                    conditions: { requiresInfra: true, requiresDatabase: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.COMPUTE, "deploy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.COMPUTE, "deploy"),
+                    conditions: { requiresInfra: true, requiresCompute: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.CDN, "deploy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.CDN, "deploy"),
+                    conditions: { requiresInfra: true, requiresCdn: true }
+                },
+                {
+                    id: STEP_IDS.ECS_UPDATE,
+                    name: "Updating ECS service",
+                    conditions: { requiresECS: true, requiresCompute: true }
+                },
+                {
+                    id: STEP_IDS.ECS_MONITOR,
+                    name: "Monitoring deployment",
+                    conditions: { requiresECS: true, requiresCompute: true }
+                }
+            ]
+        ],
+        [
+            "application-destroy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.DETECT_CONFIG, name: STEP_NAMES.CHECK_INFRA_STATE },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.CDN, "destroy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.CDN, "destroy"),
+                    conditions: { requiresCdn: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.COMPUTE, "destroy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.COMPUTE, "destroy")
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.DATABASE, "destroy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.DATABASE, "destroy")
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.MESSAGING, "destroy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.MESSAGING, "destroy"),
+                    conditions: { requiresMessaging: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.STORAGE, "destroy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.STORAGE, "destroy"),
+                    conditions: { requiresStorage: true }
+                },
+                {
+                    id: getApplicationStepId(APPLICATION_STACKS.NETWORK, "destroy"),
+                    name: getApplicationStepName(APPLICATION_STACKS.NETWORK, "destroy")
+                }
+            ]
+        ],
+        [
+            "organisation-deploy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.ORG_SETUP, name: "Configuring organisation" },
+                { id: STEP_IDS.PREPARE, name: STEP_NAMES.PREPARE_DEPLOY },
+                { id: STEP_IDS.BOOTSTRAP, name: STEP_NAMES.BOOTSTRAP },
+                {
+                    id: STEP_IDS.DEPLOY,
+                    name: "Deploying organisation",
+                    conditions: { requiresOrgChanges: true }
+                },
+                {
+                    id: STEP_IDS.CASCADE_PLATFORM,
+                    name: "Deploying platform",
+                    conditions: {
+                        requiresPlatformAccount: true,
+                        requiresPlatformChanges: true
+                    }
+                },
+                {
+                    id: STEP_IDS.CASCADE_DOMAINS,
+                    name: "Deploying domains",
+                    conditions: {
+                        requiresDomainConfiguration: true,
+                        requiresDomainChanges: true
+                    }
+                },
+                {
+                    id: STEP_IDS.CASCADE_ACCOUNTS,
+                    name: "Deploying accounts",
+                    conditions: {
+                        requiresMemberAccounts: true,
+                        requiresAccountChanges: true
+                    }
+                }
+            ]
+        ],
+        [
+            "organisation-destroy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.CFN_CHECK, name: STEP_NAMES.CHECK_INFRA_STATE },
+                {
+                    id: STEP_IDS.CASCADE_ACCOUNTS,
+                    name: "Destroying account infrastructure",
+                    conditions: { requiresMemberAccounts: true }
+                },
+                {
+                    id: STEP_IDS.CASCADE_PLATFORM,
+                    name: "Destroying platform infrastructure",
+                    conditions: { requiresPlatformAccount: true }
+                },
+                { id: STEP_IDS.DESTROY, name: "Destroying organisation infrastructure" }
+            ]
+        ],
+        [
+            "platform-deploy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.CONNECT, name: INFRA_STEP_NAME.CONNECT },
+                { id: STEP_IDS.PREPARE_ENVIRONMENT, name: INFRA_STEP_NAME.PREPARE },
+                { id: STEP_IDS.DEPLOY, name: INFRA_STEP_NAME.DEPLOY },
+                { id: STEP_IDS.MONITORING, name: INFRA_STEP_NAME.MONITORING }
+            ]
+        ],
+        [
+            "platform-destroy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.CFN_CHECK, name: "Checking infrastructure state" },
+                { id: STEP_IDS.ORG_DESTROY, name: "Destroying platform infrastructure" }
+            ]
+        ],
+        [
+            "account-deploy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.CONNECT, name: INFRA_STEP_NAME.CONNECT },
+                { id: STEP_IDS.PREPARE_ENVIRONMENT, name: INFRA_STEP_NAME.PREPARE },
+                { id: STEP_IDS.DEPLOY, name: INFRA_STEP_NAME.DEPLOY },
+                { id: STEP_IDS.MONITORING, name: INFRA_STEP_NAME.MONITORING }
+            ]
+        ],
+        [
+            "account-destroy",
+            [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                { id: STEP_IDS.CFN_CHECK, name: "Checking infrastructure state" },
+                { id: STEP_IDS.ORG_DESTROY, name: "Destroying account infrastructure" }
+            ]
+        ]
+    ]);
+    /**
+     * Get filtered steps based on deployment context
+     * This is the SINGLE method for getting steps for ANY deployment
+     */
+    static getSteps(context) {
+        // Special handling for deploy-only mode
+        if (context.deploymentType === "application" &&
+            context.operation === "deploy" &&
+            context.deployOnly) {
+            // Return simplified steps for deploy-only mode.
+            // Stack step IDs are derived from APPLICATION_DEPLOY_ORDER so they
+            // match the IDs deploy-core actually emits during deployment.
+            return [
+                { id: STEP_IDS.AUTH, name: STEP_NAMES.AUTH },
+                {
+                    id: STEP_IDS.DOCKER_OPERATIONS,
+                    name: "Build and push Docker container"
+                },
+                ...APPLICATION_DEPLOY_ORDER.map((stack) => ({
+                    id: getApplicationStepId(stack, "deploy"),
+                    name: getApplicationStepName(stack, "deploy")
+                }))
+            ];
+        }
+        const key = `${context.deploymentType}-${context.operation}`;
+        const steps = this.DEPLOYMENT_STEPS.get(key) ?? [];
+        // Apply context-based filtering
+        const filteredSteps = steps
+            .filter((step) => {
+            // Application-specific filtering
+            if (context.deploymentType === "application") {
+                const isOpenNextDeploy = context.builderName === "opennext";
+                // Skip infrastructure steps in deploy-only mode
+                if (step.conditions?.requiresInfra && context.deployOnly) {
+                    return false;
+                }
+                // Resource gating: when resources are known, skip steps for absent resources
+                if (context.resources) {
+                    const r = context.resources;
+                    if (step.conditions?.requiresNetwork && !r.hasNetwork)
+                        return false;
+                    if (step.conditions?.requiresCompute && !r.hasCompute)
+                        return false;
+                    if (step.conditions?.requiresDatabase && !r.hasDatabase)
+                        return false;
+                    if (step.conditions?.requiresStorage && !r.hasStorage)
+                        return false;
+                    if (step.conditions?.requiresMessaging && !r.hasMessaging)
+                        return false;
+                    if (step.conditions?.requiresCdn && !r.hasCdn)
+                        return false;
+                }
+                else if (context.operation === "deploy" && !isOpenNextDeploy) {
+                    // Pre-synth (standard deploy): hide ALL resource-specific steps
+                    // until manifest detection completes post-synth.
+                    // OpenNext patterns always use all 6 stacks so they keep theirs.
+                    // Destroy never runs synth so resources stays undefined — show all steps.
+                    const isResourceStep = step.conditions?.requiresNetwork ||
+                        step.conditions?.requiresCompute ||
+                        step.conditions?.requiresDatabase ||
+                        step.conditions?.requiresStorage ||
+                        step.conditions?.requiresMessaging ||
+                        step.conditions?.requiresCdn;
+                    if (isResourceStep) {
+                        return false;
+                    }
+                }
+                // Handle Docker operations step - skip for OpenNext deployments
+                if (step.conditions?.requiresDocker ||
+                    step.id === STEP_IDS.DOCKER_OPERATIONS) {
+                    // Skip Docker steps for OpenNext deployments (uses Lambda instead)
+                    if (isOpenNextDeploy) {
+                        return false;
+                    }
+                    // Skip in infra-only mode
+                    if (context.infraOnly) {
+                        return false;
+                    }
+                    // Skip when post-synth detection confirms no Compute stack
+                    if (context.resources && !context.resources.hasCompute) {
+                        return false;
+                    }
+                    // For deploy-only mode, always show if we have a Dockerfile
+                    if (context.deployOnly) {
+                        return context.hasDockerfile === true;
+                    }
+                    // For normal mode, show if:
+                    // - We have a Dockerfile (build+push), OR
+                    // - No Dockerfile + Compute stack (ECR init + welcome image)
+                    if (context.hasDockerfile === true) {
+                        return true;
+                    }
+                    if (context.hasDockerfile === false && !context.isManagedAccount) {
+                        return true;
+                    }
+                    // Don't show during initial state (hasDockerfile undefined)
+                    return false;
+                }
+                // Handle ECS update/monitor steps - skip for OpenNext, only show in deploy-only mode
+                if (step.conditions?.requiresECS) {
+                    if (isOpenNextDeploy) {
+                        return false;
+                    }
+                    return (context.deployOnly === true && context.hasDockerfile === true);
+                }
+                // Handle image tagging step - show when no Dockerfile + Compute exists
+                // ECS expects :<serviceName>-latest tags; initialiseECR only pushes :latest
+                if (step.conditions?.requiresImageTagging) {
+                    if (context.infraOnly) {
+                        return false;
+                    }
+                    if (isOpenNextDeploy) {
+                        return false;
+                    }
+                    // Skip when post-synth detection confirms no Compute stack
+                    if (context.resources && !context.resources.hasCompute) {
+                        return false;
+                    }
+                    // Show when no Dockerfile (we're not building our own image)
+                    return context.hasDockerfile === false;
+                }
+            }
+            // Organisation cascade filtering: hide cascade steps when no accounts exist
+            if (step.conditions?.requiresMemberAccounts &&
+                !context.hasMemberAccounts) {
+                return false;
+            }
+            if (step.conditions?.requiresPlatformAccount &&
+                !context.hasPlatformAccount) {
+                return false;
+            }
+            // Organisation change-detection filtering: hide steps until detection confirms changes.
+            // Steps only appear when the corresponding flag is explicitly true.
+            // Pre-detection (undefined) hides steps to avoid flash-then-remove.
+            if (step.conditions?.requiresOrgChanges &&
+                context.hasOrgChanges !== true) {
+                return false;
+            }
+            if (step.conditions?.requiresPlatformChanges &&
+                context.hasPlatformChanges !== true) {
+                return false;
+            }
+            if (step.conditions?.requiresAccountChanges &&
+                context.hasAccountChanges !== true) {
+                return false;
+            }
+            if (step.conditions?.requiresDomainConfiguration &&
+                !context.hasDomainConfiguration) {
+                return false;
+            }
+            if (step.conditions?.requiresDomainChanges &&
+                context.hasDomainChanges !== true) {
+                return false;
+            }
+            return true;
+        })
+            .map((step) => {
+            // Dynamically set the name for docker-operations based on context
+            if (step.id === STEP_IDS.DOCKER_OPERATIONS) {
+                return {
+                    ...step,
+                    name: context.hasDockerfile
+                        ? "Building and pushing Docker image"
+                        : "Initialising container repository"
+                };
+            }
+            return step;
+        });
+        return filteredSteps;
+    }
+    /**
+     * Get step names for UI display
+     */
+    static getStepNames(context) {
+        return this.getSteps(context).map((s) => s.name);
+    }
+    /**
+     * Get the index of a specific step in the filtered list
+     */
+    static getStepIndex(stepId, context) {
+        const steps = this.getSteps(context);
+        return steps.findIndex((s) => s.id === stepId);
+    }
+    /**
+     * Get a step by ID from all steps
+     */
+    static getStepById(stepId, deploymentType = "application") {
+        // Search in deploy steps first
+        const deployKey = `${deploymentType}-deploy`;
+        const deploySteps = this.DEPLOYMENT_STEPS.get(deployKey) || [];
+        const found = deploySteps.find((s) => s.id === stepId);
+        if (found)
+            return found;
+        // Then search in destroy steps
+        const destroyKey = `${deploymentType}-destroy`;
+        const destroySteps = this.DEPLOYMENT_STEPS.get(destroyKey) || [];
+        return destroySteps.find((s) => s.id === stepId);
+    }
+    /**
+     * Check if a step should be included based on context
+     */
+    static isStepIncluded(stepId, context) {
+        const steps = this.getSteps(context);
+        return steps.some((s) => s.id === stepId);
+    }
+    /**
+     * Convenience method for creating context
+     */
+    static createContext(deploymentType, operation, options) {
+        return {
+            deploymentType,
+            operation,
+            deployOnly: options?.deployOnly ?? false,
+            infraOnly: options?.infraOnly ?? false,
+            isManagedAccount: options?.isManagedAccount ?? false,
+            hasDockerfile: options?.hasDockerfile ?? false,
+            pattern: options?.pattern ?? null,
+            builderName: options?.builderName,
+            resources: options?.resources
+        };
+    }
+    /**
+     * Get all deployment types
+     */
+    static getDeploymentTypes() {
+        return ["application", "organisation", "platform", "account"];
+    }
+    /**
+     * Get stack names for a deployment type
+     */
+    static getStackNames(deploymentType) {
+        switch (deploymentType) {
+            case "application":
+                return [...APPLICATION_DEPLOY_ORDER];
+            case "organisation":
+                return ["Organisation"];
+            case "platform":
+                return ["Platform"];
+            case "account":
+                return ["Account"];
+            default:
+                return [];
+        }
+    }
+    /**
+     * Get infrastructure step IDs for skipping
+     */
+    static getInfraStepIds() {
+        return [
+            STEP_IDS.CFN_CHECK,
+            STEP_IDS.BOOTSTRAP,
+            STEP_IDS.DIFF,
+            STEP_IDS.NETWORK,
+            STEP_IDS.STORAGE,
+            STEP_IDS.MESSAGING,
+            STEP_IDS.DATABASE,
+            STEP_IDS.COMPUTE,
+            STEP_IDS.CDN
+        ];
+    }
+    /**
+     * Get Docker step IDs for skipping
+     */
+    static getDockerStepIds() {
+        return [
+            STEP_IDS.ECR_INIT,
+            STEP_IDS.DOCKER_DEPLOY,
+            STEP_IDS.ECS_UPDATE,
+            STEP_IDS.ECS_MONITOR
+        ];
+    }
+}

package/dist/src/types/FjallState.js

@@ -1,118 +1 @@
-import { z } from "zod";
-import { readFile, writeFile, unlink, rename, mkdir } from "fs/promises";
-import { dirname, join } from "path";
-import { fileExists } from "../util/fsHelpers.js";
-import { logger, getErrorMessage } from "@fjall/util";
-const TemplateHashEntrySchema = z
-    .object({
-    hash: z.string(),
-    deployedAt: z.string(),
-    stackStatus: z.string().optional()
-})
-    .strict();
-/**
- * State file schema for hash-based change detection.
- * Location: fjall/{appName}/.fjall-state.json
- */
-export const FjallStateFileSchema = z
-    .object({
-    version: z.literal(1),
-    lastDeployedAt: z.string().optional(),
-    templateHashes: z.record(z.string(), TemplateHashEntrySchema),
-    metadata: z.record(z.string(), z.unknown()).optional()
-})
-    .strict();
-const STATE_FILE_NAME = ".fjall-state.json";
-/**
- * Get the state file path for an application
- */
-export function getStateFilePath(appPath) {
-    return join(appPath, STATE_FILE_NAME);
-}
-/**
- * Read state file from application directory.
- * Returns null if file doesn't exist or is corrupt (graceful degradation).
- */
-export async function readStateFile(appPath) {
-    const statePath = getStateFilePath(appPath);
-    if (!(await fileExists(statePath))) {
-        return null;
-    }
-    try {
-        const content = await readFile(statePath, "utf-8");
-        const parsed = JSON.parse(content);
-        const result = FjallStateFileSchema.safeParse(parsed);
-        if (!result.success) {
-            return null;
-        }
-        return result.data;
-    }
-    catch (err) {
-        logger.debug("FjallState", "Failed to read state file", {
-            path: statePath,
-            error: getErrorMessage(err)
-        });
-        return null;
-    }
-}
-/**
- * Write state file atomically using temp file + rename pattern.
- * Prevents partial writes from corrupting the state file.
- */
-export async function writeStateFile(appPath, state) {
-    const statePath = getStateFilePath(appPath);
-    const tempPath = `${statePath}.${Date.now()}.tmp`;
-    await mkdir(dirname(statePath), { recursive: true });
-    try {
-        await writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
-        await rename(tempPath, statePath);
-    }
-    catch (error) {
-        try {
-            await unlink(tempPath);
-        }
-        catch {
-            // Temp file cleanup is non-fatal
-        }
-        throw error;
-    }
-}
-/**
- * Create an empty state file structure
- */
-export function createEmptyState() {
-    return {
-        version: 1,
-        templateHashes: {}
-    };
-}
-/**
- * Delete state file for an application directory.
- * No-op if the file does not exist.
- */
-export async function deleteStateFile(appPath) {
-    const statePath = getStateFilePath(appPath);
-    try {
-        await unlink(statePath);
-    }
-    catch {
-        /* file may not exist */
-    }
-}
-/**
- * Update a single template hash in the state
- */
-export function updateTemplateHash(state, stackName, hash, stackStatus) {
-    return {
-        ...state,
-        lastDeployedAt: new Date().toISOString(),
-        templateHashes: {
-            ...state.templateHashes,
-            [stackName]: {
-                hash,
-                deployedAt: new Date().toISOString(),
-                ...(stackStatus !== undefined && { stackStatus })
-            }
-        }
-    };
-}
+import{z as e}from"zod";import{randomBytes as d}from"crypto";import{readFile as u,writeFile as m,unlink as c,rename as f,mkdir as h}from"fs/promises";import{dirname as S,join as g}from"path";import{fileExists as y}from"@fjall/util/fsHelpers";import{logger as i}from"@fjall/util/logger";import{getErrorMessage as l}from"@fjall/util";const w=e.object({hash:e.string(),deployedAt:e.string(),stackStatus:e.string().optional()}).strict(),F=e.object({version:e.literal(1),lastDeployedAt:e.string().optional(),templateHashes:e.record(e.string(),w),metadata:e.record(e.string(),e.unknown()).optional()}).strict(),j=".fjall-state.json";function s(r){return g(r,j)}async function D(r){const a=s(r);if(!await y(a))return null;try{const t=await u(a,"utf-8"),n=JSON.parse(t),o=F.safeParse(n);return o.success?o.data:null}catch(t){return i.debug("FjallState","Failed to read state file",{path:a,error:l(t)}),null}}async function N(r,a){const t=s(r),n=`${t}.${Date.now()}-${d(4).toString("hex")}.tmp`;await h(S(t),{recursive:!0});try{await m(n,JSON.stringify(a,null,2),"utf-8"),await f(n,t)}catch(o){try{await c(n)}catch(p){i.debug("FjallState","Temp file cleanup failed (non-fatal)",{path:n,error:l(p)})}throw o}}function O(){return{version:1,templateHashes:{}}}async function k(r){const a=s(r);try{await c(a)}catch(t){(typeof t=="object"&&t!==null&&"code"in t?t.code:void 0)!=="ENOENT"&&i.warn("FjallState","Failed to delete state file",{path:a,error:l(t)})}}function v(r,a,t,n){return{...r,lastDeployedAt:new Date().toISOString(),templateHashes:{...r.templateHashes,[a]:{hash:t,deployedAt:new Date().toISOString(),...n!==void 0&&{stackStatus:n}}}}}export{F as FjallStateFileSchema,O as createEmptyState,k as deleteStateFile,s as getStateFilePath,D as readStateFile,v as updateTemplateHash,N as writeStateFile};

package/dist/src/types/ProgressEvent.js

@@ -1,48 +1 @@
-/**
- * Progress callbacks used by infrastructure services.
- *
- * This is the simpler callback interface used by inner services
- * (CdkService, CloudFormationService). The orchestration layer
- * bridges between DeployCallbacks and ProgressCallbacks.
- */
-/**
- * Helper to create progress events with optional typing
- */
-export class ProgressReporter {
-    callbacks;
-    stepIndex = 0;
-    totalSteps;
-    constructor(callbacks) {
-        this.callbacks = callbacks;
-    }
-    setTotalSteps(total) {
-        this.totalSteps = total;
-    }
-    step(message, options) {
-        const { metadata, stepIndex, totalSteps } = options ?? {};
-        this.callbacks?.onProgress?.({
-            type: "step",
-            message,
-            metadata: {
-                ...metadata,
-                stepIndex: stepIndex ?? this.stepIndex++,
-                totalSteps: totalSteps ?? this.totalSteps
-            }
-        });
-    }
-    info(message, metadata) {
-        this.callbacks?.onProgress?.({ type: "info", message, metadata });
-    }
-    spinner(message, metadata) {
-        this.callbacks?.onProgress?.({ type: "spinner", message, metadata });
-    }
-    warning(message, metadata) {
-        this.callbacks?.onProgress?.({ type: "warning", message, metadata });
-    }
-    debug(message, metadata) {
-        this.callbacks?.onProgress?.({ type: "debug", message, metadata });
-    }
-    error(message, metadata) {
-        this.callbacks?.onProgress?.({ type: "error", message, metadata });
-    }
-}
+class l{callbacks;stepIndex=0;totalSteps;constructor(s){this.callbacks=s}setTotalSteps(s){this.totalSteps=s}step(s,t){const{metadata:e,stepIndex:a,totalSteps:r}=t??{};this.callbacks?.onProgress?.({type:"step",message:s,metadata:{...e,stepIndex:a??this.stepIndex++,totalSteps:r??this.totalSteps}})}info(s,t){this.callbacks?.onProgress?.({type:"info",message:s,metadata:t})}spinner(s,t){this.callbacks?.onProgress?.({type:"spinner",message:s,metadata:t})}warning(s,t){this.callbacks?.onProgress?.({type:"warning",message:s,metadata:t})}debug(s,t){this.callbacks?.onProgress?.({type:"debug",message:s,metadata:t})}error(s,t){this.callbacks?.onProgress?.({type:"error",message:s,metadata:t})}}export{l as ProgressReporter};