@kensio/yulin 1.21.3 → 1.21.5

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

@@ -3,9 +3,11 @@ import { CreateStackCommandHandler } from "./command/create-stack/create-stack.h
 import { DescribeStacksCommandHandler } from "./command/describe-stacks/describe-stacks.handler.js";
 import { DeleteStackCommandHandler } from "./command/delete-stack/delete-stack.handler.js";
 import { UpdateStackCommandHandler } from "./command/update-stack/update-stack.handler.js";
+import { SimCfnChangeSetCommands } from "./changeset/sim-cfn-change-set-commands.js";
 import { SimCloudFormationTemplateDeployer, } from "./deploy/sim-cfn-template-deployer.js";
 import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
 import { SimCfnExports } from "./export/sim-cfn-exports.js";
+import { SimCfnDeletedStacks } from "./stack/sim-cfn-deleted-stacks.js";
 import { SimCloudFormationSdkCommandRouter } from "./sdk/sim-cloudformation-sdk-command-router.js";
 import { SimCloudFormationAuthorization } from "./authorize/sim-cloudformation-authorization.js";
 import { simIamInRegion } from "../iam/authorize/sim-iam-region-auth-z.js";
@@ -17,10 +19,12 @@ export class SimCloudFormation {
     simAws;
     background;
     stacks = new Map();
+    deletedStacks = new SimCfnDeletedStacks();
     exports = new SimCfnExports();
     templateDeployer;
     sdkRouter = new SimCloudFormationSdkCommandRouter(this);
     authorization;
+    changeSetCommands;
     constructor(properties) {
         const { simAws, accountRegionScope = simAwsAccountRegionScopeFactory.make(), background, } = properties;
         const iam = simIamInRegion(properties.iam, accountRegionScope.regionName);
@@ -31,6 +35,14 @@ export class SimCloudFormation {
             iam,
             accountRegionScope: this.accountRegionScope,
         });
+        this.changeSetCommands = new SimCfnChangeSetCommands({
+            simAws: this.simAws,
+            accountRegionScope: this.accountRegionScope,
+            stacks: this.stacks,
+            background: this.background,
+            authorization: this.authorization,
+            exports: this.exports,
+        });
         this.templateDeployer = new SimCloudFormationTemplateDeployer({
             simAws: this.simAws,
             accountRegionScope: this.accountRegionScope,
@@ -61,36 +73,71 @@ export class SimCloudFormation {
      */
     async describeStacks(command, options) {
         this.authorization.describeStacks(command.input.StackName, options?.caller);
-        const handler = new DescribeStacksCommandHandler({
+        return await new DescribeStacksCommandHandler({
             stacks: this.stacks,
+            deleted: this.deletedStacks,
             background: this.background,
-        });
-        return await handler.handle(command);
+        }).handle(command);
     }
     /**
      * Handle an Update Stack Command from the SDK.
      */
     async updateStack(command, options) {
         this.authorization.updateStack(command.input.StackName, options?.caller);
-        const handler = new UpdateStackCommandHandler({
+        return await new UpdateStackCommandHandler({
             simAws: this.simAws,
             accountRegionScope: this.accountRegionScope,
             stacks: this.stacks,
             background: this.background,
             exports: this.exports,
-        });
-        return await handler.handle(command);
+        }).handle(command);
     }
     /**
      * Handle a Delete Stack Command from the SDK.
      */
     async deleteStack(command, options) {
         this.authorization.deleteStack(command.input.StackName, options?.caller);
-        const handler = new DeleteStackCommandHandler({
+        return await new DeleteStackCommandHandler({
             stacks: this.stacks,
+            deleted: this.deletedStacks,
             background: this.background,
-        });
-        return await handler.handle(command);
+        }).handle(command);
+    }
+    /**
+     * Handle a Create Change Set Command from the SDK.
+     *
+     * The change set commands authorize themselves, unlike the Stack commands
+     * above. Three of them can name a change set by its ARN alone, and only the
+     * change set registry knows which Stack such a request operates on.
+     */
+    async createChangeSet(command, options) {
+        this.authorization.createChangeSet(command.input.StackName, options?.caller);
+        return await this.changeSetCommands.create(command, options?.caller);
+    }
+    /**
+     * Handle a Describe Change Set Command from the SDK.
+     */
+    async describeChangeSet(command, options) {
+        return await this.changeSetCommands.describe(command, options?.caller);
+    }
+    /**
+     * Handle an Execute Change Set Command from the SDK.
+     */
+    async executeChangeSet(command, options) {
+        return await this.changeSetCommands.execute(command, options?.caller);
+    }
+    /**
+     * Handle a Delete Change Set Command from the SDK.
+     */
+    async deleteChangeSet(command, options) {
+        this.authorization.deleteChangeSet(command.input.StackName, options?.caller);
+        return await this.changeSetCommands.delete(command);
+    }
+    /**
+     * Handle a List Change Sets Command from the SDK.
+     */
+    async listChangeSets(command, options) {
+        return await this.changeSetCommands.list(command, options?.caller);
     }
     /**
      * Wait for a simulated CloudFormation Stack deploy operation to complete.

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

@@ -13,6 +13,7 @@ export function makeSimCfnStackResourceMap(properties) {
             background,
             logicalId: resourceTemplate.logicalId,
             stackName: template.stackName,
+            stackId: template.stackId,
             template: resourceTemplate.template,
             parameters: template.parameters,
             resourceLogicalIds,

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

@@ -0,0 +1,20 @@
+import type { SimCfnStack } from "./sim-cfn-stack.js";
+/**
+ * The Stacks that have finished deleting, kept by Stack ID.
+ *
+ * A deleted Stack gives its name back, so the map of live Stacks can no longer
+ * hold it: the next Stack of that name is a different Stack. CloudFormation
+ * still answers `DescribeStacks` for it by its Stack ID, for 90 days, and this
+ * is where the Stack it answers with is kept.
+ *
+ * Nothing expires here. A simulation lasts a test rather than three months, so
+ * a deleted Stack stays readable for as long as the simulated CloudFormation
+ * it was deleted from does.
+ */
+export declare class SimCfnDeletedStacks {
+    private readonly stacks;
+    /** Keep a Stack that has finished deleting, so its ID still describes it. */
+    record(stack: SimCfnStack): void;
+    /** The deleted Stack with this Stack ID, if one was deleted under it. */
+    get(stackId: string): SimCfnStack | undefined;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * The Stacks that have finished deleting, kept by Stack ID.
+ *
+ * A deleted Stack gives its name back, so the map of live Stacks can no longer
+ * hold it: the next Stack of that name is a different Stack. CloudFormation
+ * still answers `DescribeStacks` for it by its Stack ID, for 90 days, and this
+ * is where the Stack it answers with is kept.
+ *
+ * Nothing expires here. A simulation lasts a test rather than three months, so
+ * a deleted Stack stays readable for as long as the simulated CloudFormation
+ * it was deleted from does.
+ */
+export class SimCfnDeletedStacks {
+    stacks = new Map();
+    /** Keep a Stack that has finished deleting, so its ID still describes it. */
+    record(stack) {
+        this.stacks.set(stack.stackId, stack);
+    }
+    /** The deleted Stack with this Stack ID, if one was deleted under it. */
+    get(stackId) {
+        return this.stacks.get(stackId);
+    }
+}

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

@@ -17,6 +17,12 @@ import type { SimCloudFormationStackStatus } from "./sim-cfn-stack.type.js";
 export interface SimCfnDeployedStack {
     /** What the Stack was deployed as. */
     readonly stackName: string;
+    /**
+     * The Stack's unique ID, which is the ARN CloudFormation gave it when it was
+     * created. A Stack deployed again under the same name gets a new one, and a
+     * deleted Stack is described by this rather than by the name it gave back.
+     */
+    readonly stackId: string;
     /** What CloudFormation last did to the Stack. */
     readonly status: SimCloudFormationStackStatus;
     /** What the operation the status reports failed with, where it failed. */

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

@@ -0,0 +1,47 @@
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+import type { SimCdkOutContext } from "../cdk/sim-cdk-out-context.js";
+/**
+ * What an update can replace on a Stack's deploy context. Anything it leaves
+ * out, the Stack goes on using.
+ */
+export interface SimCfnStackUpdateContext {
+    readonly cdkOutContext?: SimCdkOutContext | undefined;
+    readonly caller?: SimAwsCaller | undefined;
+    readonly assetsCaller?: SimAwsCaller | undefined;
+}
+/**
+ * What a Stack is deploying from, and who it is deploying as.
+ *
+ * These three travel together and are the only things an update replaces, so
+ * they are held apart from the rest of a Stack's Resource operations. An
+ * operation reads them here whenever it runs, rather than closing over the
+ * values the deployment started with.
+ */
+export declare class SimCfnStackDeployContext {
+    /** The CDK cloud assembly the Stack's template was synthesized into. */
+    cdkOutContext: SimCdkOutContext | undefined;
+    /** The principal the Stack's Resource work is authorized as. */
+    caller: SimAwsCaller | undefined;
+    /** The principal the Stack's CDK file assets are published as. */
+    assetsCaller: SimAwsCaller | undefined;
+    constructor(properties: SimCfnStackUpdateContext);
+    /**
+     * Take on what an update brings with it, for this and every later operation.
+     *
+     * A synthesis writes the template and the assets manifest beside it together,
+     * so a Stack updated from a re-synthesized template needs the manifest that
+     * came with it. Keeping the one the Stack was deployed from would look up the
+     * asset a replaced Resource names in a manifest written before it existed.
+     *
+     * An update naming a caller runs as that one, and the Stack is torn down as
+     * it afterwards. An update that names none keeps the deployment's caller, so
+     * a Stack updated from a plain template path goes on running as whoever
+     * deployed it.
+     */
+    useUpdate(properties: SimCfnStackUpdateContext): void;
+    /**
+     * The principal file assets are published as, which is the deployment's own
+     * caller unless the deployment named one for publishing.
+     */
+    publishingCaller(): SimAwsCaller | undefined;
+}

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

@@ -0,0 +1,46 @@
+/**
+ * What a Stack is deploying from, and who it is deploying as.
+ *
+ * These three travel together and are the only things an update replaces, so
+ * they are held apart from the rest of a Stack's Resource operations. An
+ * operation reads them here whenever it runs, rather than closing over the
+ * values the deployment started with.
+ */
+export class SimCfnStackDeployContext {
+    /** The CDK cloud assembly the Stack's template was synthesized into. */
+    cdkOutContext;
+    /** The principal the Stack's Resource work is authorized as. */
+    caller;
+    /** The principal the Stack's CDK file assets are published as. */
+    assetsCaller;
+    constructor(properties) {
+        this.cdkOutContext = properties.cdkOutContext;
+        this.caller = properties.caller;
+        this.assetsCaller = properties.assetsCaller;
+    }
+    /**
+     * Take on what an update brings with it, for this and every later operation.
+     *
+     * A synthesis writes the template and the assets manifest beside it together,
+     * so a Stack updated from a re-synthesized template needs the manifest that
+     * came with it. Keeping the one the Stack was deployed from would look up the
+     * asset a replaced Resource names in a manifest written before it existed.
+     *
+     * An update naming a caller runs as that one, and the Stack is torn down as
+     * it afterwards. An update that names none keeps the deployment's caller, so
+     * a Stack updated from a plain template path goes on running as whoever
+     * deployed it.
+     */
+    useUpdate(properties) {
+        this.cdkOutContext = properties.cdkOutContext ?? this.cdkOutContext;
+        this.caller = properties.caller ?? this.caller;
+        this.assetsCaller = properties.assetsCaller ?? this.assetsCaller;
+    }
+    /**
+     * The principal file assets are published as, which is the deployment's own
+     * caller unless the deployment named one for publishing.
+     */
+    publishingCaller() {
+        return this.assetsCaller ?? this.caller;
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { Brand } from "../../../util/brand.type.js";
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+/**
+ * The unique ID CloudFormation gives a Stack when it creates it.
+ *
+ * An ARN rather than a name, and a new one every time a Stack of that name is
+ * created, which is what lets a deleted Stack still be told apart from the one
+ * that took its name.
+ */
+export type SimCfnStackId = Brand<string, "SimCfnStackId">;
+interface SimCfnStackIdProperties {
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly stackName: string;
+}
+/**
+ * Make the Stack ID for a Stack being created.
+ *
+ * The Account and Region are the ones the Stack is being created in, and the
+ * UUID on the end is what makes this Stack a different Stack from the last one
+ * of the same name.
+ */
+export declare function makeSimCfnStackId(properties: SimCfnStackIdProperties): SimCfnStackId;
+/**
+ * Whether a value naming a Stack is a Stack ID rather than a Stack name.
+ *
+ * `DescribeStacks` takes either in `StackName`, so what a caller gave has to be
+ * read before it can be looked up.
+ */
+export declare function isSimCfnStackId(value: string): boolean;
+export {};

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

@@ -0,0 +1,24 @@
+import { randomUUID } from "node:crypto";
+import { parseSimArn } from "../../aws/arn.js";
+/**
+ * Make the Stack ID for a Stack being created.
+ *
+ * The Account and Region are the ones the Stack is being created in, and the
+ * UUID on the end is what makes this Stack a different Stack from the last one
+ * of the same name.
+ */
+export function makeSimCfnStackId(properties) {
+    const { accountRegionScope, stackName } = properties;
+    const { accountId, regionName } = accountRegionScope;
+    return `arn:aws:cloudformation:${regionName}:${accountId}:stack/${stackName}/${randomUUID()}`;
+}
+/**
+ * Whether a value naming a Stack is a Stack ID rather than a Stack name.
+ *
+ * `DescribeStacks` takes either in `StackName`, so what a caller gave has to be
+ * read before it can be looked up.
+ */
+export function isSimCfnStackId(value) {
+    const arn = parseSimArn(value);
+    return arn?.service === "cloudformation" && arn.resourceType === "stack";
+}

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

@@ -4,7 +4,9 @@ import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimCfnBinding } from "../bind/sim-cfn-binding.js";
 import type { SimCdkOutContext } from "../cdk/sim-cdk-out-context.js";
+import { type SimCfnStackUpdateContext } from "./sim-cfn-stack-deploy-context.js";
 import type { SimCfnResource } from "../resource/sim-cfn-resource.js";
+import { SimCfnResourceRetention } from "../resource/delete/sim-cfn-resource-retention.js";
 import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
 import type { SimCfnResourceOrder } from "./deploy/sim-cfn-resource-order.js";
 import { SimCfnStackUpdater } from "./update/sim-cfn-stack-updater.js";
@@ -27,6 +29,11 @@ interface SimCfnStackResourceOperationsProperties {
      * caller leaves each service to decide the request as the Account root.
      */
     readonly caller?: SimAwsCaller | undefined;
+    /**
+     * The principal the Stack's CDK file assets are published as, where that is
+     * somebody other than the caller its Resources are created as.
+     */
+    readonly assetsCaller?: SimAwsCaller | undefined;
     /**
      * The order Resources with no dependency between them are started in.
      */
@@ -51,26 +58,19 @@ export declare class SimCfnStackResourceOperations {
     private readonly stackName;
     private readonly bindings;
     private readonly resourceOrder;
-    private cdkOutContext;
-    private caller;
-    constructor(properties: SimCfnStackResourceOperationsProperties);
+    private readonly context;
     /**
-     * Take on what an update brings with it, for this and every later operation.
-     *
-     * A synthesis writes the template and the assets manifest beside it together,
-     * so a Stack updated from a re-synthesized template needs the manifest that
-     * came with it. Keeping the one the Stack was deployed from would look up the
-     * asset a replaced Resource names in a manifest written before it existed.
+     * Resources an update kept in simulated AWS.
      *
-     * An update naming a caller runs as that one, and the Stack is torn down as
-     * it afterwards. An update that names none keeps the deployment's caller, so
-     * a Stack updated from a plain template path goes on running as whoever
-     * deployed it.
+     * They are held here because the Stack cannot hold them. A replaced Resource
+     * gives its logical ID up to the Resource created in its place as soon as the
+     * update applies. A teardown's retained Resources are still on the Stack, and
+     * are read off it.
      */
-    useUpdate(properties: {
-        readonly cdkOutContext?: SimCdkOutContext | undefined;
-        readonly caller?: SimAwsCaller | undefined;
-    }): void;
+    private readonly retainedByUpdates;
+    constructor(properties: SimCfnStackResourceOperationsProperties);
+    /** Take on what an update brings with it, for every later operation. */
+    useUpdate(properties: SimCfnStackUpdateContext): void;
     /**
      * Create every Resource in the given Stack Resource map.
      */
@@ -79,15 +79,28 @@ export declare class SimCfnStackResourceOperations {
      * Create the given Resources, in dependency order among the whole Stack.
      */
     create(resources: ReadonlyMap<string, SimCfnResource>, creating: readonly SimCfnResource[]): Promise<void>;
+    /** Resources an update kept in simulated AWS. */
+    get retainedResources(): readonly SimCfnResource[];
+    /**
+     * Refuse a teardown that names a Resource the Stack does not have, before
+     * anything is deleted.
+     */
+    assertRetainable(resources: ReadonlyMap<string, SimCfnResource>, retainResources: readonly string[] | undefined): void;
     /**
-     * Delete every Resource in the given Stack Resource map.
+     * Delete every Resource in the given Stack Resource map, apart from any the
+     * teardown named as ones to keep.
      */
-    deleteAll(resources: ReadonlyMap<string, SimCfnResource>): Promise<void>;
+    deleteAll(resources: ReadonlyMap<string, SimCfnResource>, retainResources?: readonly string[]): Promise<void>;
+    /**
+     * Take a record of the Resources an update kept, which the Stack is about to
+     * stop holding.
+     */
+    recordRetained(resources: readonly SimCfnResource[]): void;
     /**
      * Delete the given Resources, in reverse dependency order among the whole
      * Stack.
      */
-    delete(resources: ReadonlyMap<string, SimCfnResource>, deleting: readonly SimCfnResource[]): Promise<void>;
+    delete(resources: ReadonlyMap<string, SimCfnResource>, deleting: readonly SimCfnResource[], retention?: SimCfnResourceRetention): Promise<void>;
     /**
      * Validate every Resource replacement before the update changes the Stack.
      */
@@ -96,6 +109,26 @@ export declare class SimCfnStackResourceOperations {
      * An update of this Stack from a changed template, in the same scope.
      */
     updater(properties: SimCfnStackUpdateProperties): SimCfnStackUpdater;
+    /**
+     * Put this Stack's Resources back on the template it was deployed from, over
+     * whatever a failed update left behind.
+     *
+     * The difference is worked out from the Resources the Stack holds now, not
+     * from either template. A failure part way through is reconciled from where
+     * it stopped. Nothing asserts that there is a change to make. An update that
+     * failed before it touched a Resource has nothing to undo, and that is a
+     * finished rollback.
+     *
+     * A Resource the failed update replaced is created again empty. The deployed
+     * one was deleted to make room for the replacement, and there is nothing left
+     * to put back.
+     */
+    rollBack(properties: SimCfnStackUpdateProperties): Promise<void>;
+    /**
+     * What a teardown of these Resources is to leave behind: the ones it named,
+     * and the ones their own DeletionPolicy keeps.
+     */
+    private teardownRetention;
     private publishAssets;
     private creator;
     private deleter;

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

@@ -1,4 +1,7 @@
+import { SimCfnStackDeployContext, } from "./sim-cfn-stack-deploy-context.js";
 import { SimCdkAssetsPublisher } from "../cdk/assets/sim-cdk-assets-publisher.js";
+import { SimCfnResourceRetention } from "../resource/delete/sim-cfn-resource-retention.js";
+import { simCfnStackRetainedLogicalIds } from "./teardown/sim-cfn-stack-retained-logical-ids.js";
 import { SimCfnStackResourceCreator } from "./deploy/sim-cfn-stack-resource-creator.js";
 import { SimCfnStackResourceDeleter } from "./teardown/sim-cfn-stack-resource-deleter.js";
 import { SimCfnStackUpdater } from "./update/sim-cfn-stack-updater.js";
@@ -22,34 +25,28 @@ export class SimCfnStackResourceOperations {
     stackName;
     bindings;
     resourceOrder;
-    cdkOutContext;
-    caller;
+    context;
+    /**
+     * Resources an update kept in simulated AWS.
+     *
+     * They are held here because the Stack cannot hold them. A replaced Resource
+     * gives its logical ID up to the Resource created in its place as soon as the
+     * update applies. A teardown's retained Resources are still on the Stack, and
+     * are read off it.
+     */
+    retainedByUpdates = [];
     constructor(properties) {
-        const { simAws, accountRegionScope, stackName, cdkOutContext, bindings, caller, resourceOrder, } = properties;
+        const { simAws, accountRegionScope, stackName, bindings, resourceOrder } = properties;
         this.simAws = simAws;
         this.accountRegionScope = accountRegionScope;
         this.stackName = stackName;
-        this.cdkOutContext = cdkOutContext;
         this.bindings = bindings;
-        this.caller = caller;
         this.resourceOrder = resourceOrder;
+        this.context = new SimCfnStackDeployContext(properties);
     }
-    /**
-     * Take on what an update brings with it, for this and every later operation.
-     *
-     * A synthesis writes the template and the assets manifest beside it together,
-     * so a Stack updated from a re-synthesized template needs the manifest that
-     * came with it. Keeping the one the Stack was deployed from would look up the
-     * asset a replaced Resource names in a manifest written before it existed.
-     *
-     * An update naming a caller runs as that one, and the Stack is torn down as
-     * it afterwards. An update that names none keeps the deployment's caller, so
-     * a Stack updated from a plain template path goes on running as whoever
-     * deployed it.
-     */
+    /** Take on what an update brings with it, for every later operation. */
     useUpdate(properties) {
-        this.cdkOutContext = properties.cdkOutContext ?? this.cdkOutContext;
-        this.caller = properties.caller ?? this.caller;
+        this.context.useUpdate(properties);
     }
     /**
      * Create every Resource in the given Stack Resource map.
@@ -65,18 +62,37 @@ export class SimCfnStackResourceOperations {
         await this.publishAssets();
         await this.creator(resources).create(creating);
     }
+    /** Resources an update kept in simulated AWS. */
+    get retainedResources() {
+        return this.retainedByUpdates;
+    }
+    /**
+     * Refuse a teardown that names a Resource the Stack does not have, before
+     * anything is deleted.
+     */
+    assertRetainable(resources, retainResources) {
+        this.teardownRetention(resources, retainResources);
+    }
     /**
-     * Delete every Resource in the given Stack Resource map.
+     * Delete every Resource in the given Stack Resource map, apart from any the
+     * teardown named as ones to keep.
      */
-    async deleteAll(resources) {
-        await this.deleter(resources).deleteAll();
+    async deleteAll(resources, retainResources) {
+        await this.deleter(resources, this.teardownRetention(resources, retainResources)).deleteAll();
+    }
+    /**
+     * Take a record of the Resources an update kept, which the Stack is about to
+     * stop holding.
+     */
+    recordRetained(resources) {
+        this.retainedByUpdates.push(...resources);
     }
     /**
      * Delete the given Resources, in reverse dependency order among the whole
      * Stack.
      */
-    async delete(resources, deleting) {
-        await this.deleter(resources).delete(deleting);
+    async delete(resources, deleting, retention) {
+        await this.deleter(resources, retention).delete(deleting);
     }
     /**
      * Validate every Resource replacement before the update changes the Stack.
@@ -90,7 +106,7 @@ export class SimCfnStackResourceOperations {
                 simAws: this.simAws,
                 currentResources,
                 updatedResources,
-                caller: this.caller,
+                caller: this.context.caller,
             });
         }));
     }
@@ -108,13 +124,43 @@ export class SimCfnStackResourceOperations {
             updated,
         });
     }
+    /**
+     * Put this Stack's Resources back on the template it was deployed from, over
+     * whatever a failed update left behind.
+     *
+     * The difference is worked out from the Resources the Stack holds now, not
+     * from either template. A failure part way through is reconciled from where
+     * it stopped. Nothing asserts that there is a change to make. An update that
+     * failed before it touched a Resource has nothing to undo, and that is a
+     * finished rollback.
+     *
+     * A Resource the failed update replaced is created again empty. The deployed
+     * one was deleted to make room for the replacement, and there is nothing left
+     * to put back.
+     */
+    async rollBack(properties) {
+        await this.updater(properties).apply();
+    }
+    /**
+     * What a teardown of these Resources is to leave behind: the ones it named,
+     * and the ones their own DeletionPolicy keeps.
+     */
+    teardownRetention(resources, retainResources) {
+        return new SimCfnResourceRetention({
+            named: simCfnStackRetainedLogicalIds({
+                stackName: this.stackName,
+                resources,
+                retainResources,
+            }),
+        });
+    }
     async publishAssets() {
         await new SimCdkAssetsPublisher({
             simAws: this.simAws,
             accountRegionScope: this.accountRegionScope,
             stackName: this.stackName,
-            cdkOutContext: this.cdkOutContext,
-            caller: this.caller,
+            cdkOutContext: this.context.cdkOutContext,
+            assetsCaller: this.context.publishingCaller(),
         }).publish();
     }
     creator(resources) {
@@ -122,18 +168,19 @@ export class SimCfnStackResourceOperations {
             simAws: this.simAws,
             resources,
             stackName: this.stackName,
-            cdkOutContext: this.cdkOutContext,
+            cdkOutContext: this.context.cdkOutContext,
             bindings: this.bindings,
-            caller: this.caller,
+            caller: this.context.caller,
             resourceOrder: this.resourceOrder,
         });
     }
-    deleter(resources) {
+    deleter(resources, retention) {
         return new SimCfnStackResourceDeleter({
             simAws: this.simAws,
             resources,
             stackName: this.stackName,
-            caller: this.caller,
+            caller: this.context.caller,
+            retention,
         });
     }
 }