@go-to-k/cdkd 0.284.51 → 0.284.53

package/dist/{deploy-engine-Dnp730rc.js → deploy-engine-DOP4V6eK.js}

@@ -1,5 +1,5 @@
 import { a as getLiveRenderer, d as generateResourceNameWithFallback, f as getCurrentStackName, h as withStackName, l as applyDefaultNameForFallback, n as getLogger, p as looksLikeCdkdGeneratedName, u as generateResourceName } from "./logger-zRrlbaQt.js";
-import { t as getCdkdVersion } from "./version-CJG_PFNb.js";
+import { t as getCdkdVersion } from "./version-CaIqvSUG.js";
 import { randomUUID } from "node:crypto";
 import { CreateBucketCommand, DeleteObjectCommand, DeleteObjectsCommand, GetBucketLocationCommand, GetObjectCommand, HeadBucketCommand, HeadObjectCommand, ListObjectsV2Command, NoSuchKey, PutBucketEncryptionCommand, PutBucketPolicyCommand, PutObjectCommand, PutPublicAccessBlockCommand, S3Client, S3ServiceException } from "@aws-sdk/client-s3";
 import { CloudControlClient, CreateResourceCommand, DeleteResourceCommand, GetResourceCommand, GetResourceRequestStatusCommand, ListResourcesCommand, UpdateResourceCommand } from "@aws-sdk/client-cloudcontrol";
