@go-to-k/cdkd 0.284.24 → 0.284.26

package/dist/{deploy-engine-BJQbni1s.js → deploy-engine-DNCs229s.js}

@@ -6838,6 +6838,19 @@ var S3StateBackend = class {
 	* but `--state-prefix` overrides at the consumer side propagate
 	* cleanly).
 	*/
+	/**
+	* Release the S3 client this backend currently holds.
+	*
+	* The backend OWNS its client and may destroy and REPLACE it
+	* (`ensureClientForBucket` rebuilds when the bucket turns out to live in
+	* another region). So a caller that keeps its own reference and destroys
+	* that instead destroys the dead original and leaks the live replacement —
+	* which is exactly what a short-lived probe backend does in the cross-region
+	* case. Callers that construct a throwaway backend use this instead.
+	*/
+	destroyClient() {
+		this.s3Client.destroy();
+	}
 	get prefix() {
 		return this.config.prefix;
 	}
@@ -16860,7 +16873,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-Bh0odlSk.js").then((n) => n.n);
+			const { ASGProvider } = await import("./asg-provider-CS5j-5z6.js").then((n) => n.n);
 			return await new ASGProvider().delete(logicalId, physicalId, resourceType, _properties, context);
 		}
 		const isProtectedEc2Instance = context?.removeProtection === true && resourceType === "AWS::EC2::Instance";
@@ -17531,6 +17544,280 @@ var CloudControlProvider = class {
 	}
 };
 
