@kensio/yulin 1.21.3 → 1.21.5

package/dist/service/s3/sim-s3-operations.d.ts

@@ -1,16 +1,17 @@
 import type * as simS3Commands from "./command/sim-s3-command.types.js";
 import type { SimS3RequestOptions } from "./command/sim-s3-request-options.js";
-import { SimS3VersionOperations } from "./sim-s3-version-operations.js";
+import { SimS3TaggingOperations } from "./sim-s3-tagging-operations.js";
 /**
  * The AWS operations simulated S3 answers. One delegation per SDK Command,
  * onto the handler in `SimS3Commands` that runs it.
  *
  * `SimS3` extends this. A caller reaches every operation on the one service
  * object, alongside the simulator-only controls `SimS3` holds itself. The
- * operations that make a Bucket keep what it held are on
- * `SimS3VersionOperations`, which this extends.
+ * operations that tag an Object are on `SimS3TaggingOperations`, and the ones
+ * that make a Bucket keep what it held are on `SimS3VersionOperations` below
+ * it, both of which this extends.
  */
-export declare abstract class SimS3Operations extends SimS3VersionOperations {
+export declare abstract class SimS3Operations extends SimS3TaggingOperations {
     /** Handle a Create Bucket Command from the SDK. */
     createBucket(command: simS3Commands.SimCreateBucketCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimCreateBucketCommandOutput>;
     /** Handle a Head Bucket Command from the SDK. */
@@ -33,6 +34,12 @@ export declare abstract class SimS3Operations extends SimS3VersionOperations {
     getPublicAccessBlock(command: simS3Commands.SimGetPublicAccessBlockCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetPublicAccessBlockCommandOutput>;
     /** Handle a Delete Public Access Block Command from the SDK. */
     deletePublicAccessBlock(command: simS3Commands.SimDeletePublicAccessBlockCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimDeletePublicAccessBlockCommandOutput>;
+    /** Handle a Put Bucket Encryption Command from the SDK. */
+    putBucketEncryption(command: simS3Commands.SimPutBucketEncryptionCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutBucketEncryptionCommandOutput>;
+    /** Handle a Get Bucket Encryption Command from the SDK. */
+    getBucketEncryption(command: simS3Commands.SimGetBucketEncryptionCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetBucketEncryptionCommandOutput>;
+    /** Handle a Delete Bucket Encryption Command from the SDK. */
+    deleteBucketEncryption(command: simS3Commands.SimDeleteBucketEncryptionCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimDeleteBucketEncryptionCommandOutput>;
     /** Handle a Put Bucket Website Command from the SDK. */
     putBucketWebsite(command: simS3Commands.SimPutBucketWebsiteCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutBucketWebsiteCommandOutput>;
     /** Handle a Put Bucket Notification Configuration Command from the SDK. */

package/dist/service/s3/sim-s3-operations.js

@@ -1,14 +1,15 @@
-import { SimS3VersionOperations } from "./sim-s3-version-operations.js";
+import { SimS3TaggingOperations } from "./sim-s3-tagging-operations.js";
 /**
  * The AWS operations simulated S3 answers. One delegation per SDK Command,
  * onto the handler in `SimS3Commands` that runs it.
  *
  * `SimS3` extends this. A caller reaches every operation on the one service
  * object, alongside the simulator-only controls `SimS3` holds itself. The
- * operations that make a Bucket keep what it held are on
- * `SimS3VersionOperations`, which this extends.
+ * operations that tag an Object are on `SimS3TaggingOperations`, and the ones
+ * that make a Bucket keep what it held are on `SimS3VersionOperations` below
+ * it, both of which this extends.
  */
-export class SimS3Operations extends SimS3VersionOperations {
+export class SimS3Operations extends SimS3TaggingOperations {
     /** Handle a Create Bucket Command from the SDK. */
     async createBucket(command, options) {
         return await this.commands.buckets.create(command, options);
@@ -53,6 +54,18 @@ export class SimS3Operations extends SimS3VersionOperations {
     async deletePublicAccessBlock(command, options) {
         return await this.commands.publicAccessBlocks.delete(command, options);
     }
+    /** Handle a Put Bucket Encryption Command from the SDK. */
+    async putBucketEncryption(command, options) {
+        return await this.commands.encryption.put(command, options);
+    }
+    /** Handle a Get Bucket Encryption Command from the SDK. */
+    async getBucketEncryption(command, options) {
+        return await this.commands.encryption.get(command, options);
+    }
+    /** Handle a Delete Bucket Encryption Command from the SDK. */
+    async deleteBucketEncryption(command, options) {
+        return await this.commands.encryption.delete(command, options);
+    }
     /** Handle a Put Bucket Website Command from the SDK. */
     async putBucketWebsite(command, options) {
         return await this.commands.buckets.putWebsite(command, options);

package/dist/service/s3/sim-s3-tagging-operations.d.ts

@@ -0,0 +1,21 @@
+import type * as simS3Commands from "./command/sim-s3-command.types.js";
+import type { SimS3RequestOptions } from "./command/sim-s3-request-options.js";
+import { SimS3VersionOperations } from "./sim-s3-version-operations.js";
+/**
+ * The AWS operations that hold tags against an Object.
+ *
+ * They sit together because real S3 grants each of them a permission of its
+ * own, and none of them is reachable through the read and the write of the
+ * Object they name.
+ *
+ * `SimS3Operations` extends this, and `SimS3` extends that, so a caller reaches
+ * all of them on the one service object.
+ */
+export declare abstract class SimS3TaggingOperations extends SimS3VersionOperations {
+    /** Handle a Put Object Tagging Command from the SDK. */
+    putObjectTagging(command: simS3Commands.SimPutObjectTaggingCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectTaggingCommandOutput>;
+    /** Handle a Get Object Tagging Command from the SDK. */
+    getObjectTagging(command: simS3Commands.SimGetObjectTaggingCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetObjectTaggingCommandOutput>;
+    /** Handle a Delete Object Tagging Command from the SDK. */
+    deleteObjectTagging(command: simS3Commands.SimDeleteObjectTaggingCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimDeleteObjectTaggingCommandOutput>;
+}

package/dist/service/s3/sim-s3-tagging-operations.js

@@ -0,0 +1,25 @@
+import { SimS3VersionOperations } from "./sim-s3-version-operations.js";
+/**
+ * The AWS operations that hold tags against an Object.
+ *
+ * They sit together because real S3 grants each of them a permission of its
+ * own, and none of them is reachable through the read and the write of the
+ * Object they name.
+ *
+ * `SimS3Operations` extends this, and `SimS3` extends that, so a caller reaches
+ * all of them on the one service object.
+ */
+export class SimS3TaggingOperations extends SimS3VersionOperations {
+    /** Handle a Put Object Tagging Command from the SDK. */
+    async putObjectTagging(command, options) {
+        return await this.commands.objectTagging.put(command, options);
+    }
+    /** Handle a Get Object Tagging Command from the SDK. */
+    async getObjectTagging(command, options) {
+        return await this.commands.objectTagging.get(command, options);
+    }
+    /** Handle a Delete Object Tagging Command from the SDK. */
+    async deleteObjectTagging(command, options) {
+        return await this.commands.objectTagging.delete(command, options);
+    }
+}

package/dist/service/s3/sim-s3.d.ts

@@ -5,6 +5,7 @@ import { type SimS3Properties } from "./sim-s3-commands.js";
 import { SimS3Operations } from "./sim-s3-operations.js";
 import type { SimSdkCommandRouter } from "../../sdk/router/sim-sdk-command-router.type.js";
 import type { SimS3NotificationDeliveryFailure } from "./notification/sim-s3-notification-failures.js";
+import type { SimS3ObjectNotifier } from "./notification/sim-s3-object-notifier.js";
 import type { SimS3MountFilesystemOptions } from "./mount/sim-s3-mount.type.js";
 /**
  * Simulated S3. Handles SDK commands. Emulates AWS behaviour and state.
@@ -17,9 +18,25 @@ import type { SimS3MountFilesystemOptions } from "./mount/sim-s3-mount.type.js";
  */
 export declare class SimS3 extends SimS3Operations {
     private readonly bucketAccess;
+    private readonly bucketMaker;
     private readonly cfnFactory;
     private readonly sdkRouter;
     constructor(properties?: SimS3Properties);
+    /**
+     * Make a Bucket in this scope without a `CreateBucketCommand`, and so
+     * without a principal to authorize.
+     *
+     * This is for a Bucket real AWS has provisioned before the code under test
+     * runs, which nothing in the simulation is deploying. The CDK bootstrap
+     * staging Bucket is the one the simulator makes for itself: `cdk deploy`
+     * publishes assets into a Bucket the bootstrap stack created, and a
+     * deployment that had to create it would be charged permissions no real
+     * deployment needs.
+     *
+     * A name this scope cannot take is reported the way `CreateBucketCommand`
+     * reports it.
+     */
+    makeSimBucket(bucketName: SimS3BucketName | string): SimS3Bucket;
     /**
      * Change how many keys one page of an Object listing holds, which real S3
      * fixes at a thousand.
@@ -36,6 +53,17 @@ export declare class SimS3 extends SimS3Operations {
      * real S3 tells the caller who wrote the Object nothing about a delivery.
      */
     getNotificationDeliveryFailures(): readonly SimS3NotificationDeliveryFailure[];
+    /**
+     * Get the notifier this scope's Object commands raise their events through.
+     *
+     * A write that reaches a Bucket without going through an S3 command still
+     * owes the Bucket's destinations an event. A CDK BucketDeployment is one. It
+     * stands in for a provider function that syncs a directory into the Bucket,
+     * and the Bucket notifies whatever it was configured to notify. One notifier
+     * serves the scope, so the events a deployment raises are sequenced against
+     * the commands' own rather than starting a sequence beside them.
+     */
+    objectNotifier(): SimS3ObjectNotifier;
     /**
      * Get the simulated S3 REST API endpoint URL for this Region, which is what
      * an AWS SDK S3 client, and the presigner built on it, is configured with.

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

@@ -1,5 +1,6 @@
 import { SimS3GlobalRegistry } from "./sim-s3-global-registry.js";
 import { SimS3BucketAccess } from "./bucket/sim-s3-bucket-access.js";
+import { SimS3BucketMaker } from "./bucket/sim-s3-bucket-maker.js";
 import { SimS3CloudFormationResourceFactory } from "./cfn/sim-cfn-s3-resource-factory.js";
 import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
 import { SimS3Commands } from "./sim-s3-commands.js";
@@ -16,6 +17,7 @@ import { SimS3SdkCommandRouter } from "./sdk/sim-s3-sdk-command-router.js";
  */
 export class SimS3 extends SimS3Operations {
     bucketAccess;
+    bucketMaker;
     cfnFactory = new SimS3CloudFormationResourceFactory(this);
     sdkRouter = new SimS3SdkCommandRouter(this);
     constructor(properties = {}) {
@@ -32,6 +34,29 @@ export class SimS3 extends SimS3Operations {
             accountRegionScope,
             s3GlobalRegistry,
         });
+        this.bucketMaker = new SimS3BucketMaker({
+            accountRegionScope,
+            buckets,
+            s3GlobalRegistry,
+            background: this.commands.background,
+        });
+    }
+    /**
+     * Make a Bucket in this scope without a `CreateBucketCommand`, and so
+     * without a principal to authorize.
+     *
+     * This is for a Bucket real AWS has provisioned before the code under test
+     * runs, which nothing in the simulation is deploying. The CDK bootstrap
+     * staging Bucket is the one the simulator makes for itself: `cdk deploy`
+     * publishes assets into a Bucket the bootstrap stack created, and a
+     * deployment that had to create it would be charged permissions no real
+     * deployment needs.
+     *
+     * A name this scope cannot take is reported the way `CreateBucketCommand`
+     * reports it.
+     */
+    makeSimBucket(bucketName) {
+        return this.bucketMaker.make(bucketName);
     }
     /**
      * Change how many keys one page of an Object listing holds, which real S3
@@ -55,6 +80,19 @@ export class SimS3 extends SimS3Operations {
     getNotificationDeliveryFailures() {
         return this.commands.objectNotifier.deliveryFailures;
     }
+    /**
+     * Get the notifier this scope's Object commands raise their events through.
+     *
+     * A write that reaches a Bucket without going through an S3 command still
+     * owes the Bucket's destinations an event. A CDK BucketDeployment is one. It
+     * stands in for a provider function that syncs a directory into the Bucket,
+     * and the Bucket notifies whatever it was configured to notify. One notifier
+     * serves the scope, so the events a deployment raises are sequenced against
+     * the commands' own rather than starting a sequence beside them.
+     */
+    objectNotifier() {
+        return this.commands.objectNotifier;
+    }
     /**
      * Get the simulated S3 REST API endpoint URL for this Region, which is what
      * an AWS SDK S3 client, and the presigner built on it, is configured with.

package/dist/service/s3/storage/filesystem/s3-filesystem-deleting-storage.d.ts

@@ -0,0 +1,34 @@
+import { FilesystemS3BucketStorage, type FilesystemS3BucketStorageProperties } from "./s3-filesystem-storage.js";
+interface FilesystemS3MountStorageProperties extends FilesystemS3BucketStorageProperties {
+    /**
+     * Whether the mount asked to be able to delete the files under it.
+     */
+    readonly allowDelete?: boolean | undefined;
+}
+/**
+ * Filesystem-backed storage for a mount that asked to be able to delete.
+ *
+ * A mounted Bucket refuses a delete by default, for the reason
+ * `FilesystemS3BucketStorage.deleteObject` gives. `allowDelete` on the mount
+ * is what puts this in its place, and the Bucket then deletes the way an
+ * in-memory one does.
+ */
+export declare class DeletingFilesystemS3BucketStorage extends FilesystemS3BucketStorage {
+    /**
+     * Remove the file backing a simulated Object.
+     *
+     * The removal is reported, so the Bucket raises the event a removal raises,
+     * and the key goes through the same safety checks a read and a write do. A
+     * delete naming a path or a file type those refuse is refused here too.
+     */
+    deleteObject(key: string): Promise<boolean>;
+}
+/**
+ * The storage a mounted directory gets, deleting only where the mount said so.
+ *
+ * The choice is made once, when the directory is mounted, so a Bucket that may
+ * delete and a Bucket that may not are two different pieces of storage rather
+ * than one holding a flag.
+ */
+export declare function filesystemS3MountStorage(properties: FilesystemS3MountStorageProperties): FilesystemS3BucketStorage;
+export {};

package/dist/service/s3/storage/filesystem/s3-filesystem-deleting-storage.js

@@ -0,0 +1,34 @@
+import { unlinkFilesystemS3File } from "./s3-filesystem-deletion.js";
+import { FilesystemS3BucketStorage, } from "./s3-filesystem-storage.js";
+/**
+ * Filesystem-backed storage for a mount that asked to be able to delete.
+ *
+ * A mounted Bucket refuses a delete by default, for the reason
+ * `FilesystemS3BucketStorage.deleteObject` gives. `allowDelete` on the mount
+ * is what puts this in its place, and the Bucket then deletes the way an
+ * in-memory one does.
+ */
+export class DeletingFilesystemS3BucketStorage extends FilesystemS3BucketStorage {
+    /**
+     * Remove the file backing a simulated Object.
+     *
+     * The removal is reported, so the Bucket raises the event a removal raises,
+     * and the key goes through the same safety checks a read and a write do. A
+     * delete naming a path or a file type those refuse is refused here too.
+     */
+    async deleteObject(key) {
+        return await unlinkFilesystemS3File(this.objectKeys.filePathFor(key));
+    }
+}
+/**
+ * The storage a mounted directory gets, deleting only where the mount said so.
+ *
+ * The choice is made once, when the directory is mounted, so a Bucket that may
+ * delete and a Bucket that may not are two different pieces of storage rather
+ * than one holding a flag.
+ */
+export function filesystemS3MountStorage(properties) {
+    return properties.allowDelete === true
+        ? new DeletingFilesystemS3BucketStorage(properties)
+        : new FilesystemS3BucketStorage(properties);
+}

package/dist/service/s3/storage/filesystem/s3-filesystem-deletion.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Remove one file, reporting whether there was one to remove.
+ *
+ * A key the directory does not hold is what an idempotent S3 delete of a
+ * missing Object looks like, and the Bucket raises no removal event for it.
+ * The directory the file was in stays where it is, since a Bucket has no
+ * directories for an empty one to be.
+ */
+export declare function unlinkFilesystemS3File(filePath: string): Promise<boolean>;

package/dist/service/s3/storage/filesystem/s3-filesystem-deletion.js

@@ -0,0 +1,24 @@
+import { unlink } from "node:fs/promises";
+import { isMissingFilesystemPathError } from "./filesystem-path-exists.js";
+/**
+ * Remove one file, reporting whether there was one to remove.
+ *
+ * A key the directory does not hold is what an idempotent S3 delete of a
+ * missing Object looks like, and the Bucket raises no removal event for it.
+ * The directory the file was in stays where it is, since a Bucket has no
+ * directories for an empty one to be.
+ */
+export async function unlinkFilesystemS3File(filePath) {
+    try {
+        // oxlint-disable-next-line security/detect-non-literal-fs-filename
+        await unlink(filePath);
+    }
+    catch (error) {
+        if (isMissingFilesystemPathError(error)) {
+            return false;
+        }
+        /* v8 ignore next */
+        throw error;
+    }
+    return true;
+}

package/dist/service/s3/storage/filesystem/s3-filesystem-storage.d.ts

@@ -1,7 +1,8 @@
 import type { SimS3BucketStorage } from "../s3-bucket-storage.js";
 import type { SimS3Object } from "../../object/s3-object.js";
+import { FilesystemS3ObjectKeys } from "./s3-filesystem-object-keys.js";
 import { SimS3DeclaredSystemMetadata } from "../../object/s3-declared-system-metadata.js";
-interface FilesystemS3BucketStorageProperties {
+export interface FilesystemS3BucketStorageProperties {
     readonly directoryPath: string;
     readonly allowedDirectoryNames?: readonly string[];
     readonly additionalFileExtensions?: readonly string[];
@@ -21,9 +22,9 @@ interface FilesystemS3BucketStorageProperties {
  * potential safety issues.
  */
 export declare class FilesystemS3BucketStorage implements SimS3BucketStorage {
+    protected readonly objectKeys: FilesystemS3ObjectKeys;
     private readonly directoryPath;
     private readonly safety;
-    private readonly objectKeys;
     private readonly systemMetadata;
     constructor(properties: FilesystemS3BucketStorageProperties);
     /**
@@ -45,8 +46,8 @@ export declare class FilesystemS3BucketStorage implements SimS3BucketStorage {
      * a Bucket at an ordinary directory of the user's, and the safety checks here
      * are local-development tooling rather than a sandbox boundary. Unlinking
      * someone's files because a test called DeleteObject is the wrong default, so
-     * filesystem-backed Buckets are read and written but never emptied.
+     * a mount that wants deletes asks for one with `allowDelete` and gets
+     * `DeletingFilesystemS3BucketStorage` in place of this.
      */
     deleteObject(key: string): Promise<boolean>;
 }
-export {};

package/dist/service/s3/storage/filesystem/s3-filesystem-storage.js

@@ -16,9 +16,9 @@ import { filesystemS3ObjectFile } from "./s3-filesystem-object-file.js";
  * potential safety issues.
  */
 export class FilesystemS3BucketStorage {
+    objectKeys;
     directoryPath;
     safety;
-    objectKeys;
     systemMetadata;
     constructor(properties) {
         this.systemMetadata =
@@ -76,11 +76,13 @@ export class FilesystemS3BucketStorage {
      * a Bucket at an ordinary directory of the user's, and the safety checks here
      * are local-development tooling rather than a sandbox boundary. Unlinking
      * someone's files because a test called DeleteObject is the wrong default, so
-     * filesystem-backed Buckets are read and written but never emptied.
+     * a mount that wants deletes asks for one with `allowDelete` and gets
+     * `DeletingFilesystemS3BucketStorage` in place of this.
      */
     deleteObject(key) {
         return Promise.reject(new SimS3NotImplemented(`Simulated S3 will not delete ${key} from filesystem-backed storage ` +
             `at ${this.directoryPath}, because it would remove a real file. ` +
-            `Use the default in-memory Bucket storage to simulate deletion.`));
+            `Mount the directory with { allowDelete: true } to allow it, or use ` +
+            `the default in-memory Bucket storage to simulate deletion.`));
     }
 }

package/dist/service/s3/upload/sim-s3-completed-upload.js

@@ -1,4 +1,5 @@
-import { SimS3InvalidPart, SimS3InvalidPartOrder, SimS3MalformedXml, } from "../error/sim-s3.error.js";
+import { SimS3MalformedXml } from "../error/sim-s3.error.js";
+import { SimS3InvalidPart, SimS3InvalidPartOrder, } from "../error/sim-s3-upload.error.js";
 import { SimS3Object } from "../object/s3-object.js";
 import { simS3MultipartETag, simS3UnquotedETag, } from "../object/s3-object-etag.js";
 /**
@@ -28,6 +29,9 @@ export function simS3CompletedUploadObject(properties) {
         metadata: upload.metadata,
         lastModified: properties.completedAt,
         etag: simS3MultipartETag(stored.map((part) => part.etag)),
+        storageClass: upload.storageClass,
+        serverSideEncryption: upload.serverSideEncryption,
+        tags: upload.tags,
     });
 }
 /**

package/dist/service/s3/upload/sim-s3-multipart-upload.d.ts

@@ -1,5 +1,8 @@
 import type { Brand } from "../../../util/brand.type.js";
 import type { SimS3ObjectMetadata } from "../object/s3-object.js";
+import { SimS3ObjectTagSet } from "../object/s3-object-tags.js";
+import type { SimS3ServerSideEncryption } from "../object/s3-server-side-encryption.js";
+import { type SimS3StorageClass } from "../object/s3-storage-class.js";
 export type SimS3UploadId = Brand<string, "SimS3UploadId">;
 /**
  * One numbered part of a multipart upload, as S3 holds it between the
@@ -21,6 +24,18 @@ interface SimS3MultipartUploadProperties {
     readonly key: string;
     readonly metadata: SimS3ObjectMetadata;
     readonly initiated: Date;
+    /**
+     * Where and how the completed Object will be stored. Real S3 takes both at
+     * `CreateMultipartUpload`, alongside the metadata, rather than at completion.
+     */
+    readonly storageClass?: SimS3StorageClass;
+    readonly serverSideEncryption?: SimS3ServerSideEncryption | undefined;
+    /**
+     * The tags the completed Object will carry. Real S3 takes these at
+     * `CreateMultipartUpload` too, for the same reason it takes the metadata
+     * there: the request describing the Object arrives before its bytes.
+     */
+    readonly tags?: SimS3ObjectTagSet | undefined;
 }
 /**
  * A simulated S3 multipart upload in progress.
@@ -40,6 +55,9 @@ export declare class SimS3MultipartUpload {
     readonly key: string;
     readonly metadata: SimS3ObjectMetadata;
     readonly initiated: Date;
+    readonly storageClass: SimS3StorageClass;
+    readonly serverSideEncryption: SimS3ServerSideEncryption | undefined;
+    readonly tags: SimS3ObjectTagSet;
     private readonly parts;
     constructor(properties: SimS3MultipartUploadProperties);
     /**

package/dist/service/s3/upload/sim-s3-multipart-upload.js

@@ -1,4 +1,6 @@
 import { createHash } from "node:crypto";
+import { SimS3ObjectTagSet } from "../object/s3-object-tags.js";
+import { simS3DefaultStorageClass, } from "../object/s3-storage-class.js";
 /**
  * One numbered part of a multipart upload, as S3 holds it between the
  * `UploadPart` that stored it and the `CompleteMultipartUpload` that joins it
@@ -37,12 +39,18 @@ export class SimS3MultipartUpload {
     key;
     metadata;
     initiated;
+    storageClass;
+    serverSideEncryption;
+    tags;
     parts = new Map();
     constructor(properties) {
         this.uploadId = properties.uploadId;
         this.key = properties.key;
         this.metadata = properties.metadata;
         this.initiated = new Date(properties.initiated);
+        this.storageClass = properties.storageClass ?? simS3DefaultStorageClass;
+        this.serverSideEncryption = properties.serverSideEncryption;
+        this.tags = properties.tags ?? SimS3ObjectTagSet.empty();
     }
     /**
      * Store a numbered part, replacing whatever was under that number.

package/dist/service/s3/upload/sim-s3-multipart-uploads.d.ts

@@ -1,9 +1,15 @@
 import type { SimS3ObjectMetadata } from "../object/s3-object.js";
+import type { SimS3ObjectTagSet } from "../object/s3-object-tags.js";
+import type { SimS3ServerSideEncryption } from "../object/s3-server-side-encryption.js";
+import type { SimS3StorageClass } from "../object/s3-storage-class.js";
 import { SimS3MultipartUpload, type SimS3UploadId } from "./sim-s3-multipart-upload.js";
 interface SimS3StartUploadProperties {
     readonly key: string;
     readonly metadata: SimS3ObjectMetadata;
     readonly initiated: Date;
+    readonly storageClass?: SimS3StorageClass;
+    readonly serverSideEncryption?: SimS3ServerSideEncryption | undefined;
+    readonly tags?: SimS3ObjectTagSet | undefined;
 }
 /**
  * The multipart uploads one Bucket has in progress.

package/dist/service/s3/upload/sim-s3-multipart-uploads.js

@@ -23,6 +23,11 @@ export class SimS3MultipartUploads {
             key: properties.key,
             metadata: properties.metadata,
             initiated: properties.initiated,
+            ...(properties.storageClass !== undefined && {
+                storageClass: properties.storageClass,
+            }),
+            serverSideEncryption: properties.serverSideEncryption,
+            tags: properties.tags,
         });
         this.uploads.set(upload.uploadId, upload);
         return upload;

package/dist/util/background/background-clock-waits.d.ts

@@ -0,0 +1,52 @@
+/**
+ * How many things one running scheduled task is waiting on the clock for.
+ */
+export interface BackgroundClockWait {
+    count: number;
+}
+/**
+ * Which scheduled tasks are waiting for the clock rather than for the host.
+ *
+ * Completing a simulation waits for the work that can still get somewhere on
+ * its own. A task blocked on an instant the clock has not reached is not that
+ * kind of work: only moving the clock releases it, and whatever moves the
+ * clock is what waits for completion. Left in, it would be waiting for itself.
+ *
+ * A task says so for itself, from wherever inside it the wait happens, so a
+ * scheduler needs no way of telling one kind of work from another. Code
+ * running outside a scheduled task has nothing to say, and changes nothing by
+ * saying it, which is what keeps this invisible to a caller who holds the
+ * promise itself.
+ */
+export declare class BackgroundClockWaits {
+    private readonly storage;
+    private started;
+    /**
+     * Run outstanding work with a record of what it waits on the clock for.
+     */
+    around<T>(wait: BackgroundClockWait, work: () => Promise<T>): Promise<T>;
+    /**
+     * The work in a set that is neither waiting on the clock nor the work asking
+     * about it.
+     */
+    runnable(held: ReadonlyMap<Promise<unknown>, BackgroundClockWait>): Promise<unknown>[];
+    /**
+     * Whether the code running now is already inside outstanding work, and so
+     * already counted.
+     */
+    get inWork(): boolean;
+    /**
+     * Say that the task running now is waiting for simulated time to reach an
+     * instant, and get back the way to say it no longer is.
+     */
+    begin(): () => void;
+    /**
+     * Resolves the next time a task starts waiting on the clock.
+     *
+     * Whoever is waiting for the simulation to complete takes this alongside the
+     * tasks it is waiting for, so a task that parks part way through stops the
+     * wait rather than extending it forever.
+     */
+    get next(): Promise<undefined>;
+    private wake;
+}

package/dist/util/background/background-clock-waits.js

@@ -0,0 +1,76 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * Which scheduled tasks are waiting for the clock rather than for the host.
+ *
+ * Completing a simulation waits for the work that can still get somewhere on
+ * its own. A task blocked on an instant the clock has not reached is not that
+ * kind of work: only moving the clock releases it, and whatever moves the
+ * clock is what waits for completion. Left in, it would be waiting for itself.
+ *
+ * A task says so for itself, from wherever inside it the wait happens, so a
+ * scheduler needs no way of telling one kind of work from another. Code
+ * running outside a scheduled task has nothing to say, and changes nothing by
+ * saying it, which is what keeps this invisible to a caller who holds the
+ * promise itself.
+ */
+export class BackgroundClockWaits {
+    storage = new AsyncLocalStorage();
+    started = Promise.withResolvers();
+    /**
+     * Run outstanding work with a record of what it waits on the clock for.
+     */
+    async around(wait, work) {
+        return await this.storage.run(wait, work);
+    }
+    /**
+     * The work in a set that is neither waiting on the clock nor the work asking
+     * about it.
+     */
+    runnable(held) {
+        const own = this.storage.getStore();
+        return held
+            .entries()
+            .filter(([, wait]) => wait.count === 0 && wait !== own)
+            .map(([promise]) => promise)
+            .toArray();
+    }
+    /**
+     * Whether the code running now is already inside outstanding work, and so
+     * already counted.
+     */
+    get inWork() {
+        return this.storage.getStore() !== undefined;
+    }
+    /**
+     * Say that the task running now is waiting for simulated time to reach an
+     * instant, and get back the way to say it no longer is.
+     */
+    begin() {
+        const wait = this.storage.getStore();
+        if (wait === undefined) {
+            return () => {
+                // Nothing scheduled is waiting, so nothing stops waiting either.
+            };
+        }
+        wait.count += 1;
+        this.wake();
+        return () => {
+            wait.count -= 1;
+        };
+    }
+    /**
+     * Resolves the next time a task starts waiting on the clock.
+     *
+     * Whoever is waiting for the simulation to complete takes this alongside the
+     * tasks it is waiting for, so a task that parks part way through stops the
+     * wait rather than extending it forever.
+     */
+    get next() {
+        return this.started.promise;
+    }
+    wake() {
+        const { resolve } = this.started;
+        this.started = Promise.withResolvers();
+        resolve(undefined);
+    }
+}

package/dist/util/background/background-jitter.js

@@ -1,3 +1,4 @@
+import { setTimeout } from "node:timers";
 /**
  * A short random pause between scheduling a task and running it.
  *