@kensio/yulin 1.21.3 → 1.21.4

package/dist/service/cloudformation/stack/sim-cfn-stack.js

@@ -29,8 +29,8 @@ export class SimCfnStack {
     updating;
     deletion;
     stackName;
+    stackId;
     resourceMap;
-    template;
     outputs = new Map();
     background;
     operations;
@@ -38,12 +38,12 @@ export class SimCfnStack {
     stackOutputs;
     cfnTemplate;
     constructor(properties) {
-        const { simAws, accountRegionScope, background, stackName, template, cdkOutContext, bindings, caller, resourceOrder, exports, } = properties;
+        const { simAws, accountRegionScope, background, stackName, stackId, template, cdkOutContext, bindings, caller, resourceOrder, exports, } = properties;
         this.background = background;
         this.stackName = stackName;
+        this.stackId = stackId;
         this.stackOutputs = new SimCfnStackOutputs({ stackName, exports });
         this.cfnTemplate = template;
-        this.template = this.cfnTemplate.template;
         this.resourceMap = makeSimCfnStackResourceMap({
             accountRegionScope,
             background,
@@ -67,14 +67,15 @@ export class SimCfnStack {
             background,
             stackName,
             runDeployment: async () => {
-                await this.createResources();
+                await this.operations.createAll(this.resourceMap);
+                this.resolveOutputs();
             },
         });
         this.updating = new SimCfnStackUpdateLifecycle({ background, stackName });
         this.deletion = new SimCfnStackDeletionLifecycle({
             background,
-            runTeardown: async () => {
-                await this.teardown();
+            runTeardown: async (deleteProperties) => {
+                await this.teardown(deleteProperties);
             },
         });
         this.operationStatus = new SimCfnStackOperationStatus({
@@ -87,19 +88,23 @@ export class SimCfnStack {
     get status() {
         return this.operationStatus.status;
     }
+    /** The parsed template this Stack is deployed from. */
+    get currentTemplate() {
+        return this.cfnTemplate;
+    }
+    /** The template body this Stack is deployed from. */
+    get template() {
+        return this.cfnTemplate.template;
+    }
     /** The error the operation the status reports failed with, if it failed. */
     get error() {
         return this.operationStatus.error;
     }
-    /**
-     * Start deploying this simulated Stack into simulated AWS.
-     */
+    /** Start deploying this simulated Stack into simulated AWS. */
     async deploy() {
         await this.lifecycle.deploy();
     }
-    /**
-     * Wait for the scheduled deployment task to finish.
-     */
+    /** Wait for the scheduled deployment task to finish. */
     async waitForDeployComplete() {
         await this.lifecycle.waitForComplete();
     }
@@ -119,13 +124,18 @@ export class SimCfnStack {
      * A template that came from a synthesis of its own brings the cloud assembly
      * it was written into with it, so Resources it replaces read the assets that
      * synthesis staged rather than the ones the Stack was deployed with.
+     *
+     * An update that fails is rolled back onto the template the Stack was
+     * deployed from, which the Stack goes on holding for as long as the update
+     * runs.
      */
     async update(template, properties = {}) {
         this.updating.assertNotUpdating();
+        const deployed = this.cfnTemplate;
         const updater = this.operations.updater({
             background: this.background,
             resources: this.resourceMap,
-            current: this.cfnTemplate,
+            current: deployed,
             updated: template,
         });
         updater.assertHasChanges();
@@ -134,15 +144,24 @@ export class SimCfnStack {
         // deployed it.
         this.operations.useUpdate(properties);
         this.cfnTemplate = template;
-        this.template = template.template;
-        await this.updating.update(async () => {
-            await updater.apply();
-            this.resolveOutputs();
+        await this.updating.update({
+            apply: async () => {
+                await updater.apply();
+                this.resolveOutputs();
+            },
+            rollBack: async () => {
+                await this.operations.rollBack({
+                    background: this.background,
+                    resources: this.resourceMap,
+                    current: this.cfnTemplate,
+                    updated: deployed,
+                });
+                this.cfnTemplate = deployed;
+                this.resolveOutputs();
+            },
         });
     }
-    /**
-     * Wait for the scheduled Stack update to finish.
-     */
+    /** Wait for the scheduled Stack update to finish. */
     async waitForUpdateComplete() {
         await this.updating.waitForComplete();
     }
@@ -153,13 +172,22 @@ export class SimCfnStack {
      * before the Resources have gone. The optional onDeleteComplete callback runs
      * once the teardown has finished successfully, which is when the Stack name
      * becomes free to use again.
+     *
+     * Resources named in retainResources are checked against the Stack before
+     * the teardown is scheduled. A caller naming one the Stack does not have is
+     * refused there, where a check in the background would only fail the
+     * deletion.
+     *
+     * The names are copied as the request is accepted. The teardown runs in the
+     * background, and a caller holding the array it passed could otherwise change
+     * which Resources are kept after the Stack agreed to keep them.
      */
     async delete(properties = {}) {
-        await this.deletion.delete(properties);
+        const retainResources = [...(properties.retainResources ?? [])];
+        this.operations.assertRetainable(this.resourceMap, retainResources);
+        await this.deletion.delete({ ...properties, retainResources });
     }
-    /**
-     * Wait for the scheduled Stack deletion to finish.
-     */
+    /** Wait for the scheduled Stack deletion to finish. */
     async waitForDeleteComplete() {
         await this.deletion.waitForComplete();
     }
@@ -170,8 +198,8 @@ export class SimCfnStack {
      * The Resource half of deleting a Stack, without the Stack-level status or
      * the Stack name release that delete() puts on top of it.
      */
-    async teardown() {
-        await this.operations.deleteAll(this.resourceMap);
+    async teardown(properties = {}) {
+        await this.operations.deleteAll(this.resourceMap, properties.retainResources);
         this.stackOutputs.release();
     }
     /** Every Stack Resource, in the order the template declared them. */
@@ -209,9 +237,12 @@ export class SimCfnStack {
     get skippedResourceDeletions() {
         return this.report.deletionSkipped;
     }
-    /** Resources a teardown left in simulated AWS, as their policy says to. */
+    /**
+     * Resources left in simulated AWS, whether a teardown stepped over them or
+     * an update replaced them and kept the deployed one.
+     */
     get retainedResources() {
-        return this.report.retained;
+        return [...this.report.retained, ...this.operations.retainedResources];
     }
     /** Every property or Parameter that did not reach simulated AWS as written. */
     get ignoredProperties() {
@@ -220,10 +251,6 @@ export class SimCfnStack {
     get report() {
         return new SimCfnStackResourceReport(this.resourceMap, this.cfnTemplate);
     }
-    async createResources() {
-        await this.operations.createAll(this.resourceMap);
-        this.resolveOutputs();
-    }
     resolveOutputs() {
         this.outputs = this.stackOutputs.resolve(this.cfnTemplate, this.resourceMap);
     }

package/dist/service/cloudformation/stack/sim-cfn-stack.type.d.ts

@@ -8,8 +8,9 @@ import type { SimCdkOutContext } from "../cdk/sim-cdk-out-context.js";
 import type { SimCfnBinding } from "../bind/sim-cfn-binding.js";
 import type { SimCfnExports } from "../export/sim-cfn-exports.js";
 import type { SimCfnResourceOrder } from "./deploy/sim-cfn-resource-order.js";
+import type { SimCfnStackId } from "./sim-cfn-stack-id.js";
 export type SimCloudFormationStackName = Brand<string, "SimCloudFormationStackName">;
-export type SimCloudFormationStackStatus = "REVIEW_IN_PROGRESS" | "CREATE_IN_PROGRESS" | "CREATE_COMPLETE" | "CREATE_FAILED" | "UPDATE_IN_PROGRESS" | "UPDATE_COMPLETE" | "UPDATE_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_COMPLETE" | "DELETE_FAILED";
+export type SimCloudFormationStackStatus = "REVIEW_IN_PROGRESS" | "CREATE_IN_PROGRESS" | "CREATE_COMPLETE" | "CREATE_FAILED" | "UPDATE_IN_PROGRESS" | "UPDATE_COMPLETE" | "UPDATE_FAILED" | "UPDATE_ROLLBACK_IN_PROGRESS" | "UPDATE_ROLLBACK_COMPLETE" | "UPDATE_ROLLBACK_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_COMPLETE" | "DELETE_FAILED";
 export interface SimCfnStackUpdateProperties {
     /**
      * The CDK cloud assembly the new template was synthesized into, when it came
@@ -29,6 +30,11 @@ export interface SimCloudFormationStackProperties {
     readonly accountRegionScope: SimAwsAccountRegionScope;
     readonly background: BackgroundScheduler;
     readonly stackName: SimCloudFormationStackName;
+    /**
+     * The unique ID this Stack was created with, which is what a deleted Stack
+     * is still described by once its name has gone back into circulation.
+     */
+    readonly stackId: SimCfnStackId;
     readonly template: SimCfnTemplate;
     readonly cdkOutContext?: SimCdkOutContext | undefined;
     readonly bindings?: readonly SimCfnBinding[] | undefined;

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-deletion-lifecycle.d.ts

@@ -10,7 +10,7 @@ interface SimCfnStackDeletionLifecycleProperties {
      * stays outside this class, while status, error and completion handling stay
      * inside it.
      */
-    readonly runTeardown: () => Promise<void>;
+    readonly runTeardown: (properties: SimCfnStackDeleteProperties) => Promise<void>;
 }
 export interface SimCfnStackDeleteProperties {
     /**
@@ -20,6 +20,12 @@ export interface SimCfnStackDeleteProperties {
      * lifecycle only says when the name is free rather than freeing it.
      */
     readonly onDeleteComplete?: (() => void) | undefined;
+    /**
+     * Resources to leave in simulated AWS, named by logical ID or CDK construct
+     * ID. What DeleteStack RetainResources asks for, and it overrides whatever
+     * the Resource's own DeletionPolicy says.
+     */
+    readonly retainResources?: readonly string[] | undefined;
 }
 /**
  * Owns the simulated CloudFormation Stack deletion lifecycle state.

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-deletion-lifecycle.js

@@ -58,7 +58,9 @@ export class SimCfnStackDeletionLifecycle {
         });
         await scheduler.sequence();
         this.completePromise = scheduler.schedule({
-            operation: this.runTeardown,
+            operation: async () => {
+                await this.runTeardown(properties);
+            },
             onSuccess: () => {
                 this.#status = "DELETE_COMPLETE";
                 properties.onDeleteComplete?.();

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-resource-batch-deleter.d.ts

@@ -1,10 +1,12 @@
 import type { SimAws } from "../../../aws/sim-aws.js";
 import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
 import type { SimCfnResource } from "../../resource/sim-cfn-resource.js";
+import type { SimCfnResourceRetention } from "../../resource/delete/sim-cfn-resource-retention.js";
 interface SimCfnStackResourceBatchDeleterProperties {
     readonly simAws: SimAws;
     readonly resources: ReadonlyMap<string, SimCfnResource>;
     readonly caller?: SimAwsCaller | undefined;
+    readonly retention?: SimCfnResourceRetention | undefined;
 }
 /**
  * Deletes one batch of Stack Resources nothing still depends on.
@@ -20,6 +22,7 @@ export declare class SimCfnStackResourceBatchDeleter {
     private readonly simAws;
     private readonly resources;
     private readonly caller;
+    private readonly retention;
     constructor(properties: SimCfnStackResourceBatchDeleterProperties);
     /**
      * Delete the supplied Resources concurrently.

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-resource-batch-deleter.js

@@ -12,10 +12,12 @@ export class SimCfnStackResourceBatchDeleter {
     simAws;
     resources;
     caller;
+    retention;
     constructor(properties) {
         this.simAws = properties.simAws;
         this.resources = properties.resources;
         this.caller = properties.caller;
+        this.retention = properties.retention;
     }
     /**
      * Delete the supplied Resources concurrently.
@@ -28,6 +30,7 @@ export class SimCfnStackResourceBatchDeleter {
                 simAws: this.simAws,
                 resources: this.resources,
                 caller: this.caller,
+                retention: this.retention,
             });
         }));
     }

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-resource-deleter.d.ts

@@ -1,11 +1,14 @@
 import type { SimAws } from "../../../aws/sim-aws.js";
 import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
 import type { SimCfnResource } from "../../resource/sim-cfn-resource.js";
+import type { SimCfnResourceRetention } from "../../resource/delete/sim-cfn-resource-retention.js";
 interface SimCfnStackResourceDeleterProperties {
     readonly simAws: SimAws;
     readonly resources: ReadonlyMap<string, SimCfnResource>;
     readonly stackName: string;
     readonly caller?: SimAwsCaller | undefined;
+    /** Which of the Resources being deleted are to be left in simulated AWS. */
+    readonly retention?: SimCfnResourceRetention | undefined;
 }
 /**
  * Orchestrates reverse-dependency-ordered deletion of a Stack's Resources.

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-resource-deleter.js

@@ -20,13 +20,14 @@ export class SimCfnStackResourceDeleter {
     stackName;
     batchDeleter;
     constructor(properties) {
-        const { simAws, resources, stackName, caller } = properties;
+        const { simAws, resources, stackName, caller, retention } = properties;
         this.resources = resources;
         this.stackName = stackName;
         this.batchDeleter = new SimCfnStackResourceBatchDeleter({
             simAws,
             resources,
             caller,
+            retention,
         });
     }
     /**

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-retained-logical-ids.d.ts

@@ -0,0 +1,18 @@
+import type { SimCfnResource } from "../../resource/sim-cfn-resource.js";
+interface SimCfnStackRetainedLogicalIdsProperties {
+    readonly stackName: string;
+    readonly resources: ReadonlyMap<string, SimCfnResource>;
+    /** The identifiers DeleteStack named in RetainResources. */
+    readonly retainResources?: readonly string[] | undefined;
+}
+/**
+ * The logical IDs a DeleteStack call asked to keep, resolved against the Stack.
+ *
+ * An identifier the Stack has no Resource for is refused, as CloudFormation
+ * refuses one. A caller who misspells the Resource they meant to keep would
+ * otherwise watch it go. CDK construct IDs resolve here as well as logical IDs,
+ * the same way `getResource(...)` takes either. A test written against a
+ * synthesized template then needs no hashed logical ID.
+ */
+export declare function simCfnStackRetainedLogicalIds(properties: SimCfnStackRetainedLogicalIdsProperties): ReadonlySet<string>;
+export {};

package/dist/service/cloudformation/stack/teardown/sim-cfn-stack-retained-logical-ids.js

@@ -0,0 +1,30 @@
+import { SimCloudFormationValidationError } from "../../error/sim-cloudformation.error.js";
+import { SimCfnStackResourceLookup } from "../resource-map/sim-cfn-stack-resource-lookup.js";
+/**
+ * The logical IDs a DeleteStack call asked to keep, resolved against the Stack.
+ *
+ * An identifier the Stack has no Resource for is refused, as CloudFormation
+ * refuses one. A caller who misspells the Resource they meant to keep would
+ * otherwise watch it go. CDK construct IDs resolve here as well as logical IDs,
+ * the same way `getResource(...)` takes either. A test written against a
+ * synthesized template then needs no hashed logical ID.
+ */
+export function simCfnStackRetainedLogicalIds(properties) {
+    const { stackName, resources, retainResources = [] } = properties;
+    const lookup = new SimCfnStackResourceLookup(resources);
+    const retained = new Set();
+    const missing = [];
+    for (const identifier of retainResources) {
+        const resource = lookup.find(identifier);
+        if (resource === undefined) {
+            missing.push(identifier);
+        }
+        else {
+            retained.add(resource.logicalId);
+        }
+    }
+    if (missing.length > 0) {
+        throw new SimCloudFormationValidationError(`Invalid RetainResources: [${missing.join(", ")}] not found in Stack ${stackName}`);
+    }
+    return retained;
+}

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-guard.d.ts

@@ -0,0 +1,9 @@
+import type { SimCloudFormationStackName, SimCloudFormationStackStatus } from "../sim-cfn-stack.type.js";
+/**
+ * Refuse an update while one is already running, or being rolled back.
+ *
+ * CloudFormation takes one update at a time. A second here would read the
+ * difference to apply from a Stack half way through the first, or from one
+ * being put back on the template it was deployed from.
+ */
+export declare function assertSimCfnStackNotUpdating(stackName: SimCloudFormationStackName, status: SimCloudFormationStackStatus | undefined): void;

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-guard.js

@@ -0,0 +1,14 @@
+import { SimCloudFormationValidationError } from "../../error/sim-cloudformation.error.js";
+/**
+ * Refuse an update while one is already running, or being rolled back.
+ *
+ * CloudFormation takes one update at a time. A second here would read the
+ * difference to apply from a Stack half way through the first, or from one
+ * being put back on the template it was deployed from.
+ */
+export function assertSimCfnStackNotUpdating(stackName, status) {
+    if (status === "UPDATE_IN_PROGRESS" ||
+        status === "UPDATE_ROLLBACK_IN_PROGRESS") {
+        throw new SimCloudFormationValidationError(`Stack ${stackName} is in ${status} state and can not be updated`);
+    }
+}

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-lifecycle.d.ts

@@ -4,6 +4,14 @@ interface SimCfnStackUpdateLifecycleProperties {
     readonly background: BackgroundScheduler;
     readonly stackName: SimCloudFormationStackName;
 }
+/**
+ * The two halves of one Stack update: applying the new template, and putting
+ * the Stack back the way it was if that fails.
+ */
+export interface SimCfnStackUpdateWork {
+    readonly apply: () => Promise<void>;
+    readonly rollBack: () => Promise<void>;
+}
 /**
  * Owns the simulated CloudFormation Stack update lifecycle state.
  *
@@ -21,7 +29,9 @@ export declare class SimCfnStackUpdateLifecycle {
     private readonly background;
     private readonly stackName;
     private completePromise;
+    private rollbackPromise;
     private updateError;
+    private rollbackError;
     constructor(properties: SimCfnStackUpdateLifecycleProperties);
     /**
      * The current Stack update status, or undefined if the Stack has never been
@@ -30,14 +40,13 @@ export declare class SimCfnStackUpdateLifecycle {
     get status(): SimCloudFormationStackStatus | undefined;
     /**
      * The error captured during a background update, if any.
-     */
-    get error(): Error | undefined;
-    /**
-     * Refuse an update while one is already running.
      *
-     * CloudFormation takes one update at a time, and a second here would read
-     * the difference to apply from a Stack half way through the first.
+     * A rollback that failed answers with its own failure, because that is what
+     * the Stack is left in UPDATE_ROLLBACK_FAILED by and what has to be dealt
+     * with before the Stack works again.
      */
+    get error(): Error | undefined;
+    /** Refuse an update while one is already running, or being rolled back. */
     assertNotUpdating(): void;
     /**
      * Start the Stack update lifecycle.
@@ -46,17 +55,19 @@ export declare class SimCfnStackUpdateLifecycle {
      * and deletion do. The Resource work continues in the background, so callers
      * that need the final state should use waitForComplete().
      *
-     * An update that fails leaves the Stack in UPDATE_FAILED with the reason on
-     * it. Sim CloudFormation does not roll the Stack back to the template it was
-     * deployed from, so the Stack is left holding whatever the update managed.
+     * An update that fails is rolled back. The Stack moves to
+     * UPDATE_ROLLBACK_IN_PROGRESS with the reason on it, the rollback is
+     * scheduled as an operation of its own, and the Stack settles in
+     * UPDATE_ROLLBACK_COMPLETE, or in UPDATE_ROLLBACK_FAILED if the rollback
+     * could not finish either.
      */
-    update(runUpdate: () => Promise<void>): Promise<void>;
+    update(work: SimCfnStackUpdateWork): Promise<void>;
     /**
-     * Wait for the scheduled update to finish.
+     * Wait for the scheduled update to finish, rollback included.
      *
-     * If the update failed, this rethrows the captured error, so a caller can see
-     * what stopped the new template being applied. A Stack that was never updated
-     * has nothing to wait for.
+     * If the update failed, this rethrows the captured error once the Stack has
+     * settled, so a caller can see what stopped the new template being applied.
+     * A Stack that was never updated has nothing to wait for.
      */
     waitForComplete(): Promise<void>;
 }

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-lifecycle.js

@@ -1,5 +1,5 @@
-import { SimCloudFormationValidationError } from "../../error/sim-cloudformation.error.js";
 import { SimCfnStackOperationScheduler } from "../sim-cfn-stack-operation-scheduler.js";
+import { assertSimCfnStackNotUpdating } from "./sim-cfn-stack-update-guard.js";
 /**
  * Owns the simulated CloudFormation Stack update lifecycle state.
  *
@@ -17,7 +17,9 @@ export class SimCfnStackUpdateLifecycle {
     stackName;
     #status;
     completePromise;
+    rollbackPromise;
     updateError;
+    rollbackError;
     constructor(properties) {
         this.background = properties.background;
         this.stackName = properties.stackName;
@@ -31,20 +33,17 @@ export class SimCfnStackUpdateLifecycle {
     }
     /**
      * The error captured during a background update, if any.
+     *
+     * A rollback that failed answers with its own failure, because that is what
+     * the Stack is left in UPDATE_ROLLBACK_FAILED by and what has to be dealt
+     * with before the Stack works again.
      */
     get error() {
-        return this.updateError;
+        return this.rollbackError ?? this.updateError;
     }
-    /**
-     * Refuse an update while one is already running.
-     *
-     * CloudFormation takes one update at a time, and a second here would read
-     * the difference to apply from a Stack half way through the first.
-     */
+    /** Refuse an update while one is already running, or being rolled back. */
     assertNotUpdating() {
-        if (this.#status === "UPDATE_IN_PROGRESS") {
-            throw new SimCloudFormationValidationError(`Stack ${this.stackName} is in UPDATE_IN_PROGRESS state and can not be updated`);
-        }
+        assertSimCfnStackNotUpdating(this.stackName, this.#status);
     }
     /**
      * Start the Stack update lifecycle.
@@ -53,40 +52,58 @@ export class SimCfnStackUpdateLifecycle {
      * and deletion do. The Resource work continues in the background, so callers
      * that need the final state should use waitForComplete().
      *
-     * An update that fails leaves the Stack in UPDATE_FAILED with the reason on
-     * it. Sim CloudFormation does not roll the Stack back to the template it was
-     * deployed from, so the Stack is left holding whatever the update managed.
+     * An update that fails is rolled back. The Stack moves to
+     * UPDATE_ROLLBACK_IN_PROGRESS with the reason on it, the rollback is
+     * scheduled as an operation of its own, and the Stack settles in
+     * UPDATE_ROLLBACK_COMPLETE, or in UPDATE_ROLLBACK_FAILED if the rollback
+     * could not finish either.
      */
-    async update(runUpdate) {
+    async update(work) {
         this.#status = "UPDATE_IN_PROGRESS";
         this.updateError = undefined;
+        this.rollbackError = undefined;
+        this.rollbackPromise = undefined;
         const scheduler = new SimCfnStackOperationScheduler({
             background: this.background,
             failureMessage: "Sim CloudFormation Stack update failed",
         });
         await scheduler.sequence();
         this.completePromise = scheduler.schedule({
-            operation: runUpdate,
+            operation: work.apply,
             onSuccess: () => {
                 this.#status = "UPDATE_COMPLETE";
             },
             onFailure: (error) => {
-                this.#status = "UPDATE_FAILED";
+                this.#status = "UPDATE_ROLLBACK_IN_PROGRESS";
                 this.updateError = error;
+                // Scheduled rather than run where the failure was caught, so the Stack
+                // is visibly rolling back while it happens, the way it is visibly
+                // updating while the update happens.
+                this.rollbackPromise = scheduler.schedule({
+                    operation: work.rollBack,
+                    onSuccess: () => {
+                        this.#status = "UPDATE_ROLLBACK_COMPLETE";
+                    },
+                    onFailure: (failure) => {
+                        this.#status = "UPDATE_ROLLBACK_FAILED";
+                        this.rollbackError = failure;
+                    },
+                });
             },
         });
     }
     /**
-     * Wait for the scheduled update to finish.
+     * Wait for the scheduled update to finish, rollback included.
      *
-     * If the update failed, this rethrows the captured error, so a caller can see
-     * what stopped the new template being applied. A Stack that was never updated
-     * has nothing to wait for.
+     * If the update failed, this rethrows the captured error once the Stack has
+     * settled, so a caller can see what stopped the new template being applied.
+     * A Stack that was never updated has nothing to wait for.
      */
     async waitForComplete() {
-        if (this.completePromise !== undefined) {
-            await this.completePromise;
-        }
+        // Awaiting nothing is how a Stack that was never updated, and one that was
+        // never rolled back, wait for the operation they never had.
+        await this.completePromise;
+        await this.rollbackPromise;
         if (this.updateError !== undefined) {
             throw this.updateError;
         }

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-plan.d.ts

@@ -35,6 +35,15 @@ export declare class SimCfnStackUpdatePlan {
     readonly creations: readonly SimCfnResource[];
     readonly updated: ReadonlyMap<string, SimCfnResource>;
     constructor(properties: SimCfnStackUpdatePlanProperties);
+    /**
+     * For each logical ID the update is replacing, whether the definition taking
+     * its place says to keep the deployed Resource.
+     *
+     * The new half answers it because CloudFormation reads UpdateReplacePolicy
+     * off the template it is applying. An update that adds the attribute keeps
+     * the Resource it replaces, and one that drops it deletes that Resource.
+     */
+    replacementRetentions(): ReadonlyMap<string, boolean>;
     /**
      * Whether the update changes any Resource at all.
      *

package/dist/service/cloudformation/stack/update/sim-cfn-stack-update-plan.js

@@ -56,6 +56,20 @@ export class SimCfnStackUpdatePlan {
         })
             .toArray();
     }
+    /**
+     * For each logical ID the update is replacing, whether the definition taking
+     * its place says to keep the deployed Resource.
+     *
+     * The new half answers it because CloudFormation reads UpdateReplacePolicy
+     * off the template it is applying. An update that adds the attribute keeps
+     * the Resource it replaces, and one that drops it deletes that Resource.
+     */
+    replacementRetentions() {
+        return new Map(this.replacements.map(({ current, updated }) => [
+            current.logicalId,
+            updated.retainedOnReplace,
+        ]));
+    }
     /**
      * Whether the update changes any Resource at all.
      *

package/dist/service/cloudformation/stack/update/sim-cfn-stack-updater.js

@@ -2,6 +2,7 @@ import { SimCloudFormationValidationError } from "../../error/sim-cloudformation
 import { makeSimCfnStackResourceMap } from "../resource-map/sim-cfn-stack-resource-map.js";
 import { SimCfnStackUpdatePlan } from "./sim-cfn-stack-update-plan.js";
 import { simCfnStackTemplateChanged } from "./sim-cfn-stack-template-changes.js";
+import { SimCfnResourceRetention } from "../../resource/delete/sim-cfn-resource-retention.js";
 /**
  * What CloudFormation answers an update that would change nothing.
  *
@@ -58,8 +59,12 @@ export class SimCfnStackUpdater {
         const { resources, operations } = this.properties;
         const { plan } = this;
         await operations.assertUpdatesAllowed(resources, plan.updated, plan.replacements);
-        await operations.delete(resources, plan.deletions);
+        await operations.delete(resources, plan.deletions, new SimCfnResourceRetention({ replaced: plan.replacementRetentions() }));
         plan.applyTo(resources);
+        // Once the Stack has stopped holding them, and before the replacements are
+        // created. An update that keeps a Resource and then fails to create the one
+        // taking its place still reports what it kept.
+        operations.recordRetained(plan.deletions.filter((resource) => resource.retained));
         await operations.create(resources, plan.creations);
     }
 }