+//#endregion
+//#region src/provisioning/interrupt-watch.ts
+/**
+* The ONE interrupt watch every bounded wait under `src/provisioning/**` uses
+* (issues #2053 / #1952, consolidating the per-invocation shape PR #2033
+* introduced in `providers/custom-resource-provider.ts`).
+*
+* WHY A WAIT NEEDS ONE AT ALL
+* ---------------------------
+* `withRetry` (`src/deployment/retry.ts`) is the only wait in cdkd that
+* consults an interrupt DURING a backoff — it probes once a second while
+* sleeping. The deploy engine, `destroy-runner.ts` and `rollback-executor.ts`
+* all poll only BETWEEN operations. So a retry that threads nothing is dead to
+* Ctrl-C for its whole schedule, and on the destroy path `withResourceTimeout`
+* has by then abandoned the promise WITHOUT cancelling it, so the loop keeps
+* issuing writes behind a run the user was told had ended.
+* `docs/provider-development.md` states the requirement; `vp run
+* audit:withretry-interrupt:check` enforces it.
+*
+* WHY IT IS SHARED RATHER THAN PER MODULE
+* ---------------------------------------
+* Four modules carried a copy before issue #2104, and the copies could not
+* agree about the one thing that matters: a single `delete()` traverses more
+* than one of them, so a SIGINT marked only whichever module happened to hold a
+* live watch. One module means one latch, one error type, and ONE process
+* listener rather than four.
+*
+* FOUR PROPERTIES, EACH LOAD-BEARING
+* ----------------------------------
+*
+* 1. **The flag is per WAIT, never on a provider.** Providers are registered as
+*    SINGLETONS serving concurrent resources, so provider-level state is some
+*    other resource's.
+*
+* 2. **The latch is STICKY.** A watch STARTED after the signal begins is
+*    already interrupted. Clearing it when the last watch is disposed — the
+*    first cut — is wrong for exactly the case issue #1952 is about: a
+*    `GlobalTable` delete runs the #1521 gate, then the index-busy retry loop,
+*    then the gone-wait, each disposing before the next begins, so a SIGINT
+*    during the gate left the two multi-minute waits after it DEAF. Only a
+*    COMMAND clears it. The listener is likewise never torn down BETWEEN two
+*    waits: one removed in that gap cannot record a signal landing in it, which
+*    is the same bug one layer down. {@link endCommandInterruptScope} removes it
+*    at command END, where there is no next wait to miss.
+*
+* 3. **It arms only inside a command that OWNS interrupt handling.** Registering
+*    any SIGINT listener disables Node's default terminate, so a command with no
+*    graceful shutdown of its own must not gain one here: `cdkd drift --revert`
+*    reaches `provider.update` and installs nothing, and an armed watch there
+*    would leave Ctrl-C setting flags nobody reads while the command carried on
+*    writing to AWS — needing a SIGKILL.
+*
+*    The gate is an explicit flag raised by
+*    {@link beginCommandInterruptScope}, which `forwardSigtermToSigint()` calls
+*    at command start. It is deliberately NOT
+*    `process.listenerCount('SIGINT') > 0`, which was the first cut and is
+*    defeated by the very case it was meant to catch: `cdkd drift` runs
+*    `provider.update` at concurrency 4, and a concurrent CloudFront / ACM /
+*    Route53 wait installs a TRANSIENT SIGINT listener of its own — so an ELBv2
+*    update starting inside that window saw a non-zero count, armed, and then
+*    kept the listener for the rest of the command after the transient one was
+*    removed. A count answers "is anyone listening right now"; the question is
+*    "does this COMMAND have a shutdown path", and only the command can say.
+*    (`forwardSigtermToSigint` itself registers on SIGTERM only, so it never
+*    satisfied the count either — a detail an earlier version of this comment
+*    got wrong, which is how the gap survived a review.)
+*
+*    Arming is re-attempted on every watch, so a wait that runs before the
+*    command opens its scope does not poison later ones.
+*
+* 4. **The handler force-quits when it is the LAST listener.** Property 3 gets
+*    the watch armed only under a command with a shutdown path, but that path
+*    is not live for the command's whole duration: `destroy.ts` registers no
+*    SIGINT handler of its own, and `destroy-runner.ts` removes its one in a
+*    `finally` — so between two stacks of a multi-stack destroy the shared
+*    handler is the ONLY listener. Merely latching there SWALLOWS the Ctrl-C:
+*    the process does not exit, `draining` is never set, `result.interrupted`
+*    stays false, and the loop proceeds to delete the NEXT stack after the user
+*    asked to stop — this file's own headline failure, one layer out.
+*
+*    So when no other listener remains, the handler restores exactly what Node
+*    would have done with no listener at all. That is deliberately not a second
+*    graceful path: inventing one would duplicate `destroy-runner.ts`'s drain
+*    and have to be kept in sync with it, whereas "there is no graceful owner
+*    right now, so terminate" is true by construction and needs no upkeep.
+*/
+/**
+* Thrown by {@link InterruptWatch.onInterrupted}, and the ONE type the whole
+* codebase uses to mean "a wait stopped because the user asked us to stop".
+*
+* It has to be a distinct class rather than a bare `Error` because
+* `deploy-engine.ts` decides whether to ROLL BACK by asking what the failure
+* was. Its own `InterruptedError` is module-private, so a provider cannot
+* produce one; a bare `Error` from a provider therefore read as a genuine
+* resource failure and triggered an automatic rollback of the whole stack on
+* Ctrl-C — strictly worse than the unresponsiveness the threading removes.
+*
+* The explicit `setPrototypeOf` is not decoration: without it a subclass of
+* `Error` loses `instanceof` under this repo's compile target, which would make
+* {@link isInterruptedWaitError} silently answer `false`.
+*/
+var InterruptedWaitError = class InterruptedWaitError extends Error {
+	constructor(what) {
+		super(`${what} interrupted by user (SIGINT)`);
+		this.name = "InterruptedWaitError";
+		Object.setPrototypeOf(this, InterruptedWaitError.prototype);
+	}
+};
+/**
+* Whether `error` IS an interrupt, or WRAPS one.
+*
+* The wrap is the normal case, not the edge case: every provider catch under
+* `src/provisioning/providers/**` re-throws AWS failures as a
+* `ProvisioningError` threading the original as `cause` (issue #2040, enforced
+* by `vp run audit:provider-error-cause:check`), so by the time the engine sees
+* an interrupt it is one or more `cause` hops down. A plain `instanceof` check
+* at the engine would therefore have been a placebo.
+*
+* **The walk is bounded by a VISITED SET, not by a depth ceiling**, and the
+* difference decides correctness rather than style. A ceiling has to be sized
+* against the deepest real chain, and that chain GROWS: the flat case is 2 (the
+* provider's own wrap, then the command's), `DagExecutor` adds none — it
+* collects rather than wraps (`dag-executor.ts:178`) — but `deploy-engine.ts`
+* adds one `ProvisioningError` PER NESTED-STACK LEVEL (`deploy-engine.ts:2932`;
+* `NestedStackProvider.create` adds none of its own). A depth-5 cap therefore
+* missed at four levels of nesting, and missing here is not a degraded answer:
+* it is a full automatic rollback on Ctrl-C. The visited set gives the
+* termination the cap was really there for — a cyclic `cause` chain, which
+* would otherwise spin on the ERROR path where nothing else is watching —
+* without a ceiling any legitimate nest can cross.
+*/
+function isInterruptedWaitError(error) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current !== void 0 && current !== null) {
+		if (current instanceof InterruptedWaitError) return true;
+		if (!(current instanceof Error)) return false;
+		if (seen.has(current)) return false;
+		seen.add(current);
+		current = current.cause;
+	}
+	return false;
+}
+const liveWatches = /* @__PURE__ */ new Set();
+let sharedSigintHandler;
+let sigintLatched = false;
+/**
+* Test seam for the "this command owns interrupt handling" gate and for the
+* force-quit in property 4.
+*
+* Production never assigns either, and neither condition may be weakened to
+* accommodate tests: a command without a shutdown path really must keep Node's
+* default terminate, and a swallowed Ctrl-C in a multi-stack destroy really is
+* a blocker. `cdkd drift --revert` and `cdkd destroy` are the live instances.
+*
+* `commandOwnsInterrupts` exists because a provider suite never runs a COMMAND,
+* so every interrupt test would otherwise exercise the UNARMED path while
+* appearing to test the armed one — the worst of both, since it fails for a
+* reason unrelated to what the test claims. `forceQuit` exists because the real
+* one calls `process.exit`, which would take the test runner with it.
+*/
+const interruptWatchTestSeam = {};
+/**
+* How many command scopes are currently open.
+*
+* A COUNTER rather than a boolean, because a boolean is only correct while
+* scopes never overlap. The CLI runs one command per process so they do not
+* today — but this module's own contract offers itself to "a host that runs
+* more than one command", and under a boolean the inner scope's `end` would
+* remove the shared listener and clear the OUTER command's sticky latch
+* mid-run, so a signal landing in the re-arm gap goes unrecorded. That is
+* exactly what property 2 forbids, arrived at from the other direction.
+*/
+let commandInterruptScopeDepth = 0;
+function commandOwnsInterrupts() {
+	const override = interruptWatchTestSeam.commandOwnsInterrupts;
+	if (override !== void 0) return override();
+	return commandInterruptScopeDepth > 0;
+}
+/**
+* Install the ONE process listener, if and only if the running command has
+* declared that it owns interrupt handling. See property 3 for why the "if" is
+* load-bearing rather than defensive.
+*
+* Called on every `startInterruptWatch` rather than once, so a wait that runs
+* before the command opens its interrupt scope leaves the door open instead of
+* latching a permanent "unarmed".
+*/
+function armSharedSigintHandler() {
+	if (sharedSigintHandler !== void 0) return;
+	if (!commandOwnsInterrupts()) return;
+	const handler = () => {
+		sigintLatched = true;
+		for (const live of liveWatches) live.interrupted = true;
+		if (process.listeners("SIGINT").filter((l) => l !== handler).length === 0) {
+			process.stderr.write("\nInterrupted.\nIf the next run reports a stack lock, release it with: cdkd force-unlock <stack-name>\n");
+			(interruptWatchTestSeam.forceQuit ?? ((code) => process.exit(code)))(130);
+		}
+	};
+	sharedSigintHandler = handler;
+	process.on("SIGINT", handler);
+}
+/**
+* Start a watch for ONE wait. `what` names the wait in the thrown message.
+*
+* The caller MUST `dispose()` in a `finally`. A leaked watch is not merely
+* untidy: it stays in {@link liveWatches} forever, and the sticky latch means
+* every wait after a Ctrl-C would keep aborting instantly even if the run
+* somehow continued.
+*/
+function startInterruptWatch(what) {
+	armSharedSigintHandler();
+	const state = { interrupted: sigintLatched };
+	liveWatches.add(state);
+	let disposed = false;
+	return {
+		isInterrupted: () => state.interrupted,
+		onInterrupted: () => new InterruptedWaitError(what),
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			liveWatches.delete(state);
+		}
+	};
+}
+/**
+* Clear the sticky latch.
+*
+* Called by {@link beginCommandInterruptScope} and
+* {@link endCommandInterruptScope}, which bracket one command. On the CLI one
+* process runs one command, so the latch starts false regardless and those
+* calls are belt-and-braces; they earn their keep for a host that runs more
+* than one command, and for unit suites, where every test shares one process
+* and a simulated Ctrl-C would otherwise leak into every test after it.
+*
+* Deliberately NOT wired into `dispose()` — see property 2. That was the first
+* cut and it is precisely the bug: sequential waits always empty the live set
+* between them, so the latch cleared in every gap that mattered.
+*/
+function resetInterruptWatchLatch() {
+	sigintLatched = false;
+	for (const live of liveWatches) live.interrupted = false;
+}
+/**
+* Declare that this command owns interrupt handling, and clear the latch.
+*
+* Called by `forwardSigtermToSigint()` (`src/utils/interrupt-signals.ts`),
+* which every command that reaches a provider wait through a lock invokes at
+* start — `deploy`, `destroy`, `rollback`, `state`. A command that does NOT
+* call it (`cdkd drift`) keeps Node's default terminate, which is the point.
+*/
+function beginCommandInterruptScope() {
+	commandInterruptScopeDepth += 1;
+	if (commandInterruptScopeDepth === 1) resetInterruptWatchLatch();
+}
+/**
+* Close the scope — the command is done.
+*
+* Removing the shared listener HERE does not weaken property 2: what must never
+* happen is a teardown between two sequential WAITS, because a signal landing
+* in that gap would go unrecorded. At command end there is no next wait, and
+* leaving the listener installed would suppress default terminate for whatever
+* runs after.
+*/
+function endCommandInterruptScope() {
+	commandInterruptScopeDepth = Math.max(0, commandInterruptScopeDepth - 1);
+	if (commandInterruptScopeDepth > 0) return;
+	if (sharedSigintHandler !== void 0) {
+		process.removeListener("SIGINT", sharedSigintHandler);
+		sharedSigintHandler = void 0;
+	}
+	resetInterruptWatchLatch();
+}
+
 //#endregion
 //#region src/provisioning/providers/custom-resource-provider.ts
 /**
@@ -18533,7 +18820,7 @@ var CustomResourceProvider = class CustomResourceProvider {
 	* #2054, which replaced its warn-and-continue).
 	*/
 	async invokeCustomResourceWithRetry(serviceToken, logicalId, operation, buildRequest) {
-		const watch = this.startInterruptWatch(logicalId);
+		const watch = startInterruptWatch(`Custom resource ${logicalId}`);
 		try {
 			const stackId = await this.resolveSyntheticStackId(logicalId);
 			let preDeliveryRetries = 0;
@@ -19084,33 +19371,6 @@ var CustomResourceProvider = class CustomResourceProvider {
 		return customResourceRetryDelays.sleep(ms);
 	}
 	/**
-	* Install a SIGINT watch for one custom-resource invocation (issue #2033).
-	*
-	* `docs/provider-development.md` requires a new `withRetry` to thread
-	* `isInterrupted` / `onInterrupted`, and a hand-rolled backoff to be
-	* interruptible for the same reason: without it Ctrl-C is dead for the whole
-	* 47.75s schedule. The provider already had the shape — `pollS3Response`
-	* installs its own handler — so this is that pattern, lifted so the two new
-	* wait sites share one flag and one disposal.
-	*
-	* The caller MUST `dispose()` in a `finally`; a leaked listener would
-	* accumulate one per resource across a deploy.
-	*/
-	startInterruptWatch(logicalId) {
-		let interrupted = false;
-		const handler = () => {
-			interrupted = true;
-		};
-		process.on("SIGINT", handler);
-		return {
-			isInterrupted: () => interrupted,
-			onInterrupted: () => /* @__PURE__ */ new Error(`Custom resource ${logicalId} interrupted by user`),
-			dispose: () => {
-				process.removeListener("SIGINT", handler);
-			}
-		};
-	}
-	/**
 	* `sleep` that checks the interrupt watch at most a second apart, mirroring
 	* `withRetry`'s own once-per-second probe. Throws the watch's error when the
 	* user has hit Ctrl-C, so the retry loop unwinds instead of sitting out the
@@ -25526,7 +25786,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.284.24";
+	return "0.284.26";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -26970,7 +27230,7 @@ var DeployEngine = class {
 				this.logger.warn(`Failed to save partial state before rollback: ${saveError instanceof Error ? saveError.message : String(saveError)}`);
 			}
 			let autoRollbackClean = false;
-			if (error instanceof InterruptedError) {
+			if (error instanceof InterruptedError || isInterruptedWaitError(error)) {
 				await this.writeRollbackJournalSegment(stackName, completedOperations, failedOperations, "interrupted", initialDeploy);
 				this.logger.info(`Partial state saved (${Object.keys(newResources).length} resources). Run deploy again to resume, 'cdkd rollback' to revert, or destroy to clean up.`);
 				throw error;
@@ -27740,7 +28000,7 @@ var DeployEngine = class {
 					}), 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`);
+					if (!isInterruptedWaitError(deleteError) && (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`);
 					else throw deleteError;
 				}
 				const deleteSkipped = deleteSkipReason(deleteResult);
@@ -28146,5 +28406,5 @@ var DeployEngine = class {
 };
 
 //#endregion
-export { disableInstanceApiTermination as $, NestedStackChildDirectDestroyError as $n, ensureAssetStorage as $t, isStatefulRecreateTargetSync as A, uploadCfnTemplate as An, s3BucketWebsiteUrl as At, collectPublishedOutputNames as B, getAwsClients as Bn, rebuildClientForBucketRegion as Bt, createPreDeleteFinalSnapshot as C, resolveUseCdkBootstrapAssets as Cn, maskSecretsInText as Ct, makeCanonicalizePropertiesFn as D, CFN_TEMPLATE_URL_LIMIT as Dn, s3BucketDomainName as Dt, unsupportedFinalSnapshotError as E, CFN_TEMPLATE_BODY_LIMIT as En, s3BucketArn as Et, gray as F, AssemblyReader as Fn, withRetry as Ft, IAMRoleProvider as G, ConfigError as Gn, buildAssetRedirectMap as Gt, isExportAliasCollision as H, setAwsClients as Hn, AssetPublisher as Ht, green as I, processStackMessages as In, DagBuilder as It, ProviderRegistry as J, LocalInvokeBuildError as Jn, rewriteTemplateAssetReferences as Jt, collectInlinePolicyNamesManagedBySiblings as K, DependencyError as Kn, createAssetRedirectResolver as Kt, red as L, clearBucketRegionCache as Ln, TemplateParser as Lt, formatResourceLine as M, PARTITION_TABLE as Mn, DiffCalculator as Mt, bold as N, canonicalizeRegion as Nn, INTRINSIC_KEYS as Nt, extractDeploymentEventError as O, MIGRATE_TMP_PREFIX as On, s3BucketDualStackDomainName as Ot, cyan as P, derivePartitionAndUrlSuffix as Pn, describeTypeWithThrottleRetry as Pt, slowCcOperationTimeoutMs as Q, MissingCdkCliError as Qn, BOOTSTRAP_MARKER_PREFIX as Qt, yellow as R, resolveBucketRegion as Rn, LockManager as Rt, ccRoutedFinalSnapshotError as S, resolveStateBucketWithDefaultAndSource as Sn, isSingleDynamicReferenceToken as St, refusesFinalSnapshot as T, warnDeprecatedNoPrefixCliFlag as Tn, scrubResourceRecord as Tt, secretBearingStateKeyWarning as U, AssetError as Un, stringifyValue as Ut, exportAliasCollisionScrubWarning as V, resetAwsClients as Vn, shouldRetainResource as Vt, stateKeySecretExposure as W, CdkdError as Wn, WorkGraph as Wt, findSilentDropProperties as X, LocalStartServiceError as Xn, stripControlChars as Xt, findActionableSilentDrops as Y, LocalMigrateError as Yn, escapeRegExp$1 as Yt, CloudControlProvider as Z, LockError as Zn, AssetModeResolver as Zt, IMPLICIT_DELETE_DEPENDENCIES as _, resolveApp as _n, STATE_SOURCED_CROSS_GENERATION_RULES as _t, DeploymentEventsStore as a, buildDenyExternalAccessPolicy as an, StackTerminationProtectionError as ar, WAFv2WebACLProvider as at, PRE_DELETE_SNAPSHOT_TYPES as b, resolveSkipPrefix as bn, createSecretMasker as bt, producerRegionsFromState as c, getDockerCmd as cn, formatError as cr, assertRegionMatch as ct, updatePartialMessage as d, AssetManifestLoader as dn, withErrorHandling as dr, configStringRefusal as dt, getBootstrapMarkerKey as en, PartialFailureError as er, isTerminationProtectionPropagationError as et, updatePartialReason as f, getDockerImageBySourceHash as fn, isMarkedNonRetryable as fr, readConfigString as ft, maskingRetryLogger as g, getLegacyStateBucketName as gn, __exportAll as gr, requireConfigString as gt, withResourceDeadline as h, getDefaultStateBucketName as hn, markNonRetryable as hr, requireConfigObject as ht, DeploymentEventsReader as i, validateContainerRepoName as in, StackHasActiveImportsError as ir, refStateLookupFromResource as it, renderStatefulReason as j, expectedOwnerParam as jn, applyRoleArnIfSet as jt, MULTI_REGION_RECREATE_BLOCKED_TYPES as k, findLargeInlineResources as kn, s3BucketRegionalDomainName as kt, replayFailedOperations as l, runDockerForeground as ln, isCdkdError as lr, coerceCfnBoolean as lt, deleteSkipReason as m, synthesisStatusMessage as mn, isThrottlingError as mr, requireConfigArray as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, readBootstrapMarkerBody as nn, ResourceTimeoutError as nr, cfnRefValueFromPhysicalId as nt, planFailedOps as o, buildDockerImage as on, StateError as or, normalizeAwsTagsToCfn as ot, UNSPECIFIED_SKIP_REASON as p, Synthesizer as pn, isRetryableTransientError as pr, replayWarn as pt, clearOnUpdateRemoval as q, DeployCancelledError as qn, loadPublishableAssetManifest as qt, DeployEngine as r, validateAssetBucketName as rn, ResourceUpdateNotSupportedError as rr, getAccountInfo as rt, planRollback as s, formatDockerLoginError as sn, SynthesisError as sr, resolveExplicitPhysicalId as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, parseBootstrapMarker as tn, ProvisioningError as tr, IntrinsicFunctionResolver as tt, replayRollback as u, runDockerStreaming as un, normalizeAwsError as ur, configBooleanRefusal as ut, computeImplicitDeleteEdges as v, resolveAutoAssetStorage as vn, STATE_SOURCED_READBACK_RULES as vt, isFinalSnapshotError as w, stateBucketExistenceConfirmed as wn, redactSecretsForState as wt, buildFinalSnapshotIdentifier as x, resolveStateBucketWithDefault as xn, dynamicReferenceTokens as xt, ATOMIC_FINAL_SNAPSHOT_TYPES as y, resolveCaptureObservedState as yn, TEMPLATE_SOURCED_RULES as yt, collectDeclaredOutputNames as z, AwsClients as zn, S3StateBackend as zt };
-//# sourceMappingURL=deploy-engine-BJQbni1s.js.map
+export { isInterruptedWaitError as $, LocalMigrateError as $n, escapeRegExp$1 as $t, isStatefulRecreateTargetSync as A, CFN_TEMPLATE_BODY_LIMIT as An, s3BucketArn as At, collectPublishedOutputNames as B, processStackMessages as Bn, DagBuilder as Bt, createPreDeleteFinalSnapshot as C, resolveCaptureObservedState as Cn, TEMPLATE_SOURCED_RULES as Ct, makeCanonicalizePropertiesFn as D, resolveUseCdkBootstrapAssets as Dn, maskSecretsInText as Dt, unsupportedFinalSnapshotError as E, resolveStateBucketWithDefaultAndSource as En, isSingleDynamicReferenceToken as Et, gray as F, expectedOwnerParam as Fn, applyRoleArnIfSet as Ft, IAMRoleProvider as G, resetAwsClients as Gn, shouldRetainResource as Gt, isExportAliasCollision as H, resolveBucketRegion as Hn, LockManager as Ht, green as I, PARTITION_TABLE as In, DiffCalculator as It, ProviderRegistry as J, CdkdError as Jn, WorkGraph as Jt, collectInlinePolicyNamesManagedBySiblings as K, setAwsClients as Kn, AssetPublisher as Kt, red as L, canonicalizeRegion as Ln, INTRINSIC_KEYS as Lt, formatResourceLine as M, MIGRATE_TMP_PREFIX as Mn, s3BucketDualStackDomainName as Mt, bold as N, findLargeInlineResources as Nn, s3BucketRegionalDomainName as Nt, extractDeploymentEventError as O, stateBucketExistenceConfirmed as On, redactSecretsForState as Ot, cyan as P, uploadCfnTemplate as Pn, s3BucketWebsiteUrl as Pt, endCommandInterruptScope as Q, LocalInvokeBuildError as Qn, rewriteTemplateAssetReferences as Qt, yellow as R, derivePartitionAndUrlSuffix as Rn, describeTypeWithThrottleRetry as Rt, ccRoutedFinalSnapshotError as S, resolveAutoAssetStorage as Sn, STATE_SOURCED_READBACK_RULES as St, refusesFinalSnapshot as T, resolveStateBucketWithDefault as Tn, dynamicReferenceTokens as Tt, secretBearingStateKeyWarning as U, AwsClients as Un, S3StateBackend as Ut, exportAliasCollisionScrubWarning as V, clearBucketRegionCache as Vn, TemplateParser as Vt, stateKeySecretExposure as W, getAwsClients as Wn, rebuildClientForBucketRegion as Wt, findSilentDropProperties as X, DependencyError as Xn, createAssetRedirectResolver as Xt, findActionableSilentDrops as Y, ConfigError as Yn, buildAssetRedirectMap as Yt, beginCommandInterruptScope as Z, DeployCancelledError as Zn, loadPublishableAssetManifest as Zt, IMPLICIT_DELETE_DEPENDENCIES as _, Synthesizer as _n, isRetryableTransientError as _r, replayWarn as _t, DeploymentEventsStore as a, parseBootstrapMarker as an, ProvisioningError as ar, IntrinsicFunctionResolver as at, PRE_DELETE_SNAPSHOT_TYPES as b, getLegacyStateBucketName as bn, __exportAll as br, requireConfigString as bt, producerRegionsFromState as c, validateContainerRepoName as cn, StackHasActiveImportsError as cr, refStateLookupFromResource as ct, updatePartialMessage as d, formatDockerLoginError as dn, SynthesisError as dr, resolveExplicitPhysicalId as dt, stripControlChars as en, LocalStartServiceError as er, startInterruptWatch as et, updatePartialReason as f, getDockerCmd as fn, formatError as fr, assertRegionMatch as ft, maskingRetryLogger as g, getDockerImageBySourceHash as gn, isMarkedNonRetryable as gr, readConfigString as gt, withResourceDeadline as h, AssetManifestLoader as hn, withErrorHandling as hr, configStringRefusal as ht, DeploymentEventsReader as i, getBootstrapMarkerKey as in, PartialFailureError as ir, isTerminationProtectionPropagationError as it, renderStatefulReason as j, CFN_TEMPLATE_URL_LIMIT as jn, s3BucketDomainName as jt, MULTI_REGION_RECREATE_BLOCKED_TYPES as k, warnDeprecatedNoPrefixCliFlag as kn, scrubResourceRecord as kt, replayFailedOperations as l, buildDenyExternalAccessPolicy as ln, StackTerminationProtectionError as lr, WAFv2WebACLProvider as lt, deleteSkipReason as m, runDockerStreaming as mn, normalizeAwsError as mr, configBooleanRefusal as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, BOOTSTRAP_MARKER_PREFIX as nn, MissingCdkCliError as nr, slowCcOperationTimeoutMs as nt, planFailedOps as o, readBootstrapMarkerBody as on, ResourceTimeoutError as or, cfnRefValueFromPhysicalId as ot, UNSPECIFIED_SKIP_REASON as p, runDockerForeground as pn, isCdkdError as pr, coerceCfnBoolean as pt, clearOnUpdateRemoval as q, AssetError as qn, stringifyValue as qt, DeployEngine as r, ensureAssetStorage as rn, NestedStackChildDirectDestroyError as rr, disableInstanceApiTermination as rt, planRollback as s, validateAssetBucketName as sn, ResourceUpdateNotSupportedError as sr, getAccountInfo as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, AssetModeResolver as tn, LockError as tr, CloudControlProvider as tt, replayRollback as u, buildDockerImage as un, StateError as ur, normalizeAwsTagsToCfn as ut, computeImplicitDeleteEdges as v, synthesisStatusMessage as vn, isThrottlingError as vr, requireConfigArray as vt, isFinalSnapshotError as w, resolveSkipPrefix as wn, createSecretMasker as wt, buildFinalSnapshotIdentifier as x, resolveApp as xn, STATE_SOURCED_CROSS_GENERATION_RULES as xt, ATOMIC_FINAL_SNAPSHOT_TYPES as y, getDefaultStateBucketName as yn, markNonRetryable as yr, requireConfigObject as yt, collectDeclaredOutputNames as z, AssemblyReader as zn, withRetry as zt };
+//# sourceMappingURL=deploy-engine-DNCs229s.js.map