@go-to-k/cdkd 0.264.0 → 0.264.2

package/dist/{deploy-engine-hlS6y_-0.js → deploy-engine-CaquB01e.js}

@@ -11260,7 +11260,7 @@ var CloudControlProvider = class {
 		this.logger.debug(`Deleting resource ${logicalId} (${resourceType}), physical ID: ${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-B5N9p1vq.js").then((n) => n.n);
+			const { ASGProvider } = await import("./asg-provider-Bxida3ei.js").then((n) => n.n);
 			await new ASGProvider().delete(logicalId, physicalId, resourceType, _properties, context);
 			return;
 		}
@@ -11934,10 +11934,10 @@ var CustomResourceProvider = class CustomResourceProvider {
 	responseClientResolveInFlight = null;
 	responseClientGeneration = 0;
 	/**
-	* Whether `this.s3Client` is a provider-OWNED client (built from the
-	* `setResponseBucket` region hint or by a region-correction rebuild)
-	* vs the shared `AwsClients.s3` instance from the constructor. Owned
-	* clients are `destroy()`ed when replaced; the shared one never is.
+	* Whether `this.s3Client` is a provider-OWNED client (built by a
+	* region-correction rebuild) vs the shared `AwsClients.s3` instance
+	* from the constructor. Owned clients are `destroy()`ed when replaced;
+	* the shared one never is.
 	*/
 	ownsS3Client = false;
 	/**
@@ -12015,12 +12015,20 @@ var CustomResourceProvider = class CustomResourceProvider {
 		return this.asyncResponseTimeoutMs;
 	}
 	/**
-	* Set the S3 bucket for custom resource responses
-	* Called by ProviderRegistry when state bucket is configured
-	*/
-	setResponseBucket(bucket, bucketRegion) {
+	* Set the S3 bucket for custom resource responses.
+	* Called by ProviderRegistry when the state bucket is configured.
+	*
+	* There is deliberately NO region parameter (issue #1202): the bucket's
+	* ACTUAL region is resolved lazily via `ensureResponseClient()` before
+	* the first S3 operation (issue #1195), starting from the shared
+	* `AwsClients.s3` client so `--profile` / static credentials carry into
+	* both the `GetBucketLocation` probe and the rebuilt client. The former
+	* deploy-region hint parameter built a default-credential-chain client
+	* (dropping `--profile`) and added nothing — the probe resolves the
+	* bucket's real region regardless of the starting client's region.
+	*/
+	setResponseBucket(bucket) {
 		this.responseBucket = bucket;
-		if (bucketRegion) this.replaceS3Client(new S3Client({ region: bucketRegion }));
 		this.responseClientGeneration++;
 		this.responseClientResolved = false;
 		this.responseClientResolveInFlight = null;
@@ -14893,8 +14901,8 @@ var ProviderRegistry = class {
 	* Configure the response bucket for custom resources
 	* This allows Lambda handlers using cfn-response to send responses via S3
 	*/
-	setCustomResourceResponseBucket(bucket, bucketRegion) {
-		this.customResourceProvider.setResponseBucket(bucket, bucketRegion);
+	setCustomResourceResponseBucket(bucket) {
+		this.customResourceProvider.setResponseBucket(bucket);
 		this.logger.debug(`Custom resource response bucket set to: ${bucket}`);
 	}
 	/**
@@ -16387,6 +16395,53 @@ function isRetryableTransientError(error, message) {
 	if (isThrottlingError(error)) return true;
 	return RETRYABLE_ERROR_MESSAGE_PATTERNS.some((p) => message.includes(p));
 }
+/**
+* Match the "already exists" name-collision signature raised when a create
+* targets a physical name still held by another resource (or by the same
+* name's not-yet-released tombstone after an async delete).
+*
+* Deliberately NOT part of {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}: a name
+* collision is only worth retrying at the specific re-create sites that just
+* deleted the old holder (the deploy engine's --replace delete-first fallback
+* and the rollback executor's reverse-replacement) — everywhere else it is a
+* genuine conflict that must fail fast. Shared by those sites' collision
+* detection + retry filters so a signature extension lands in one place.
+*/
+function isNameCollisionError(message) {
+	return /already exists/i.test(message) || message.includes("AlreadyExists");
+}
+/**
+* Match the SQS same-name re-creation cooldown: after `DeleteQueue`, creating
+* a queue with the SAME name inside ~60s fails with
+* `AWS.SimpleQueueService.QueueDeletedRecently` ("You must wait 60 seconds
+* after deleting a queue before you can create another with the same name").
+*
+* The generic transient table above already carries 'wait 60 seconds' for
+* plain CREATEs (rapid destroy → redeploy loops), but the delete-then-re-create
+* sites (the deploy engine's --replace delete-first fallback and the rollback
+* executor's reverse-replacement) override the retry filter with
+* {@link isNameCollisionError}, which this signature does NOT match — so a
+* replacement revert used to fail fast mid-flight with the resource absent
+* from both AWS and state (issue #1206). Those sites now OR this matcher into
+* their retry filter, with a schedule long enough to cover the 60s window.
+*
+* Kept separate from {@link isNameCollisionError} on purpose: a cooldown at a
+* create-first site must NOT be treated as a collision (deleting the new
+* resource would not release the cooldown on the old name).
+*/
+function isNameCooldownError(message) {
+	return message.includes("QueueDeletedRecently") || message.includes("wait 60 seconds");
+}
+/**
+* Retry filter for the delete-then-re-create sites: the old name holder was
+* just deleted, so both the late name release ("already exists" from an async
+* delete) and the SQS 60s name cooldown are worth waiting out. Pair with a
+* schedule that covers the full cooldown window (maxRetries 8, delays
+* 2s/4s/8s then capped at 10s ≈ 64s total sleep).
+*/
+function isRecreateRetryableError(message) {
+	return isNameCollisionError(message) || isNameCooldownError(message);
+}
 
 //#endregion
 //#region src/deployment/retry.ts
@@ -16506,6 +16561,17 @@ async function withResourceDeadline(operation, opts) {
 //#endregion
 //#region src/deployment/rollback-executor.ts
 /**
+* Retry schedule for a re-create that must wait out a name-release delay:
+* an async delete's late name release ("already exists") or the SQS 60s
+* same-name cooldown (issue #1206). 2s/4s/8s then capped at 10s over 8
+* retries ≈ 64s of total sleep — enough to cover the full cooldown window.
+*/
+const RECREATE_RETRY_SCHEDULE = {
+	maxRetries: 8,
+	initialDelayMs: 2e3,
+	maxDelayMs: 1e4
+};
+/**
 * True when the op recorded a replacement (old physical id differs from the
 * new one). The old physical resource is already gone / orphaned, so an
 * in-place revert is best-effort — the plan labels these explicitly.
@@ -16775,10 +16841,17 @@ async function replaySingle(op, stateResources, stackName, ctx, orphanLogicalIds
 				let deletedNewFirst = false;
 				let createResult;
 				try {
-					createResult = await createProvider.create(op.logicalId, op.resourceType, { ...prev.properties });
+					createResult = await withRetry(() => createProvider.create(op.logicalId, op.resourceType, { ...prev.properties }), op.logicalId, {
+						...RECREATE_RETRY_SCHEDULE,
+						logger,
+						...isInterrupted && {
+							isInterrupted,
+							onInterrupted: () => /* @__PURE__ */ new Error("Rollback interrupted while waiting out the name cooldown")
+						},
+						isRetryable: isNameCooldownError
+					});
 				} catch (createError) {
-					const msg = createError instanceof Error ? createError.message : String(createError);
-					if (!(/already exists/i.test(msg) || msg.includes("AlreadyExists"))) throw createError;
+					if (!isNameCollisionError(createError instanceof Error ? createError.message : String(createError))) throw createError;
 					logger.info(`  Rollback: re-create collided with the new resource's name — deleting the new resource (${current.physicalId}) first...`);
 					await newDeleteProvider.delete(op.logicalId, current.physicalId, op.resourceType, current.properties, { expectedRegion: ctx.region });
 					deletedNewFirst = true;
@@ -16786,15 +16859,13 @@ async function replaySingle(op, stateResources, stackName, ctx, orphanLogicalIds
 					await afterOp?.(op.logicalId);
 					try {
 						createResult = await withRetry(() => createProvider.create(op.logicalId, op.resourceType, { ...prev.properties }), op.logicalId, {
-							maxRetries: 5,
-							initialDelayMs: 2e3,
-							maxDelayMs: 1e4,
+							...RECREATE_RETRY_SCHEDULE,
 							logger,
 							...isInterrupted && {
 								isInterrupted,
 								onInterrupted: () => /* @__PURE__ */ new Error("Rollback interrupted while waiting for the old name to release")
 							},
-							isRetryable: (message) => /already exists/i.test(message) || message.includes("AlreadyExists")
+							isRetryable: isRecreateRetryableError
 						});
 					} catch (recreateError) {
 						throw new Error(`Failed to re-create the old ${op.logicalId} after the new resource (${current.physicalId}) was already deleted: ${recreateError instanceof Error ? recreateError.message : String(recreateError)}. The resource is now absent — fix forward with 'cdkd deploy'.`);
@@ -17072,7 +17143,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.264.0";
+	return "0.264.2";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -18643,7 +18714,7 @@ var DeployEngine = class {
 							createResult = await this.withRetry(() => replaceProvider.create(logicalId, resourceType, replaceProps), logicalId, void 0, void 0, replaceProvider);
 						} catch (createError) {
 							const createMsg = createError instanceof Error ? createError.message : String(createError);
-							if (!(/already exists/i.test(createMsg) || createMsg.includes("AlreadyExists"))) throw createError;
+							if (!isNameCollisionError(createMsg)) throw createError;
 							if (updateReplacePolicy === "Retain") throw new CdkdError(`${logicalId} (${resourceType}) requires replacement, but its user-supplied physical name is still held by the existing resource AND UpdateReplacePolicy: Retain pins that resource in place. Rename the resource in your CDK code — with Retain, the old resource keeps the name, so a same-name replacement can never proceed.`, "NAMED_REPLACEMENT_COLLISION");
 							if (this.options.replace !== true) throw new CdkdError(`${logicalId} (${resourceType}) requires replacement, but the create-first attempt collided with the existing resource: ${createMsg}. The resource has a user-supplied physical name, so the CloudFormation-style safe replacement order (create the new resource before deleting the old) cannot reuse the occupied name — CloudFormation refuses this shape with "cannot update a stack when a custom-named resource requires replacing". Either rename the resource in your CDK code (a fresh name lets the safe create-first order proceed), or re-run with \`cdkd deploy --replace\` to delete the old resource FIRST and recreate it under the same name (the resource is briefly unavailable while it is recreated).`, "NAMED_REPLACEMENT_COLLISION");
 							this.logger.info(`  Create-first collided with the custom-named resource and --replace is set — deleting old ${logicalId} (${currentResource.physicalId}) first...`);
@@ -18657,13 +18728,13 @@ var DeployEngine = class {
 							this.logger.info(`  Re-creating ${logicalId}...`);
 							try {
 								createResult = await withRetry(() => this.withRetry(() => replaceProvider.create(logicalId, resourceType, replaceProps), logicalId, void 0, void 0, replaceProvider), logicalId, {
-									maxRetries: 5,
+									maxRetries: 8,
 									initialDelayMs: 2e3,
 									maxDelayMs: 1e4,
 									logger: this.logger,
 									isInterrupted: () => this.interrupted,
 									onInterrupted: () => new InterruptedError(this.interruptCause ?? "user"),
-									isRetryable: (message) => /already exists/i.test(message) || message.includes("AlreadyExists")
+									isRetryable: isRecreateRetryableError
 								});
 							} catch (recreateError) {
 								throw new Error(`Failed to re-create ${logicalId} after the --replace delete-first fallback already deleted the old resource (${currentResource.physicalId}): ${recreateError instanceof Error ? recreateError.message : String(recreateError)}. Re-run the deploy to create it fresh.`);
@@ -19009,4 +19080,4 @@ var DeployEngine = class {
 
 //#endregion
 export { createAssetRedirectResolver as $, ResourceTimeoutError as $t, CloudControlProvider as A, MIGRATE_TMP_PREFIX as At, assertRegionMatch as B, setAwsClients as Bt, green as C, resolveSkipPrefix as Ct, collectInlinePolicyNamesManagedBySiblings as D, warnDeprecatedNoPrefixCliFlag as Dt, IAMRoleProvider as E, resolveUseCdkBootstrapAssets as Et, cfnRefValueFromPhysicalId as F, clearBucketRegionCache as Ft, LockManager as G, LocalInvokeBuildError as Gt, DiffCalculator as H, CdkdError as Ht, refStateLookupFromResource as I, resolveBucketRegion as It, shouldRetainResource as J, LockError as Jt, S3StateBackend as K, LocalMigrateError as Kt, WAFv2WebACLProvider as L, AwsClients as Lt, disableInstanceApiTermination as M, uploadCfnTemplate as Mt, isTerminationProtectionPropagationError as N, expectedOwnerParam as Nt, ProviderRegistry as O, CFN_TEMPLATE_BODY_LIMIT as Ot, IntrinsicFunctionResolver as P, AssemblyReader as Pt, buildAssetRedirectMap as Q, ProvisioningError as Qt, normalizeAwsTagsToCfn as R, getAwsClients as Rt, gray as S, resolveCaptureObservedState as St, yellow as T, resolveStateBucketWithDefaultAndSource as Tt, DagBuilder as U, ConfigError as Ut, applyRoleArnIfSet as V, AssetError as Vt, TemplateParser as W, DependencyError as Wt, stringifyValue as X, NestedStackChildDirectDestroyError as Xt, AssetPublisher as Y, MissingCdkCliError as Yt, WorkGraph as Z, PartialFailureError as Zt, isStatefulRecreateTargetSync as _, synthesisStatusMessage as _t, DeploymentEventsStore as a, formatError as an, getBootstrapMarkerKey as at, bold as b, resolveApp as bt, replayFailedOperations as c, withErrorHandling as cn, validateContainerRepoName as ct, withRetry as d, getDockerCmd as dt, ResourceUpdateNotSupportedError as en, loadPublishableAssetManifest as et, isRetryableTransientError as f, runDockerForeground as ft, MULTI_REGION_RECREATE_BLOCKED_TYPES as g, Synthesizer as gt, extractDeploymentEventError as h, getDockerImageBySourceHash as ht, DeploymentEventsReader as i, SynthesisError as in, ensureAssetStorage as it, slowCcOperationTimeoutMs as j, findLargeInlineResources as jt, findActionableSilentDrops as k, CFN_TEMPLATE_URL_LIMIT as kt, replayRollback as l, __exportAll as ln, buildDockerImage as lt, computeImplicitDeleteEdges as m, AssetManifestLoader as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, StackTerminationProtectionError as nn, AssetModeResolver as nt, planFailedOps as o, isCdkdError as on, parseBootstrapMarker as ot, IMPLICIT_DELETE_DEPENDENCIES as p, runDockerStreaming as pt, rebuildClientForBucketRegion as q, LocalStartServiceError as qt, DeployEngine as r, StateError as rn, BOOTSTRAP_MARKER_PREFIX as rt, planRollback as s, normalizeAwsError as sn, validateAssetBucketName as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, StackHasActiveImportsError as tn, rewriteTemplateAssetReferences as tt, withResourceDeadline as u, formatDockerLoginError as ut, renderStatefulReason as v, getDefaultStateBucketName as vt, red as w, resolveStateBucketWithDefault as wt, cyan as x, resolveAutoAssetStorage as xt, formatResourceLine as y, getLegacyStateBucketName as yt, resolveExplicitPhysicalId as z, resetAwsClients as zt };
-//# sourceMappingURL=deploy-engine-hlS6y_-0.js.map
+//# sourceMappingURL=deploy-engine-CaquB01e.js.map