@@ -110,11 +110,17 @@ const IAM_PROPAGATION_ERROR_MESSAGE_PATTERNS = [
 	"is not a valid role to allow SNS"
 ];
 /**
-* The NON-IAM-propagation half of {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}:
-* transient failures whose recovery window is either long (SQS's 60s same-name
-* cooldown, a resource still leaving a Pending/Creating state) or genuinely
-* load-related (throttling), where hammering AWS with dense retries is harmful
-* and exponential backoff is the correct shape.
+* The NON-IAM-propagation, NON-name-cooldown third of
+* {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}: transient failures whose recovery
+* window is either long (a resource still leaving a Pending/Creating state) or
+* genuinely load-related (throttling), where hammering AWS with dense retries
+* is harmful and exponential backoff is the correct shape.
+*
+* The name-cooldown spellings used to live here too (`wait 60 seconds`, S3's
+* `conflicting conditional operation`); they moved to
+* {@link NAME_COOLDOWN_ERROR_MESSAGE_PATTERNS} so the ordinary-create path and
+* the delete-then-re-create sites read ONE list instead of two that drifted
+* apart (issue [#2116](https://github.com/go-to-k/cdkd/issues/2116)).
 */
 const OTHER_TRANSIENT_ERROR_MESSAGE_PATTERNS = [
 	"currently in the following state: Pending",
@@ -123,10 +129,8 @@ const OTHER_TRANSIENT_ERROR_MESSAGE_PATTERNS = [
 	"DependencyViolation",
 	"does not exist",
 	"Schema is currently being altered",
-	"conflicting conditional operation",
 	"scheduled for deletion",
 	"Could not deliver test message",
-	"wait 60 seconds",
 	"concurrent update operation",
 	"because it is in use",
 	"Rate exceeded",
@@ -135,15 +139,101 @@ const OTHER_TRANSIENT_ERROR_MESSAGE_PATTERNS = [
 	"Unable to complete operation due to concurrent modification"
 ];
 /**
+* The **name-cooldown** third of {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}:
+* an AWS service that holds a resource's NAME (or other unique identifier)
+* while an ASYNCHRONOUS delete of the previous holder is still in flight, so a
+* create of the same name inside that window is refused with a
+* service-specific message. The window always clears on its own — the delete
+* that opened it is already running — which is what makes every entry here
+* retryable rather than terminal, whichever call site hits it.
+*
+* Read by BOTH consumers, which is the whole point of the list existing
+* (issue [#2116](https://github.com/go-to-k/cdkd/issues/2116)):
+*
+*  - {@link isNameCooldownError}, and through it
+*    {@link isRecreateRetryableError}, the retry filter at the
+*    delete-then-re-create sites (the deploy engine's `--replace` delete-first
+*    fallback, the recreate-via-* path, the rollback executor's
+*    delete-new-first) — the sites where cdkd itself just deleted the name
+*    holder;
+*  - {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}, i.e. the ORDINARY create path,
+*    where a fresh `cdkd deploy` process has no idea a prior `cdkd destroy`
+*    deleted anything.
+*
+* The second consumer is the reachable one and was the measured failure in
+* #2116: destroy-then-redeploy is a routine dev loop, CloudFormation absorbs
+* the window and converges, and cdkd claims template compatibility with
+* CloudFormation — so failing the whole deploy (26 resources created and
+* rolled back, on the run that filed the issue) over a condition that clears
+* in seconds is a parity defect. Before this list, the two consumers held
+* DIFFERENT spellings of the same SQS error: the wire message
+* (`wait 60 seconds`) was in the generic table so an ordinary create retried
+* it, while the error CODE (`QueueDeletedRecently`) was not — so whether the
+* identical AWS condition was survivable depended on which spelling the SDK
+* happened to surface.
+*
+* Bounded, not unbounded: since #2116 the ordinary-create path rides
+* `withRetry`'s NAME-COOLDOWN grid (8 retries, 2s/4s/8s then capped at 10s ≈
+* 64s of sleep — `NAME_COOLDOWN_INITIAL_DELAY_MS` in `./retry.ts`), which is
+* the same budget the re-create sites already carried. It is deliberately NOT
+* the generic 47s schedule this path used to inherit: SQS's own sentence names
+* a 60-second window, so 47s would not converge, it would merely fail 47s
+* later. A name that is NOT in fact being
+* released — a genuine, permanent collision — is a different signature
+* ({@link isNameCollisionError}) and is deliberately NOT here, so it still
+* fails fast into the actionable `--replace` refusal instead of burning a
+* budget it cannot survive.
+*
+* **What must NOT go in this list.** Every entry below is specific to a delete
+* that is ALREADY in flight and clears within a budget. Three candidates the
+* sibling sweep turned up are recorded here as deliberate EXCLUSIONS rather
+* than left unmentioned, because "absent" and "considered and rejected" are
+* indistinguishable to the next person doing this sweep:
+*
+*  - **ELBv2 `DuplicateLoadBalancerName`** and **DynamoDB's create-side
+*    `Table already exists: <name>`** — AWS raises both for a resource that
+*    merely EXISTS, just as readily as for a deleting one, so neither is
+*    distinguishable from a terminal collision. Promoting either would convert
+*    a fast, actionable `--replace` refusal into a full retry budget ending in
+*    the same failure. (DynamoDB's `Table is being deleted` IS distinguishable,
+*    but promoting THAT one re-multiplies the destroy-runner budget arithmetic
+*    `src/provisioning/dynamodb-index-busy-delete.ts` derives against the
+*    per-resource deadline — a different reason, so it is stated separately
+*    rather than folded in with the two above.)
+*  - **Secrets Manager `scheduled for deletion`** — the same one-sided shape as
+*    S3's entry (generic table only, invisible to
+*    {@link isRecreateRetryableError}), and the provider does delete with
+*    `ForceDeleteWithoutRecovery: true`, so it LOOKS like it belongs. It is
+*    excluded because that single message covers TWO conditions with wildly
+*    different windows: a force-deleted secret's name releasing in
+*    seconds-to-minutes, and a secret scheduled for deletion with a
+*    `RecoveryWindowInDays` of 7-30 DAYS, which no bounded budget can ride out
+*    and which a user reaches by deleting a secret outside cdkd. A budget that
+*    cannot converge on half its population is worse than failing fast, so the
+*    entry stays where it already was — in the generic table, retryable on an
+*    ordinary create and terminal at the re-create sites, unchanged by #2116.
+*/
+const NAME_COOLDOWN_ERROR_MESSAGE_PATTERNS = [
+	"QueueDeletedRecently",
+	"wait 60 seconds",
+	"StateMachineDeleting",
+	"State Machine is being deleted",
+	"conflicting conditional operation"
+];
+/**
 * Patterns that mark an AWS error as a transient/retryable failure.
 * Each entry is a substring match against the error message; all of these
 * are situations where the same call typically succeeds after a short delay
 * because of eventual consistency or just-created-dependency propagation.
 *
-* Composed from the two halves above so retryability has ONE source of truth
+* Composed from the three halves above so retryability has ONE source of truth
 * while `withRetry` can still pick a per-class backoff cadence.
 */
-const RETRYABLE_ERROR_MESSAGE_PATTERNS = [...IAM_PROPAGATION_ERROR_MESSAGE_PATTERNS, ...OTHER_TRANSIENT_ERROR_MESSAGE_PATTERNS];
+const RETRYABLE_ERROR_MESSAGE_PATTERNS = [
+	...IAM_PROPAGATION_ERROR_MESSAGE_PATTERNS,
+	...OTHER_TRANSIENT_ERROR_MESSAGE_PATTERNS,
+	...NAME_COOLDOWN_ERROR_MESSAGE_PATTERNS
+];
 /**
 * HTTP status codes that always indicate a transient failure worth retrying.
 * 429 = Too Many Requests (throttle), 503 = Service Unavailable.
@@ -575,26 +665,31 @@ function isNameCollisionError(message) {
 	return /(?<!\b(?:must|not|should|may|cannot)\s)already exists?\b/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.
+* Match a same-name re-creation cooldown — an AWS service still holding a
+* resource's name while its asynchronous delete finishes. Every recognised
+* spelling lives in {@link NAME_COOLDOWN_ERROR_MESSAGE_PATTERNS}; add new ones
+* THERE rather than here, so the ordinary-create path
+* ({@link RETRYABLE_ERROR_MESSAGE_PATTERNS}, which composes that list) cannot
+* drift out of step with the delete-then-re-create sites again. That drift is
+* exactly what issue [#2116](https://github.com/go-to-k/cdkd/issues/2116)
+* found: SQS's wire message was retryable on an ordinary create while its
+* error code was not, and the Step Functions spelling was recognised by
+* neither.
+*
+* 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 these
+* signatures do 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 OR this matcher into their retry filter, with a schedule long
+* enough to cover the 60s SQS 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");
+	return NAME_COOLDOWN_ERROR_MESSAGE_PATTERNS.some((p) => message.includes(p));
 }
 /**
 * Retry filter for the delete-then-re-create sites: the old name holder was
@@ -989,8 +1084,10 @@ var PartialFailureError = class PartialFailureError extends CdkdError {
 * is the whole point: the message interpolates the resource's LOGICAL ID,
 * and the retry classifiers match by SUBSTRING, so a perfectly ordinary
 * composite CDK id like `MyDependencyViolationSub` made
-* `isRetryableTransientError` return true (`DependencyViolation` is the only
-* whitespace-free entry in `RETRYABLE_ERROR_MESSAGE_PATTERNS`) and burned the
+* `isRetryableTransientError` return true (`DependencyViolation` was then the
+* only whitespace-free entry in `RETRYABLE_ERROR_MESSAGE_PATTERNS`; the
+* name-cooldown error CODES `QueueDeletedRecently` / `StateMachineDeleting`
+* joined it under issue #2116, so the hazard is wider, not narrower) and burned the
 * full generic schedule — 8 retries, ~47s of pure sleep — on a path that was
 * never going to succeed, before the fallback the error exists to trigger was
 * even reached.
@@ -6938,7 +7035,8 @@ const STATE_SCHEMA_VERSIONS_READABLE = [
 	5,
 	6,
 	7,
-	8
+	8,
+	9
 ];
 /**
 * Returns true when a recorded `DeletionPolicy` should prevent cdkd from
@@ -6954,6 +7052,50 @@ const STATE_SCHEMA_VERSIONS_READABLE = [
 function shouldRetainResource(deletionPolicy) {
 	return deletionPolicy === "Retain" || deletionPolicy === "RetainExceptOnCreate";
 }
+/**
+* The keys of `state.outputs` an `Fn::ImportValue` may bind to (issue
+* [#2193](https://github.com/go-to-k/cdkd/issues/2193)) — THE predicate
+* behind "what does this stack export". Four readers used to answer that
+* by walking `outputs` wholesale (the exports index on update and on
+* rebuild, the resolver's state scan, and the local-command loader's
+* `Fn::ImportValue` fallback scan), and each therefore took a plain Output
+* name for an export; they all go through here now, so the rule cannot
+* drift between them.
+*
+* A record whose `exportNames` is unknown (pre-v9, or a v9 partial save that
+* carried a pre-v9 bag forward) keeps the legacy rule — every key — until
+* its next deploy writes the set. A known set is intersected with the bag:
+* an alias whose value did not resolve publishes nothing, and a name the
+* bag does not hold cannot be served.
+*
+* `outputs` is typed required but every consumer treats it as optional (a
+* state file may simply have none), so it is read defensively here too.
+*/
+function importableOutputKeys(state) {
+	const outputs = state.outputs ?? {};
+	if (state.exportNames === void 0) return Object.keys(outputs);
+	return state.exportNames.filter((name) => Object.hasOwn(outputs, name));
+}
+/** `state.outputs` narrowed to its {@link importableOutputKeys}. */
+function importableOutputs(state) {
+	const outputs = state.outputs ?? {};
+	const picked = Object.create(null);
+	for (const name of importableOutputKeys(state)) picked[name] = outputs[name];
+	return picked;
+}
+/**
+* The `exportNames` half of a record whose `outputs` bag is being CARRIED
+* FORWARD unchanged rather than re-resolved (a partial save on a failed
+* deploy, `cdkd import` over an existing record). The two travel together:
+* carrying the bag without its set would turn a known-exports record back
+* into a "not known" one, and inventing `[]` for a pre-v9 bag would deny
+* every consumer of a stack that never had the chance to write the set.
+* Spread this next to `outputs: previous.outputs` — never write the field
+* by hand at such a site.
+*/
+function exportNamesCarriedFrom(previous) {
+	return previous.exportNames === void 0 ? {} : { exportNames: previous.exportNames };
+}
 
 //#endregion
 //#region src/types/rollback-journal.ts
@@ -7327,7 +7469,7 @@ var S3StateBackend = class {
 		const { expectedEtag, migrateLegacy } = options;
 		const body = {
 			...state,
-			version: 8,
+			version: 9,
 			stackName,
 			region
 		};
@@ -9715,6 +9857,68 @@ const IAM_PROPAGATION_MAX_DELAY_MS = 2e3;
 * generic one by more than 0.75s in the early band.
 */
 const IAM_PROPAGATION_MAX_RETRIES = 26;
+/**
+* Backoff for the NAME-COOLDOWN class on the DEFAULT schedule — an AWS service
+* still holding a resource's name while an asynchronous delete of the previous
+* holder finishes (`NAME_COOLDOWN_ERROR_MESSAGE_PATTERNS` in
+* ./retryable-errors.ts). Issue
+* [#2116](https://github.com/go-to-k/cdkd/issues/2116).
+*
+* **Why this class does not inherit the generic schedule.** The generic one
+* sleeps 1+2+4+8+8+8+8+8 = 47s, and the longest window in this class NAMES its
+* own duration: SQS's own sentence is "You must wait 60 seconds after deleting
+* a queue before you can create another with the same name." A 47s budget
+* against a 60s window does not converge — it just fails 47s later, which is
+* strictly worse than failing at once. That mismatch was live for as long as
+* `wait 60 seconds` has been in the generic table.
+*
+* **Where the numbers come from — precedent, not a fresh guess.** They are the
+* delete-then-re-create sites' existing budget, chosen for this exact window
+* (`deploy-engine.ts`'s `--replace` fallback and `rollback-executor.ts`'s
+* reverse-replacement both pass `maxRetries: 8, initialDelayMs: 2_000,
+* maxDelayMs: 10_000`). Adopting it here makes the ordinary create path and
+* the re-create sites ride the SAME window with the SAME budget, which is the
+* property #2116 is about: whether a cooldown is survivable must not depend on
+* which call site met it.
+*
+*   2 + 4 + 8 + 10 x 5 = 64s over 8 retries
+*
+* Probe grid (seconds after the first failure): 2, 6, 14, 24, 34, 44, 54, 64 —
+* covering SQS's 60s and, with room to spare, the ~23s of `status: DELETING`
+* measured on an idle Step Functions state machine
+* (`tests/integration/custom-resource-provider`).
+*
+* **What it does NOT claim.** A window LONGER than 64s still fails, with the
+* same AWS message as before. This class converts "always fails" into "fails
+* only past a budget derived from the longest window AWS itself documents" —
+* and, unlike the generic schedule, a run that exhausts it now says so (see
+* the give-up summary in {@link withRetry}), so a too-short budget is
+* reportable rather than indistinguishable from having no retry at all.
+*
+* The retry COUNT is deliberately the generic 8 rather than a new ceiling, so
+* nothing about the loop's own exit condition moves. Same reason the dense IAM
+* grid needed its own count and this does not.
+*
+* **But "only the delay grid changes" understates the effect at the NESTED
+* sites, so state the compounding rather than implying there is none.** Three
+* call sites wrap a DEFAULT-schedule `withRetry` inside their own outer loop
+* (`deploy-engine.ts`'s two `--replace` / recreate sites and
+* `rollback-executor.ts`'s reverse-replacement). The inner loop is the one
+* this grid changes, and the outer one re-enters it per attempt, so the
+* product grows with it: total sleep on a cooldown at those sites measures
+* **487s -> 640s (8.1 -> 10.7 min)**. That is accepted, not overlooked -- it
+* stays inside the 30-minute per-resource `withResourceDeadline`, and the
+* alternative is an inner loop that cannot ride out the window it is nested
+* for. A reader auditing those budgets needs the number, which is why it is
+* here and not left to be re-derived.
+*
+* `dynamodb-index-busy-delete.ts` is unaffected and that was checked rather
+* than assumed: it passes all four knobs, so `defaultSchedule` is false and
+* this grid never applies to it -- its own deadline arithmetic stands.
+*/
+const NAME_COOLDOWN_INITIAL_DELAY_MS = 2e3;
+/** Cap for the name-cooldown backoff. See {@link NAME_COOLDOWN_INITIAL_DELAY_MS}. */
+const NAME_COOLDOWN_MAX_DELAY_MS = 1e4;
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
 * Run `operation`, retrying transient failures with exponential backoff
@@ -9734,6 +9938,13 @@ const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 * re-create sites' ~64s budget covering SQS's 60s name cooldown) and gets it
 * verbatim.
 *
+* A THIRD class rides its own grid on the default schedule since issue
+* [#2116](https://github.com/go-to-k/cdkd/issues/2116): a NAME COOLDOWN (a
+* service still holding a name while an async delete finishes) gets
+* 2s/4s/8s then 10s to a 64s total, because the longest window in that class
+* NAMES its duration -- SQS says "wait 60 seconds" -- and the generic 47s
+* cannot ride out a 60s wait. See {@link NAME_COOLDOWN_INITIAL_DELAY_MS}.
+*
 * The class is re-evaluated per attempt, so a propagation retry that runs into
 * a throttle backs OFF exponentially for that attempt instead of hammering.
 *
@@ -9764,6 +9975,8 @@ async function withRetry(operation, logicalId, opts = {}) {
 	let sawPropagation = false;
 	let propagationRetries = 0;
 	let propagationSleptMs = 0;
+	let nameCooldownRetries = 0;
+	let nameCooldownSleptMs = 0;
 	let serverErrorRetries = 0;
 	for (let attempt = 0; attempt <= attemptCeiling; attempt++) try {
 		return await operation();
@@ -9774,12 +9987,15 @@ async function withRetry(operation, logicalId, opts = {}) {
 		const retryable = opts.isRetryable ? opts.isRetryable(message, error) : isRetryableTransientError(error, message);
 		const propagation = defaultSchedule && isIamPropagationError(message);
 		if (propagation) sawPropagation = true;
+		const nameCooldown = defaultSchedule && !propagation && isNameCooldownError(message);
 		const attemptLimit = sawPropagation ? 26 : maxRetries;
 		if (!retryable || attempt >= attemptLimit) {
-			if (propagationRetries > 0 || serverErrorRetries > 0) {
+			if (propagationRetries > 0 || serverErrorRetries > 0 || nameCooldownRetries > 0) {
 				const budgetExhausted = sawPropagation && attempt >= attemptLimit;
+				const nameCooldownBudgetExhausted = nameCooldownRetries >= maxRetries && attempt >= attemptLimit;
 				const spent = [];
 				if (propagationRetries > 0) spent.push(`${propagationRetries} IAM-propagation ${propagationRetries === 1 ? "retry" : "retries"} over ${(propagationSleptMs / 1e3).toFixed(2)}s of propagation backoff${budgetExhausted ? " (the full propagation budget)" : ""}`);
+				if (nameCooldownRetries > 0) spent.push(`${nameCooldownRetries} name-cooldown ${nameCooldownRetries === 1 ? "retry" : "retries"} over ${(nameCooldownSleptMs / 1e3).toFixed(2)}s waiting for the name to be released${nameCooldownBudgetExhausted ? " (the full name-cooldown budget)" : ""}`);
 				if (serverErrorRetries > 0) spent.push(`${serverErrorRetries} transient server-error ${serverErrorRetries === 1 ? "retry" : "retries"} (HTTP 5xx)`);
 				const summary = () => `${logicalId}: gave up after ${spent.join(" and ")} - ${message}` + formatRetryClassificationSignals(error);
 				try {
@@ -9788,7 +10004,7 @@ async function withRetry(operation, logicalId, opts = {}) {
 			}
 			throw error;
 		}
-		const delay = propagation ? Math.min(250 * Math.pow(2, attempt), IAM_PROPAGATION_MAX_DELAY_MS) : Math.min(initialDelayMs * Math.pow(2, attempt), maxDelayMs);
+		const delay = propagation ? Math.min(250 * Math.pow(2, attempt), IAM_PROPAGATION_MAX_DELAY_MS) : nameCooldown ? Math.min(NAME_COOLDOWN_INITIAL_DELAY_MS * Math.pow(2, attempt), NAME_COOLDOWN_MAX_DELAY_MS) : Math.min(initialDelayMs * Math.pow(2, attempt), maxDelayMs);
 		const backoffThroughThisAttemptMs = propagation ? propagationSleptMs + delay : propagationSleptMs;
 		opts.logger?.debug(`  ⏳ Retrying ${logicalId} in ${delay / 1e3}s (attempt ${attempt + 1}/${attemptLimit}${propagation ? `, ${(backoffThroughThisAttemptMs / 1e3).toFixed(2)}s backoff through this attempt` : ""}) - ${message}`);
 		for (let waited = 0; waited < delay; waited += 1e3) {
@@ -9798,6 +10014,9 @@ async function withRetry(operation, logicalId, opts = {}) {
 		if (propagation) {
 			propagationRetries++;
 			propagationSleptMs = backoffThroughThisAttemptMs;
+		} else if (nameCooldown) {
+			nameCooldownRetries++;
+			nameCooldownSleptMs += delay;
 		} else if (opts.isRetryable === void 0 && isTransientServerError(error)) serverErrorRetries++;
 	}
 	throw lastError;
@@ -16216,7 +16435,8 @@ var IntrinsicFunctionResolver = class IntrinsicFunctionResolver {
 	* criterion `retryable-errors.ts` documents as insufficient: the classifiers
 	* match by SUBSTRING, and `sourceClause` interpolates template-controlled
 	* text, so a logical id like `MyDependencyViolationHandler` puts
-	* `DependencyViolation` (the table's only whitespace-free entry) into the
+	* `DependencyViolation` (a whitespace-free entry in the table — the only
+	* one until issue #2116 added the name-cooldown error codes) into the
 	* message. Reachability is real even though resolution runs outside
 	* `withRetry` on the flat path: `NestedStackProvider.create` runs a child
 	* `DeployEngine.deploy()` and re-throws, and the parent wraps `create()` in
@@ -16559,7 +16779,7 @@ var IntrinsicFunctionResolver = class IntrinsicFunctionResolver {
 					continue;
 				}
 				const { state } = stateData;
-				if (state.outputs && exportName in state.outputs) {
+				if (importableOutputKeys(state).includes(exportName)) {
 					const value = state.outputs[exportName];
 					this.logger.info(`Resolved Fn::ImportValue: ${loggedExportName} (from stack: ${refStack} / ${lookupRegion}; ${carriesDynamicReference(value) ? "redacted dynamic reference" : "literal value"})`);
 					if (context.exportIndex) context.exportIndex.patchEntry(exportName, {
@@ -18231,7 +18451,7 @@ var CloudControlProvider = class {
 		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-CynKJdi4.js").then((n) => n.n);
+			const { ASGProvider } = await import("./asg-provider-Ciurx_UV.js").then((n) => n.n);
 			return await new ASGProvider().delete(logicalId, physicalId, resourceType, _properties, context);
 		}
 		const isProtectedEc2Instance = context?.removeProtection === true && resourceType === "AWS::EC2::Instance";
@@ -26030,7 +26250,8 @@ async function replayRollback(operations, stateResources, stackName, ctx, option
 *    hang the flag exists to prevent. Those providers retry internally.
 *  - **Interrupt.** `replayRollback` polls interrupts only BETWEEN ops, so an
 *    un-threaded `isInterrupted` leaves Ctrl-C dead for the length of the
-*    backoff schedule (~47s) per op.
+*    backoff schedule per op — ~47s on the generic grid, or ~64s if the op
+*    hits a name cooldown, which rides its own longer grid since issue #2116.
 *
 * Returns the provider's result so the caller can honour
 * `effectiveProperties` (issue #1644) — both revert arms used to write the
@@ -26336,8 +26557,13 @@ async function updateWithRollbackRetry(provider, args, logicalId, logger, isInte
 * on attempt 0 and it reaches the caller's catch on the FIRST outer attempt,
 * exactly as before. The SQS cooldown IS matched by the inner classifier (the
 * generic table carries `wait 60 seconds`), which is the same division of
-* labour the deploy engine's named-replacement site documents: the inner retry
-* absorbs most of the 60s window and the outer ~64s budget covers the tail.
+* labour the deploy engine's named-replacement site documents. Since issue
+* #2116 the inner retry rides the name-cooldown grid (≈64s) rather than the
+* generic ~47s one, so it covers the whole 60s window on its own instead of
+* absorbing most of it and leaving a tail for the outer loop; the outer loop
+* now earns its place by ALSO covering the late name release that the inner
+* default classifier rejects. The two compound — measured at 640s of total
+* sleep on a cooldown, inside the 30-minute per-resource deadline.
 */
 async function createWithRollbackRetry(provider, create, logicalId, logger, isInterrupted, secrets, outer) {
 	if (provider.disableOuterRetry) return await create();
@@ -27658,6 +27884,17 @@ var DeployEngine = class {
 	*/
 	outputsTemplateSource = {};
 	/**
+	* The export aliases the last `resolveOutputs` pass WROTE into its bag
+	* (issue #2193) — exactly the keys `outputs[exportName] = value` landed on,
+	* so an alias the pass refused (secret-bearing name, collision with a
+	* published output name) or skipped (unresolved value, condition-suppressed
+	* output) is not in it. Persisted as `StackState.exportNames` by the saves
+	* that persist that bag, and the set the exports index is fed from. Reset
+	* at the top of every `resolveOutputs`, so it is only meaningful right
+	* after that call returns — read it there, not later.
+	*/
+	resolvedExportNames = [];
+	/**
 	* Whether {@link outputsTemplateSource} may be used to POSITION the outputs
 	* redaction. False once an outputs pass threw partway: the post-loop
 	* name pass never ran, so the bag holds only the alias keys written before
@@ -28033,11 +28270,12 @@ var DeployEngine = class {
 			renderer.start();
 			const currentStateData = await this.stateBackend.getState(stackName, this.stackRegion);
 			const currentState = currentStateData?.state ?? {
-				version: 8,
+				version: 9,
 				region: this.stackRegion,
 				stackName,
 				resources: {},
 				outputs: {},
+				exportNames: [],
 				lastModified: Date.now()
 			};
 			const currentEtag = currentStateData?.etag;
@@ -28094,16 +28332,20 @@ var DeployEngine = class {
 					const resolvedOutputs = this.redactOutputs(await this.resolveOutputs(effectiveTemplate, currentState.resources, stackName, parameterValues, conditions));
 					const resolutionFailed = Object.values(resolvedOutputs).some((v) => v === void 0);
 					const outputsChanged = !resolutionFailed && !outputMapsEqual(persistedOutputs, resolvedOutputs);
+					const currentEffectiveExports = new Set(importableOutputKeys(currentState));
+					const resolvedExportSet = new Set(this.resolvedExportNames);
+					const exportSetChanged = !resolutionFailed && (currentEffectiveExports.size !== resolvedExportSet.size || [...resolvedExportSet].some((k) => !currentEffectiveExports.has(k)));
 					if (resolutionFailed && !outputMapsEqual(persistedOutputs, resolvedOutputs)) this.logger.warn("Outputs changed but one or more could not be resolved; keeping the previously persisted outputs. A downstream Fn::ImportValue may fail until the next deploy.");
 					const observedRefresh = this.observedCaptureTasks.size > 0;
 					if (observedRefresh) await this.drainObservedCaptures(currentState.resources);
-					if (observedRefresh || outputsChanged) try {
+					if (observedRefresh || outputsChanged || exportSetChanged) try {
 						const refreshedState = {
-							version: 8,
+							version: 9,
 							region: this.stackRegion,
 							stackName: currentState.stackName,
 							resources: currentState.resources,
 							outputs: outputsChanged ? resolvedOutputs : persistedOutputs,
+							...resolutionFailed ? exportNamesCarriedFrom(currentState) : { exportNames: [...this.resolvedExportNames] },
 							...crossStackReadsForPartialSave(currentState, this.recordedImports, this.recordedOutputReads),
 							lastModified: Date.now()
 						};
@@ -28111,10 +28353,11 @@ var DeployEngine = class {
 						if (currentEtag !== void 0) saveOptions.expectedEtag = currentEtag;
 						if (migrationPending) saveOptions.migrateLegacy = true;
 						await this.stateBackend.saveState(stackName, this.stackRegion, this.withParentInfo(refreshedState), saveOptions);
-						if (outputsChanged) {
-							persistedOutputs = resolvedOutputs;
-							this.logger.info("Persisted Outputs-only change (no resource diff).");
-							if (this.exportIndexStore) await this.exportIndexStore.updateForStack(stackName, this.stackRegion, persistedOutputs);
+						if (outputsChanged || exportSetChanged) {
+							persistedOutputs = refreshedState.outputs;
+							if (outputsChanged) this.logger.info("Persisted Outputs-only change (no resource diff).");
+							else this.logger.debug("Persisted export-set change (no outputs-value diff, no-change path, #2193)");
+							if (this.exportIndexStore) await this.exportIndexStore.updateForStack(stackName, this.stackRegion, importableOutputs(refreshedState));
 						} else this.logger.debug("Persisted refreshed observedProperties (no-change path)");
 					} catch (saveError) {
 						this.logger.warn(`Failed to persist no-change state update: ${saveError instanceof Error ? saveError.message : String(saveError)} — drift baseline / outputs will be re-resolved on next deploy.`);
@@ -28161,7 +28404,7 @@ var DeployEngine = class {
 			await this.drainObservedCaptures(newState.resources);
 			const newEtag = await this.stateBackend.saveState(stackName, this.stackRegion, this.withParentInfo(newState));
 			this.logger.debug(`State saved (ETag: ${newEtag})`);
-			await Promise.all([this.deleteRollbackJournalBestEffort(stackName), this.exportIndexStore ? this.exportIndexStore.updateForStack(stackName, this.stackRegion, newState.outputs ?? {}) : Promise.resolve()]);
+			await Promise.all([this.deleteRollbackJournalBestEffort(stackName), this.exportIndexStore ? this.exportIndexStore.updateForStack(stackName, this.stackRegion, importableOutputs(newState)) : Promise.resolve()]);
 			const durationMs = Date.now() - startTime;
 			const unchangedCount = this.diffCalculator.filterByType(changes, "NO_CHANGE").length + actualCounts.skipped;
 			return {
@@ -28219,11 +28462,12 @@ var DeployEngine = class {
 			saveChain = saveChain.then(async () => {
 				try {
 					const partialState = {
-						version: 8,
+						version: 9,
 						region: this.stackRegion,
 						stackName: currentState.stackName,
 						resources: newResources,
 						outputs: currentState.outputs,
+						...exportNamesCarriedFrom(currentState),
 						...crossStackReadsForPartialSave(currentState, this.recordedImports, this.recordedOutputReads),
 						lastModified: Date.now()
 					};
@@ -28349,11 +28593,12 @@ var DeployEngine = class {
 			const initialDeploy = currentEtag === void 0;
 			try {
 				const preRollbackState = {
-					version: 8,
+					version: 9,
 					region: this.stackRegion,
 					stackName: currentState.stackName,
 					resources: newResources,
 					outputs: currentState.outputs,
+					...exportNamesCarriedFrom(currentState),
 					...crossStackReadsForPartialSave(currentState, this.recordedImports, this.recordedOutputReads),
 					lastModified: Date.now()
 				};
@@ -28384,11 +28629,12 @@ var DeployEngine = class {
 			}
 			try {
 				const postRollbackState = {
-					version: 8,
+					version: 9,
 					region: this.stackRegion,
 					stackName: currentState.stackName,
 					resources: newResources,
 					outputs: currentState.outputs,
+					...exportNamesCarriedFrom(currentState),
 					...crossStackReadsForPartialSave(currentState, this.recordedImports, this.recordedOutputReads),
 					lastModified: Date.now()
 				};
@@ -28400,11 +28646,12 @@ var DeployEngine = class {
 				try {
 					const freshEtag = (await this.stateBackend.getState(stackName, this.stackRegion))?.etag;
 					const postRollbackState = {
-						version: 8,
+						version: 9,
 						region: this.stackRegion,
 						stackName: currentState.stackName,
 						resources: newResources,
 						outputs: currentState.outputs,
+						...exportNamesCarriedFrom(currentState),
 						...crossStackReadsForPartialSave(currentState, this.recordedImports, this.recordedOutputReads),
 						lastModified: Date.now()
 					};
@@ -28428,11 +28675,12 @@ var DeployEngine = class {
 		}
 		return {
 			state: {
-				version: 8,
+				version: 9,
 				region: this.stackRegion,
 				stackName: currentState.stackName,
 				resources: newResources,
 				outputs,
+				exportNames: [...this.resolvedExportNames],
 				...this.recordedImports.length > 0 && { imports: [...this.recordedImports] },
 				...this.recordedOutputReads.length > 0 && { outputReads: [...this.recordedOutputReads] },
 				lastModified: Date.now()
@@ -28465,11 +28713,12 @@ var DeployEngine = class {
 	*/
 	async persistStateAfterOutputFailure(stackName, currentState, newResources, currentEtag, pendingMigration) {
 		const buildState = () => ({
-			version: 8,
+			version: 9,
 			region: this.stackRegion,
 			stackName: currentState.stackName,
 			resources: newResources,
 			outputs: currentState.outputs,
+			...exportNamesCarriedFrom(currentState),
 			...crossStackReadsForPartialSave(currentState, this.recordedImports, this.recordedOutputReads),
 			lastModified: Date.now()
 		});
@@ -29471,6 +29720,7 @@ var DeployEngine = class {
 	* then (issue #1919).
 	*/
 	async resolveOutputs(template, resources, stackName, parameterValues, conditions) {
+		this.resolvedExportNames = [];
 		if (!template.Outputs) return {};
 		const outputs = {};
 		const context = this.buildResolverContext({
@@ -29519,6 +29769,7 @@ var DeployEngine = class {
 				else if (isExportAliasCollision(exportName, outputKey, publishedOutputNames)) this.logger.warn(exportAliasCollisionWarning(outputKey, exportName));
 				else {
 					outputs[exportName] = value;
+					if (!this.resolvedExportNames.includes(exportName)) this.resolvedExportNames.push(exportName);
 					this.outputsTemplateSource[exportName] = output.Value;
 				}
 			}
@@ -29545,5 +29796,5 @@ var DeployEngine = class {
 };
 
 //#endregion
-export { startInterruptWatch as $, setAwsClients as $n, WorkGraph as $t, renderStatefulReason as A, resolveCaptureObservedState as An, redactSecretsForState as At, exportAliasCollisionScrubWarning as B, findLargeInlineResources as Bn, DiffCalculator as Bt, isFinalSnapshotError as C, getDockerImageBySourceHash as Cn, normalizeAwsError as Cr, TEMPLATE_SOURCED_RULES as Ct, extractDeploymentEventError as D, getLegacyStateBucketName as Dn, isThrottlingError as Dr, isSingleDynamicReferenceToken as Dt, makeCanonicalizePropertiesFn as E, getDefaultStateBucketName as En, isRetryableTransientError as Er, errorCauseChain as Et, green as F, stateBucketExistenceConfirmed as Fn, s3BucketDomainName as Ft, collectInlinePolicyNamesManagedBySiblings as G, derivePartitionAndUrlSuffix as Gn, TemplateParser as Gt, secretBearingStateKeyWarning as H, expectedOwnerParam as Hn, describeTypeWithThrottleRetry as Ht, red as I, warnDeprecatedNoPrefixCliFlag as In, s3BucketDualStackDomainName as It, findActionableSilentDrops as J, clearBucketRegionCache as Jn, S3StateBackend as Jt, clearOnUpdateRemoval as K, AssemblyReader as Kn, LockManager as Kt, yellow as L, CFN_TEMPLATE_BODY_LIMIT as Ln, s3BucketRegionalDomainName as Lt, bold as M, resolveStateBucketWithDefault as Mn, classifyReplaySecretRegion as Mt, cyan as N, resolveStateBucketWithDefaultAndSource as Nn, producerRegionsFromState as Nt, MULTI_REGION_RECREATE_BLOCKED_TYPES as O, resolveApp as On, markNonRetryable as Or, maskSecretsInError as Ot, gray as P, resolveUseCdkBootstrapAssets as Pn, s3BucketArn as Pt, isInterruptedWaitError as Q, resetAwsClients as Qn, stringifyValue as Qt, collectDeclaredOutputNames as R, CFN_TEMPLATE_URL_LIMIT as Rn, s3BucketWebsiteUrl as Rt, createPreDeleteFinalSnapshot as S, AssetManifestLoader as Sn, isCdkdError as Sr, STATE_SOURCED_READBACK_RULES as St, unsupportedFinalSnapshotError as T, synthesisStatusMessage as Tn, isMarkedNonRetryable as Tr, dynamicReferenceTokens as Tt, stateKeySecretExposure as U, PARTITION_TABLE as Un, withRetry as Ut, isExportAliasCollision as V, uploadCfnTemplate as Vn, INTRINSIC_KEYS as Vt, IAMRoleProvider as W, canonicalizeRegion as Wn, DagBuilder as Wt, beginCommandInterruptScope as X, AwsClients as Xn, shouldRetainResource as Xt, findSilentDropProperties as Y, resolveBucketRegion as Yn, rebuildClientForBucketRegion as Yt, endCommandInterruptScope as Z, getAwsClients as Zn, AssetPublisher as Zt, computeImplicitDeleteEdges as _, formatDockerLoginError as _n, StackHasActiveImportsError as _r, replayWarn as _t, DeploymentEventsStore as a, stripControlChars as an, DeployCancelledError as ar, carriesDynamicReference as at, buildFinalSnapshotIdentifier as b, runDockerForeground as bn, SynthesisError as br, requireConfigString as bt, replayFailedOperations as c, ensureAssetStorage as cn, LocalMigrateError as cr, refStateLookupFromResource as ct, updatePartialReason as d, readBootstrapMarkerBody as dn, MissingCdkCliError as dr, resolveExplicitPhysicalId as dt, buildAssetRedirectMap as en, AssetError as er, CloudControlProvider as et, UNSPECIFIED_SKIP_REASON as f, validateAssetBucketName as fn, NestedStackChildDirectDestroyError as fr, assertRegionMatch as ft, IMPLICIT_DELETE_DEPENDENCIES as g, dockerSpawnEnvWithSensitive as gn, ResourceUpdateNotSupportedError as gr, readConfigString as gt, maskingRetryLogger as h, buildDockerImage as hn, ResourceTimeoutError as hr, configStringRefusal as ht, DeploymentEventsReader as i, escapeRegExp$1 as in, DependencyError as ir, IntrinsicFunctionResolver as it, formatResourceLine as j, resolveSkipPrefix as jn, scrubResourceRecord as jt, isStatefulRecreateTargetSync as k, resolveAutoAssetStorage as kn, __exportAll as kr, maskSecretsInText as kt, replayRollback as l, getBootstrapMarkerKey as ln, LocalStartServiceError as lr, WAFv2WebACLProvider as lt, withResourceDeadline as m, buildDenyExternalAccessPolicy as mn, ProvisioningError as mr, configBooleanRefusal as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, loadPublishableAssetManifest as nn, ConfigError as nr, disableInstanceApiTermination as nt, planFailedOps as o, AssetModeResolver as on, DynamicReferenceRegionAmbiguousError as or, cfnRefValueFromPhysicalId as ot, deleteSkipReason as p, validateContainerRepoName as pn, PartialFailureError as pr, coerceCfnBoolean as pt, ProviderRegistry as q, processStackMessages as qn, displaySafe as qt, DeployEngine as r, rewriteTemplateAssetReferences as rn, CrossAccountSecretRefusalError as rr, isTerminationProtectionPropagationError as rt, planRollback as s, BOOTSTRAP_MARKER_PREFIX as sn, LocalInvokeBuildError as sr, getAccountInfo as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, createAssetRedirectResolver as tn, CdkdError as tr, slowCcOperationTimeoutMs as tt, updatePartialMessage as u, parseBootstrapMarker as un, LockError as ur, normalizeAwsTagsToCfn as ut, ATOMIC_FINAL_SNAPSHOT_TYPES as v, getDockerCmd as vn, StackTerminationProtectionError as vr, requireConfigArray as vt, refusesFinalSnapshot as w, Synthesizer as wn, withErrorHandling as wr, createSecretMasker as wt, ccRoutedFinalSnapshotError as x, runDockerStreaming as xn, formatError as xr, STATE_SOURCED_CROSS_GENERATION_RULES as xt, PRE_DELETE_SNAPSHOT_TYPES as y, partitionSensitiveEnv as yn, StateError as yr, requireConfigObject as yt, collectPublishedOutputNames as z, MIGRATE_TMP_PREFIX as zn, applyRoleArnIfSet as zt };
-//# sourceMappingURL=deploy-engine-Dnp730rc.js.map
+export { startInterruptWatch as $, AwsClients as $n, shouldRetainResource as $t, renderStatefulReason as A, getLegacyStateBucketName as An, isThrottlingError as Ar, redactSecretsForState as At, exportAliasCollisionScrubWarning as B, CFN_TEMPLATE_BODY_LIMIT as Bn, DiffCalculator as Bt, isFinalSnapshotError as C, runDockerForeground as Cn, SynthesisError as Cr, TEMPLATE_SOURCED_RULES as Ct, extractDeploymentEventError as D, Synthesizer as Dn, withErrorHandling as Dr, isSingleDynamicReferenceToken as Dt, makeCanonicalizePropertiesFn as E, getDockerImageBySourceHash as En, normalizeAwsError as Er, errorCauseChain as Et, green as F, resolveStateBucketWithDefault as Fn, s3BucketDomainName as Ft, collectInlinePolicyNamesManagedBySiblings as G, expectedOwnerParam as Gn, TemplateParser as Gt, secretBearingStateKeyWarning as H, MIGRATE_TMP_PREFIX as Hn, describeTypeWithThrottleRetry as Ht, red as I, resolveStateBucketWithDefaultAndSource as In, s3BucketDualStackDomainName as It, findActionableSilentDrops as J, derivePartitionAndUrlSuffix as Jn, S3StateBackend as Jt, clearOnUpdateRemoval as K, PARTITION_TABLE as Kn, LockManager as Kt, yellow as L, resolveUseCdkBootstrapAssets as Ln, s3BucketRegionalDomainName as Lt, bold as M, resolveAutoAssetStorage as Mn, __exportAll as Mr, classifyReplaySecretRegion as Mt, cyan as N, resolveCaptureObservedState as Nn, producerRegionsFromState as Nt, MULTI_REGION_RECREATE_BLOCKED_TYPES as O, synthesisStatusMessage as On, isMarkedNonRetryable as Or, maskSecretsInError as Ot, gray as P, resolveSkipPrefix as Pn, s3BucketArn as Pt, isInterruptedWaitError as Q, resolveBucketRegion as Qn, importableOutputs as Qt, collectDeclaredOutputNames as R, stateBucketExistenceConfirmed as Rn, s3BucketWebsiteUrl as Rt, createPreDeleteFinalSnapshot as S, partitionSensitiveEnv as Sn, StateError as Sr, STATE_SOURCED_READBACK_RULES as St, unsupportedFinalSnapshotError as T, AssetManifestLoader as Tn, isCdkdError as Tr, dynamicReferenceTokens as Tt, stateKeySecretExposure as U, findLargeInlineResources as Un, withRetry as Ut, isExportAliasCollision as V, CFN_TEMPLATE_URL_LIMIT as Vn, INTRINSIC_KEYS as Vt, IAMRoleProvider as W, uploadCfnTemplate as Wn, DagBuilder as Wt, beginCommandInterruptScope as X, processStackMessages as Xn, exportNamesCarriedFrom as Xt, findSilentDropProperties as Y, AssemblyReader as Yn, rebuildClientForBucketRegion as Yt, endCommandInterruptScope as Z, clearBucketRegionCache as Zn, importableOutputKeys as Zt, computeImplicitDeleteEdges as _, buildDenyExternalAccessPolicy as _n, ProvisioningError as _r, replayWarn as _t, DeploymentEventsStore as a, loadPublishableAssetManifest as an, ConfigError as ar, carriesDynamicReference as at, buildFinalSnapshotIdentifier as b, formatDockerLoginError as bn, StackHasActiveImportsError as br, requireConfigString as bt, replayFailedOperations as c, stripControlChars as cn, DeployCancelledError as cr, refStateLookupFromResource as ct, updatePartialReason as d, ensureAssetStorage as dn, LocalMigrateError as dr, resolveExplicitPhysicalId as dt, AssetPublisher as en, getAwsClients as er, CloudControlProvider as et, UNSPECIFIED_SKIP_REASON as f, getBootstrapMarkerKey as fn, LocalStartServiceError as fr, assertRegionMatch as ft, IMPLICIT_DELETE_DEPENDENCIES as g, validateContainerRepoName as gn, PartialFailureError as gr, readConfigString as gt, maskingRetryLogger as h, validateAssetBucketName as hn, NestedStackChildDirectDestroyError as hr, configStringRefusal as ht, DeploymentEventsReader as i, createAssetRedirectResolver as in, CdkdError as ir, IntrinsicFunctionResolver as it, formatResourceLine as j, resolveApp as jn, markNonRetryable as jr, scrubResourceRecord as jt, isStatefulRecreateTargetSync as k, getDefaultStateBucketName as kn, isRetryableTransientError as kr, maskSecretsInText as kt, replayRollback as l, AssetModeResolver as ln, DynamicReferenceRegionAmbiguousError as lr, WAFv2WebACLProvider as lt, withResourceDeadline as m, readBootstrapMarkerBody as mn, MissingCdkCliError as mr, configBooleanRefusal as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, WorkGraph as nn, setAwsClients as nr, disableInstanceApiTermination as nt, planFailedOps as o, rewriteTemplateAssetReferences as on, CrossAccountSecretRefusalError as or, cfnRefValueFromPhysicalId as ot, deleteSkipReason as p, parseBootstrapMarker as pn, LockError as pr, coerceCfnBoolean as pt, ProviderRegistry as q, canonicalizeRegion as qn, displaySafe as qt, DeployEngine as r, buildAssetRedirectMap as rn, AssetError as rr, isTerminationProtectionPropagationError as rt, planRollback as s, escapeRegExp$1 as sn, DependencyError as sr, getAccountInfo as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, stringifyValue as tn, resetAwsClients as tr, slowCcOperationTimeoutMs as tt, updatePartialMessage as u, BOOTSTRAP_MARKER_PREFIX as un, LocalInvokeBuildError as ur, normalizeAwsTagsToCfn as ut, ATOMIC_FINAL_SNAPSHOT_TYPES as v, buildDockerImage as vn, ResourceTimeoutError as vr, requireConfigArray as vt, refusesFinalSnapshot as w, runDockerStreaming as wn, formatError as wr, createSecretMasker as wt, ccRoutedFinalSnapshotError as x, getDockerCmd as xn, StackTerminationProtectionError as xr, STATE_SOURCED_CROSS_GENERATION_RULES as xt, PRE_DELETE_SNAPSHOT_TYPES as y, dockerSpawnEnvWithSensitive as yn, ResourceUpdateNotSupportedError as yr, requireConfigObject as yt, collectPublishedOutputNames as z, warnDeprecatedNoPrefixCliFlag as zn, applyRoleArnIfSet as zt };
+//# sourceMappingURL=deploy-engine-DOP4V6eK.js.map