@go-to-k/cdkd 0.275.4 → 0.275.6

package/dist/{deploy-engine-CHL0hb1m.js → deploy-engine-D5j6_ZH6.js}

@@ -7,7 +7,7 @@ import { SQSClient } from "@aws-sdk/client-sqs";
 import { PublishCommand, SNSClient } from "@aws-sdk/client-sns";
 import { GetFunctionCommand, GetFunctionUrlConfigCommand, InvokeCommand, LambdaClient, UpdateFunctionConfigurationCommand, waitUntilFunctionActiveV2, waitUntilFunctionUpdatedV2 } from "@aws-sdk/client-lambda";
 import { AssumeRoleCommand, GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
-import { DescribeAvailabilityZonesCommand, DescribeImagesCommand, DescribeInstancesCommand, DescribeLaunchTemplatesCommand, DescribeRouteTablesCommand, DescribeSecurityGroupsCommand, DescribeSubnetsCommand, DescribeVpcsCommand, DescribeVpnGatewaysCommand, EC2Client, ModifyInstanceAttributeCommand } from "@aws-sdk/client-ec2";
+import { CreateSnapshotCommand, DescribeAvailabilityZonesCommand, DescribeImagesCommand, DescribeInstancesCommand, DescribeLaunchTemplatesCommand, DescribeRouteTablesCommand, DescribeSecurityGroupsCommand, DescribeSnapshotsCommand, DescribeSubnetsCommand, DescribeVpcsCommand, DescribeVpnGatewaysCommand, EC2Client, ModifyInstanceAttributeCommand } from "@aws-sdk/client-ec2";
 import { DescribeTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { CloudFormationClient, CreateChangeSetCommand, DeleteStackCommand, DescribeChangeSetCommand, DescribeTypeCommand, GetTemplateCommand, waitUntilChangeSetCreateComplete } from "@aws-sdk/client-cloudformation";
 import { APIGatewayClient, GetRestApiCommand } from "@aws-sdk/client-api-gateway";
@@ -12038,9 +12038,10 @@ var CloudControlProvider = class {
 	*/
 	async delete(logicalId, physicalId, resourceType, _properties, context) {
 		this.logger.debug(`Deleting resource ${logicalId} (${resourceType}), physical ID: ${physicalId}`);
+		if (context?.finalSnapshotIdentifier !== void 0) throw new ProvisioningError(`${logicalId} (${resourceType}) requires a final snapshot (DeletionPolicy: Snapshot), but the Cloud Control API delete route has no final-snapshot parameter. Re-run with --skip-final-snapshot after snapshotting manually, or retain the resource.`, resourceType, logicalId, physicalId);
 		if (context?.removeProtection === true && resourceType === "AWS::AutoScaling::AutoScalingGroup") {
 			this.logger.debug(`Delegating protected AutoScalingGroup ${logicalId} delete to the SDK ASGProvider (Cloud Control cannot force-delete a protected ASG)`);
-			const { ASGProvider } = await import("./asg-provider-BxpwCQGo.js").then((n) => n.n);
+			const { ASGProvider } = await import("./asg-provider-zDD6EIRo.js").then((n) => n.n);
 			await new ASGProvider().delete(logicalId, physicalId, resourceType, _properties, context);
 			return;
 		}
@@ -15101,7 +15102,7 @@ const PROPERTY_COVERAGE_BY_TYPE = /* @__PURE__ */ new Map([
 			["DBClusterParameterGroupName", "not yet implemented by cdkd"],
 			["DBInstanceParameterGroupName", "not yet implemented by cdkd"],
 			["DBSystemId", "not yet implemented by cdkd"],
-			["DeleteAutomatedBackups", "cdkd hardcodes SkipFinalSnapshot=true on destroy; this CFn lifecycle flag has no equivalent on the runtime path"],
+			["DeleteAutomatedBackups", "delete-time lifecycle flag not threaded through cdkd destroy; final snapshots are governed by DeletionPolicy: Snapshot (issue #1352), which this flag does not control"],
 			["Domain", "not yet implemented by cdkd"],
 			["DomainIAMRoleName", "not yet implemented by cdkd"],
 			["EnableCloudwatchLogsExports", "not yet implemented by cdkd"],
@@ -15180,7 +15181,7 @@ const PROPERTY_COVERAGE_BY_TYPE = /* @__PURE__ */ new Map([
 			["DBSnapshotIdentifier", "not yet implemented by cdkd"],
 			["DBSystemId", "not yet implemented by cdkd"],
 			["DedicatedLogVolume", "not yet implemented by cdkd"],
-			["DeleteAutomatedBackups", "cdkd hardcodes SkipFinalSnapshot=true on destroy; this CFn lifecycle flag has no equivalent on the runtime path"],
+			["DeleteAutomatedBackups", "delete-time lifecycle flag not threaded through cdkd destroy; final snapshots are governed by DeletionPolicy: Snapshot (issue #1352), which this flag does not control"],
 			["Domain", "not yet implemented by cdkd"],
 			["DomainAuthSecretArn", "not yet implemented by cdkd"],
 			["DomainDnsIps", "not yet implemented by cdkd"],
@@ -17030,6 +17031,182 @@ function extractDeploymentEventError(err) {
 	return result;
 }
 
+//#endregion
+//#region src/provisioning/final-snapshot.ts
+/**
+* `DeletionPolicy: Snapshot` support (issue #1352).
+*
+* CloudFormation creates a final snapshot BEFORE deleting a resource whose
+* `DeletionPolicy` is `Snapshot`. cdkd historically treated the policy as
+* `Delete` (no snapshot — silent data loss vs CFn, live-A/B-confirmed on
+* `AWS::EC2::Volume`). The destroy paths now honor the policy through the
+* two mechanisms below; a Snapshot-tagged type supported by NEITHER is
+* refused with an actionable error unless `--skip-final-snapshot` opts into
+* the data loss.
+*
+* The full CFn-documented Snapshot-capable type list (CFn refuses the
+* attribute on anything else): AWS::EC2::Volume, AWS::ElastiCache::CacheCluster,
+* AWS::ElastiCache::ReplicationGroup, AWS::Neptune::DBCluster,
+* AWS::RDS::DBCluster, AWS::RDS::DBInstance, AWS::Redshift::Cluster,
+* AWS::DocDB::DBCluster.
+*/
+/**
+* Types whose delete API takes an atomic final-snapshot parameter. The
+* destroy paths generate a snapshot identifier and pass it via
+* `DeleteContext.finalSnapshotIdentifier`; the type's SDK provider flips its
+* delete call from `SkipFinalSnapshot: true` to the final-snapshot form.
+*/
+const ATOMIC_FINAL_SNAPSHOT_TYPES = /* @__PURE__ */ new Set([
+	"AWS::RDS::DBInstance",
+	"AWS::RDS::DBCluster",
+	"AWS::Neptune::DBCluster",
+	"AWS::DocDB::DBCluster",
+	"AWS::ElastiCache::CacheCluster"
+]);
+/**
+* Types with no atomic delete parameter, where cdkd snapshots explicitly
+* BEFORE the (routing-layer-agnostic) delete. `AWS::EC2::Volume` is
+* CC-API-routed, so the pre-delete snapshot lives at the destroy call sites,
+* not in a provider.
+*/
+const PRE_DELETE_SNAPSHOT_TYPES = /* @__PURE__ */ new Set(["AWS::EC2::Volume"]);
+/**
+* CFn-documented Snapshot-capable types cdkd cannot snapshot yet (issue
+* #1353): named in the refusal error so users know the policy is valid,
+* just unimplemented — as opposed to a template mistake.
+*/
+const UNSUPPORTED_FINAL_SNAPSHOT_TYPES = /* @__PURE__ */ new Set(["AWS::Redshift::Cluster", "AWS::ElastiCache::ReplicationGroup"]);
+/**
+* Build the final-snapshot identifier for an atomic-parameter delete.
+*
+* Constraints are the intersection of the RDS / Neptune / DocDB snapshot
+* identifier rules and the ElastiCache snapshot name rules: start with a
+* letter, letters/digits/hyphens only, no consecutive or trailing hyphen.
+* The physical id already satisfies the source API's naming rules; it is
+* lowercased (RDS canonicalizes to lowercase anyway) and defensively
+* re-sanitized. A UTC timestamp suffix keeps repeated destroys of a
+* re-created same-name resource from colliding; within ONE destroy run the
+* identifier is generated once per resource, so delete retries reuse it.
+*/
+function buildFinalSnapshotIdentifier(physicalId, resourceType, now = /* @__PURE__ */ new Date()) {
+	const ts = now.toISOString().replace(/[-:]/g, "").replace(/\..*$/, "").replace("T", "-").toLowerCase();
+	let base = physicalId.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+	if (!/^[a-z]/.test(base)) base = `r${base}`;
+	const maxLength = resourceType === "AWS::ElastiCache::CacheCluster" ? 50 : 255;
+	const suffix = `-final-${ts}`;
+	base = base.slice(0, maxLength - suffix.length).replace(/-+$/, "");
+	return `${base}${suffix}`;
+}
+/** Tag key marking a cdkd-created final snapshot of an EBS volume. */
+const EBS_FINAL_SNAPSHOT_TAG_KEY = "cdkd:final-snapshot-of";
+/** Test seam (matches the `describe-type.ts` / macro-expander pattern). */
+const finalSnapshotDelays = { sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)) };
+const EBS_SNAPSHOT_POLL_INTERVAL_MS = 5e3;
+const EBS_SNAPSHOT_TIMEOUT_MS = 3600 * 1e3;
+function errMsg(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isVolumeNotFound(error) {
+	return (error instanceof Error ? error.name : "") === "InvalidVolume.NotFound" || errMsg(error).includes("InvalidVolume.NotFound");
+}
+/**
+* Create (or resume waiting on) the final EBS snapshot of a volume and wait
+* until it completes, mirroring CloudFormation's observable behavior — CFn
+* deletes the volume only after the final snapshot is done.
+*
+* Idempotent across destroy re-runs: an existing pending/completed snapshot
+* carrying the `cdkd:final-snapshot-of: <volumeId>` tag is reused instead of
+* creating a second one.
+*
+* @returns the snapshot id, or `null` when the volume no longer exists
+*   (nothing to snapshot; the subsequent delete is idempotent too).
+*/
+async function createEbsFinalSnapshot(client, volumeId, logicalId, logger) {
+	let snapshotId;
+	try {
+		snapshotId = (await client.send(new DescribeSnapshotsCommand({
+			OwnerIds: ["self"],
+			Filters: [{
+				Name: `tag:${EBS_FINAL_SNAPSHOT_TAG_KEY}`,
+				Values: [volumeId]
+			}, {
+				Name: "status",
+				Values: ["pending", "completed"]
+			}]
+		}))).Snapshots?.[0]?.SnapshotId;
+		if (snapshotId) logger.debug(`Reusing existing final snapshot ${snapshotId} for ${logicalId} (${volumeId}) from a previous destroy attempt`);
+	} catch (probeError) {
+		logger.debug(`Final-snapshot reuse probe failed for ${volumeId}: ${errMsg(probeError)}`);
+	}
+	if (!snapshotId) try {
+		snapshotId = (await client.send(new CreateSnapshotCommand({
+			VolumeId: volumeId,
+			Description: `cdkd final snapshot for ${volumeId} (DeletionPolicy: Snapshot)`,
+			TagSpecifications: [{
+				ResourceType: "snapshot",
+				Tags: [{
+					Key: EBS_FINAL_SNAPSHOT_TAG_KEY,
+					Value: volumeId
+				}]
+			}]
+		}))).SnapshotId;
+	} catch (createError) {
+		if (isVolumeNotFound(createError)) {
+			logger.debug(`Volume ${volumeId} no longer exists — skipping final snapshot for ${logicalId}`);
+			return null;
+		}
+		throw new CdkdError(`Failed to create the final snapshot for ${logicalId} (${volumeId}) required by DeletionPolicy: Snapshot: ${errMsg(createError)}. The volume was NOT deleted.`, "FINAL_SNAPSHOT_FAILED");
+	}
+	if (!snapshotId) throw new CdkdError(`CreateSnapshot for ${logicalId} (${volumeId}) returned no snapshot id. The volume was NOT deleted.`, "FINAL_SNAPSHOT_FAILED");
+	logger.info(`Creating final snapshot ${snapshotId} for ${logicalId} (${volumeId}) — DeletionPolicy: Snapshot`);
+	const deadline = Date.now() + EBS_SNAPSHOT_TIMEOUT_MS;
+	let notFoundPolls = 0;
+	for (;;) {
+		let state;
+		try {
+			state = (await client.send(new DescribeSnapshotsCommand({ SnapshotIds: [snapshotId] }))).Snapshots?.[0]?.State;
+			notFoundPolls = 0;
+		} catch (pollError) {
+			if (((pollError instanceof Error ? pollError.name : "") === "InvalidSnapshot.NotFound" || errMsg(pollError).includes("InvalidSnapshot.NotFound")) && ++notFoundPolls <= 24) state = void 0;
+			else throw new CdkdError(`Failed while waiting for final snapshot ${snapshotId} of ${logicalId} (${volumeId}): ${errMsg(pollError)}. The volume was NOT deleted; re-run the destroy (the snapshot is reused, not duplicated).`, "FINAL_SNAPSHOT_FAILED", pollError instanceof Error ? pollError : void 0);
+		}
+		if (state === "completed") {
+			logger.info(`Final snapshot ${snapshotId} completed for ${logicalId} (${volumeId})`);
+			return snapshotId;
+		}
+		if (state === "error") throw new CdkdError(`Final snapshot ${snapshotId} for ${logicalId} (${volumeId}) entered 'error' state. The volume was NOT deleted.`, "FINAL_SNAPSHOT_FAILED");
+		if (Date.now() >= deadline) throw new CdkdError(`Timed out waiting for final snapshot ${snapshotId} of ${logicalId} (${volumeId}) to complete. The volume was NOT deleted; the snapshot continues in AWS — re-run the destroy once it completes (the existing snapshot is reused, not duplicated).`, "FINAL_SNAPSHOT_TIMEOUT");
+		await finalSnapshotDelays.sleep(EBS_SNAPSHOT_POLL_INTERVAL_MS);
+	}
+}
+/**
+* Is this one of the typed final-snapshot failures the destroy call sites
+* must RETHROW before applying their "not found = already deleted"
+* idempotency heuristics? (Those heuristics match message substrings; a raw
+* snapshot-poll NotFound would otherwise be read as "resource already
+* deleted" and strand a live, un-snapshotted volume outside state.)
+*/
+function isFinalSnapshotError(error) {
+	return error instanceof CdkdError && (error.code === "FINAL_SNAPSHOT_FAILED" || error.code === "FINAL_SNAPSHOT_TIMEOUT" || error.code === "FINAL_SNAPSHOT_UNSUPPORTED");
+}
+/**
+* Refusal for an atomic-final-snapshot type whose state records
+* `provisionedBy: 'cc-api'` (#614 silent-drop routing / `--recreate-via-cc-api`).
+* Cloud Control `DeleteResource` has no final-snapshot parameter and
+* `CloudControlProvider` cannot honor `finalSnapshotIdentifier`, so deleting
+* via that route would silently drop the promised snapshot — refuse instead.
+*/
+function ccRoutedFinalSnapshotError(logicalId, resourceType, skipFlagHint) {
+	return new CdkdError(`${logicalId} (${resourceType}) has DeletionPolicy: Snapshot, but the resource is managed via the Cloud Control API route (provisionedBy: cc-api), which has no final-snapshot delete parameter — deleting it now would destroy its data WITHOUT the final snapshot the policy promises. Create a snapshot manually (e.g. aws rds create-db-snapshot / aws elasticache create-snapshot), then re-run with ${skipFlagHint} to delete WITHOUT cdkd's final snapshot (DATA LOSS otherwise), or retain the resource (DeletionPolicy: Retain) and delete it manually.`, "FINAL_SNAPSHOT_UNSUPPORTED");
+}
+/**
+* Build the refusal error for a Snapshot-tagged type cdkd cannot snapshot.
+* Thrown by the destroy call sites BEFORE any delete is issued.
+*/
+function unsupportedFinalSnapshotError(logicalId, resourceType, skipFlagHint) {
+	return new CdkdError(`${logicalId} (${resourceType}) has DeletionPolicy: Snapshot, but${UNSUPPORTED_FINAL_SNAPSHOT_TYPES.has(resourceType) ? " cdkd does not implement final snapshots for this type yet (issue #1353)." : ` cdkd does not implement final snapshots for this type (CloudFormation itself only supports Snapshot on: EC2 Volume, ElastiCache CacheCluster / ReplicationGroup, Neptune / RDS / DocDB clusters, RDS instances, Redshift clusters).`} Deleting it now would destroy its data WITHOUT the final snapshot the policy promises. Re-run with ${skipFlagHint} to delete WITHOUT a final snapshot (DATA LOSS), or retain the resource (DeletionPolicy: Retain) and delete it manually after snapshotting.`, "FINAL_SNAPSHOT_UNSUPPORTED");
+}
+
 //#endregion
 //#region src/analyzer/implicit-delete-deps.ts
 /**
@@ -17817,7 +17994,7 @@ const FLUSH_INTERVAL_MS = 2e3;
 const FLUSH_EVENT_THRESHOLD = 50;
 /** Build-time cdkd version, with a dev fallback for non-built contexts. */
 function getCdkdVersion() {
-	return "0.275.4";
+	return "0.275.6";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -18667,9 +18844,7 @@ var DeployEngine = class {
 		const startTime = Date.now();
 		this.logger.debug(`Starting deployment for stack: ${stackName}`);
 		for (const type of new Set(Object.values(template.Resources).map((r) => r.Type).filter((type) => !hasNoRegistrySchema(type)))) getCreateOnlyPropertyPaths(type).catch(() => {});
-		await this.lockManager.acquireLockWithRetry(stackName, this.stackRegion, void 0, "deploy");
 		const renderer = getLiveRenderer();
-		renderer.start();
 		this.interrupted = false;
 		this.interruptCause = null;
 		const sigintHandler = () => {
@@ -18680,6 +18855,13 @@ var DeployEngine = class {
 			this.interruptCause ??= "user";
 		};
 		process.on("SIGINT", sigintHandler);
+		try {
+			await this.lockManager.acquireLockWithRetry(stackName, this.stackRegion, void 0, "deploy");
+		} catch (error) {
+			process.removeListener("SIGINT", sigintHandler);
+			throw error;
+		}
+		renderer.start();
 		try {
 			const currentStateData = await this.stateBackend.getState(stackName, this.stackRegion);
 			const currentState = currentStateData?.state ?? {
@@ -19636,13 +19818,21 @@ var DeployEngine = class {
 					delete stateResources[logicalId];
 					break;
 				}
+				let finalSnapshotIdentifier;
+				if (deletionPolicy === "Snapshot" && this.options.skipFinalSnapshot !== true) if (ATOMIC_FINAL_SNAPSHOT_TYPES.has(resourceType) && currentResource.provisionedBy !== "cc-api") finalSnapshotIdentifier = buildFinalSnapshotIdentifier(currentResource.physicalId, resourceType);
+				else if (ATOMIC_FINAL_SNAPSHOT_TYPES.has(resourceType)) throw ccRoutedFinalSnapshotError(logicalId, resourceType, "--skip-final-snapshot");
+				else if (PRE_DELETE_SNAPSHOT_TYPES.has(resourceType)) await createEbsFinalSnapshot(this.options.finalSnapshotEc2 ?? getAwsClients().ec2, currentResource.physicalId, logicalId, this.logger);
+				else throw unsupportedFinalSnapshotError(logicalId, resourceType, "--skip-final-snapshot");
 				const deleteProvider = this.providerRegistry.getProviderFor({
 					resourceType,
 					provisionedBy: currentResource.provisionedBy
 				}).provider;
 				this.logger.debug(`Deleting ${logicalId} (${resourceType})`);
 				try {
-					await this.withRetry(() => deleteProvider.delete(logicalId, currentResource.physicalId, resourceType, currentResource.properties, { expectedRegion: this.stackRegion }), logicalId, 3, 5e3, deleteProvider);
+					await this.withRetry(() => deleteProvider.delete(logicalId, currentResource.physicalId, resourceType, currentResource.properties, {
+						expectedRegion: this.stackRegion,
+						...finalSnapshotIdentifier !== void 0 && { finalSnapshotIdentifier }
+					}), logicalId, 3, 5e3, deleteProvider);
 				} catch (deleteError) {
 					const msg = deleteError instanceof Error ? deleteError.message : String(deleteError);
 					if (msg.includes("does not exist") || msg.includes("was not found") || msg.includes("not found") || msg.includes("No policy found") || msg.includes("NoSuchEntity") || msg.includes("NotFoundException") || msg.includes("ResourceNotFoundException")) this.logger.debug(`Resource ${logicalId} already deleted (${msg}), removing from state`);
@@ -19874,5 +20064,5 @@ var DeployEngine = class {
 };
 
 //#endregion
-export { WorkGraph as $, LockError as $t, slowCcOperationTimeoutMs as A, warnDeprecatedNoPrefixCliFlag as At, applyRoleArnIfSet as B, resolveBucketRegion as Bt, yellow as C, resolveAutoAssetStorage as Ct, ProviderRegistry as D, resolveStateBucketWithDefaultAndSource as Dt, clearOnUpdateRemoval as E, resolveStateBucketWithDefault as Et, refStateLookupFromResource as F, uploadCfnTemplate as Ft, DagBuilder as G, AssetError as Gt, describeTypeWithThrottleRetry as H, getAwsClients as Ht, WAFv2WebACLProvider as I, expectedOwnerParam as It, S3StateBackend as J, DependencyError as Jt, TemplateParser as K, CdkdError as Kt, normalizeAwsTagsToCfn as L, AssemblyReader as Lt, isTerminationProtectionPropagationError as M, CFN_TEMPLATE_URL_LIMIT as Mt, IntrinsicFunctionResolver as N, MIGRATE_TMP_PREFIX as Nt, findActionableSilentDrops as O, resolveUseCdkBootstrapAssets as Ot, cfnRefValueFromPhysicalId as P, findLargeInlineResources as Pt, stringifyValue as Q, LocalStartServiceError as Qt, resolveExplicitPhysicalId as R, processStackMessages as Rt, red as S, resolveApp as St, collectInlinePolicyNamesManagedBySiblings as T, resolveSkipPrefix as Tt, withRetry as U, resetAwsClients as Ut, DiffCalculator as V, AwsClients as Vt, isRetryableTransientError as W, setAwsClients as Wt, shouldRetainResource as X, LocalInvokeBuildError as Xt, rebuildClientForBucketRegion as Y, DeployCancelledError as Yt, AssetPublisher as Z, LocalMigrateError as Zt, formatResourceLine as _, getDockerImageBySourceHash as _t, DeploymentEventsStore as a, ResourceUpdateNotSupportedError as an, BOOTSTRAP_MARKER_PREFIX as at, gray as b, getDefaultStateBucketName as bt, replayFailedOperations as c, StateError as cn, parseBootstrapMarker as ct, IMPLICIT_DELETE_DEPENDENCIES as d, isCdkdError as dn, buildDockerImage as dt, MissingCdkCliError as en, buildAssetRedirectMap as et, computeImplicitDeleteEdges as f, normalizeAwsError as fn, formatDockerLoginError as ft, renderStatefulReason as g, AssetManifestLoader as gt, isStatefulRecreateTargetSync as h, runDockerStreaming as ht, DeploymentEventsReader as i, ResourceTimeoutError as in, AssetModeResolver as it, disableInstanceApiTermination as j, CFN_TEMPLATE_BODY_LIMIT as jt, CloudControlProvider as k, stateBucketExistenceConfirmed as kt, replayRollback as l, SynthesisError as ln, validateAssetBucketName as lt, MULTI_REGION_RECREATE_BLOCKED_TYPES as m, __exportAll as mn, runDockerForeground as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, PartialFailureError as nn, loadPublishableAssetManifest as nt, planFailedOps as o, StackHasActiveImportsError as on, ensureAssetStorage as ot, extractDeploymentEventError as p, withErrorHandling as pn, getDockerCmd as pt, LockManager as q, ConfigError as qt, DeployEngine as r, ProvisioningError as rn, rewriteTemplateAssetReferences as rt, planRollback as s, StackTerminationProtectionError as sn, getBootstrapMarkerKey as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, NestedStackChildDirectDestroyError as tn, createAssetRedirectResolver as tt, withResourceDeadline as u, formatError as un, validateContainerRepoName as ut, bold as v, Synthesizer as vt, IAMRoleProvider as w, resolveCaptureObservedState as wt, green as x, getLegacyStateBucketName as xt, cyan as y, synthesisStatusMessage as yt, assertRegionMatch as z, clearBucketRegionCache as zt };
-//# sourceMappingURL=deploy-engine-CHL0hb1m.js.map
+export { TemplateParser as $, CdkdError as $t, yellow as A, resolveAutoAssetStorage as At, IntrinsicFunctionResolver as B, MIGRATE_TMP_PREFIX as Bt, renderStatefulReason as C, AssetManifestLoader as Ct, gray as D, getDefaultStateBucketName as Dt, cyan as E, synthesisStatusMessage as Et, findActionableSilentDrops as F, resolveUseCdkBootstrapAssets as Ft, resolveExplicitPhysicalId as G, processStackMessages as Gt, refStateLookupFromResource as H, uploadCfnTemplate as Ht, CloudControlProvider as I, stateBucketExistenceConfirmed as It, DiffCalculator as J, AwsClients as Jt, assertRegionMatch as K, clearBucketRegionCache as Kt, slowCcOperationTimeoutMs as L, warnDeprecatedNoPrefixCliFlag as Lt, collectInlinePolicyNamesManagedBySiblings as M, resolveSkipPrefix as Mt, clearOnUpdateRemoval as N, resolveStateBucketWithDefault as Nt, green as O, getLegacyStateBucketName as Ot, ProviderRegistry as P, resolveStateBucketWithDefaultAndSource as Pt, DagBuilder as Q, AssetError as Qt, disableInstanceApiTermination as R, CFN_TEMPLATE_BODY_LIMIT as Rt, isStatefulRecreateTargetSync as S, runDockerStreaming as St, bold as T, Synthesizer as Tt, WAFv2WebACLProvider as U, expectedOwnerParam as Ut, cfnRefValueFromPhysicalId as V, findLargeInlineResources as Vt, normalizeAwsTagsToCfn as W, AssemblyReader as Wt, withRetry as X, resetAwsClients as Xt, describeTypeWithThrottleRetry as Y, getAwsClients as Yt, isRetryableTransientError as Z, setAwsClients as Zt, createEbsFinalSnapshot as _, formatError as _n, validateContainerRepoName as _t, DeploymentEventsStore as a, LocalStartServiceError as an, stringifyValue as at, extractDeploymentEventError as b, withErrorHandling as bn, getDockerCmd as bt, replayFailedOperations as c, NestedStackChildDirectDestroyError as cn, createAssetRedirectResolver as ct, IMPLICIT_DELETE_DEPENDENCIES as d, ResourceTimeoutError as dn, AssetModeResolver as dt, ConfigError as en, LockManager as et, computeImplicitDeleteEdges as f, ResourceUpdateNotSupportedError as fn, BOOTSTRAP_MARKER_PREFIX as ft, ccRoutedFinalSnapshotError as g, SynthesisError as gn, validateAssetBucketName as gt, buildFinalSnapshotIdentifier as h, StateError as hn, parseBootstrapMarker as ht, DeploymentEventsReader as i, LocalMigrateError as in, AssetPublisher as it, IAMRoleProvider as j, resolveCaptureObservedState as jt, red as k, resolveApp as kt, replayRollback as l, PartialFailureError as ln, loadPublishableAssetManifest as lt, PRE_DELETE_SNAPSHOT_TYPES as m, StackTerminationProtectionError as mn, getBootstrapMarkerKey as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, DeployCancelledError as nn, rebuildClientForBucketRegion as nt, planFailedOps as o, LockError as on, WorkGraph as ot, ATOMIC_FINAL_SNAPSHOT_TYPES as p, StackHasActiveImportsError as pn, ensureAssetStorage as pt, applyRoleArnIfSet as q, resolveBucketRegion as qt, DeployEngine as r, LocalInvokeBuildError as rn, shouldRetainResource as rt, planRollback as s, MissingCdkCliError as sn, buildAssetRedirectMap as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, DependencyError as tn, S3StateBackend as tt, withResourceDeadline as u, ProvisioningError as un, rewriteTemplateAssetReferences as ut, isFinalSnapshotError as v, isCdkdError as vn, buildDockerImage as vt, formatResourceLine as w, getDockerImageBySourceHash as wt, MULTI_REGION_RECREATE_BLOCKED_TYPES as x, __exportAll as xn, runDockerForeground as xt, unsupportedFinalSnapshotError as y, normalizeAwsError as yn, formatDockerLoginError as yt, isTerminationProtectionPropagationError as z, CFN_TEMPLATE_URL_LIMIT as zt };
+//# sourceMappingURL=deploy-engine-D5j6_ZH6.js.map