@kensio/yulin 1.20.17 → 1.21.1

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

@@ -0,0 +1,148 @@
+import { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
+import { SimS3BucketObjectLock } from "./lock/sim-s3-bucket-object-lock.js";
+import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-configuration.js";
+import { SimS3NoncurrentSweep } from "./lifecycle/sim-s3-noncurrent-sweep.js";
+import { SimS3LifecycleSweep } from "./lifecycle/sim-s3-lifecycle-sweep.js";
+import { SimS3ObjectDeletion } from "./sim-s3-object-deletion.js";
+import { SimS3BucketVersions } from "./versioning/sim-s3-bucket-versions.js";
+/**
+ * What one simulated S3 Bucket stores, and what time does to it.
+ *
+ * Storage holds the current Object under each key and nothing else. Versions
+ * and multipart uploads sit alongside it because neither is reachable through
+ * a plain read of a key, and lifecycle rules are here because every read is
+ * what applies them. Nothing sweeps a Bucket on a schedule.
+ */
+export class SimS3BucketObjects {
+    versions = new SimS3BucketVersions();
+    objectLock = new SimS3BucketObjectLock();
+    clock;
+    uploads = new SimS3MultipartUploads();
+    storage;
+    lifecycle;
+    constructor(properties) {
+        this.storage = properties.storage;
+        this.lifecycle = properties.lifecycle;
+        this.clock = properties.clock;
+    }
+    /**
+     * Put an Object into storage, answering the version it was given.
+     *
+     * A Bucket that keeps no versions answers with nothing, which is what tells
+     * a caller there is no `VersionId` to report. A version the Bucket did keep
+     * starts under whatever default retention Object Lock puts on it.
+     */
+    async put(object) {
+        await this.storage.putObject(object);
+        return this.objectLock.withDefaultRetention(this.versions.recordPut(object), object.lastModified);
+    }
+    /**
+     * Get an Object from storage.
+     *
+     * An Object a lifecycle rule has expired goes on the way past. Every read of
+     * it then finds the key empty.
+     */
+    async get(key) {
+        return await this.sweep().object(await this.storage.getObject(key));
+    }
+    /**
+     * List the Objects currently under a prefix.
+     */
+    async list(prefix) {
+        return await this.sweep().objects(await this.storage.listObjects(prefix));
+    }
+    /**
+     * Delete a key, answering what that did to the Bucket.
+     *
+     * A versioned Bucket writes a delete marker and keeps the Object behind it.
+     * Real S3 writes the marker whether or not the key held anything, so a
+     * delete of a key that was never written still leaves one.
+     */
+    async delete(key) {
+        if (!this.versions.keepsVersions) {
+            return new SimS3ObjectDeletion({
+                removedObject: await this.storage.deleteObject(key),
+            });
+        }
+        return new SimS3ObjectDeletion({
+            deleteMarker: await this.versions.markDeleted(this.storage, key, this.clock.now()),
+        });
+    }
+    /**
+     * Remove one version permanently, answering the version that went.
+     *
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back. A version Object
+     * Lock is holding never gets that far.
+     */
+    async deleteVersion(key, versionId, bypassGovernance = false) {
+        this.sweptVersions();
+        this.objectLock.assertDeletable(this.versions.find(key, versionId), this.clock.now(), bypassGovernance);
+        return await this.versions.deleteVersion(this.storage, key, versionId);
+    }
+    /**
+     * The versions this Bucket keeps, with whatever the rules have expired gone.
+     *
+     * Every read of the history goes through here, the way every read of an
+     * Object goes through the Object sweep. A noncurrent version and a bare
+     * delete marker are both invisible to storage, so this removes them without
+     * touching it.
+     */
+    sweptVersions() {
+        new SimS3NoncurrentSweep(this.lifecycle, this.clock.now()).sweep(this.versions);
+        return this.versions;
+    }
+    /**
+     * Apply a versioning configuration, giving what is already stored the null
+     * version id where this is the Bucket's first.
+     */
+    async configureVersioning(versioning) {
+        this.versions.configure(versioning, await this.list());
+    }
+    /**
+     * The multipart uploads this Bucket has in progress.
+     *
+     * Kept apart from storage because the parts of an unfinished upload are not
+     * Objects. Nothing that lists or reads a Bucket can see them, and only
+     * completing the upload puts anything under a key.
+     */
+    multipartUploads() {
+        const now = this.clock.now();
+        this.uploads.discardAbandoned((upload) => this.lifecycle.abandons(upload, now));
+        return this.uploads;
+    }
+    /**
+     * Change the storage implementation behind this Bucket.
+     */
+    configureStorage(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Replace this Bucket's lifecycle configuration.
+     *
+     * Real S3 holds one configuration per Bucket rather than a list of them, so
+     * this replaces what was there instead of adding to it.
+     */
+    configureLifecycle(lifecycle) {
+        this.lifecycle = lifecycle;
+    }
+    /**
+     * Get this Bucket's lifecycle configuration.
+     */
+    getLifecycle() {
+        return this.lifecycle;
+    }
+    /**
+     * Remove this Bucket's lifecycle configuration.
+     *
+     * Real S3 DeleteBucketLifecycle is idempotent, so this reports nothing about
+     * whether there were rules to remove.
+     */
+    deleteLifecycle() {
+        this.lifecycle = SimS3LifecycleConfiguration.empty();
+    }
+    /** What this Bucket's rules have expired, as they stand at this moment. */
+    sweep() {
+        return new SimS3LifecycleSweep(this.storage, this.lifecycle, this.clock.now(), this.versions);
+    }
+}

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

@@ -2,6 +2,11 @@ import type { Brand } from "../../../util/brand.type.js";
 import { type SimClock } from "../../../util/clock/sim-clock.js";
 import type { SimS3BucketStorage } from "../storage/s3-bucket-storage.js";
 import type { SimS3Object } from "../object/s3-object.js";
+import type { SimS3ObjectDeletion } from "./sim-s3-object-deletion.js";
+import type { SimS3BucketObjectLock } from "./lock/sim-s3-bucket-object-lock.js";
+import type { SimS3BucketVersioning } from "./versioning/sim-s3-bucket-versioning.js";
+import type { SimS3BucketVersions } from "./versioning/sim-s3-bucket-versions.js";
+import type { SimS3ObjectVersion } from "./versioning/sim-s3-object-version.js";
 import { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
 import { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
 import { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
@@ -9,7 +14,7 @@ import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-config
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimIamPolicyDocument } from "../../iam/policy/sim-iam-policy.js";
 import { SimS3BucketSystemMetadata } from "./sim-s3-bucket-system-metadata.js";
-import { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
+import type { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
 export type SimS3BucketName = Brand<string, "SimS3BucketName">;
 interface SimS3BucketProperties {
     readonly bucketName: SimS3BucketName | string;
@@ -41,47 +46,45 @@ export declare class SimS3Bucket {
     readonly bucketName: SimS3BucketName;
     readonly creationDate: Date;
     private readonly accountRegionScope;
-    private readonly clock;
     private readonly systemMetadata;
-    private readonly multipartUploads;
-    private storage;
+    private readonly objects;
     private website;
     private policy;
     private publicAccessBlock;
     private notifications;
-    private lifecycle;
     constructor(properties: SimS3BucketProperties);
+    /** Put an Object into storage, answering the version it was given, if any. */
+    putObject(object: SimS3Object): Promise<SimS3ObjectVersion | undefined>;
+    /** Get a simulated S3 Object from storage. */
+    getObject(key: string): Promise<SimS3Object | undefined>;
+    /** List simulated S3 Objects from storage. */
+    listObjects(prefix?: string): Promise<SimS3Object[]>;
     /**
-     * Put a simulated S3 Object into storage.
-     */
-    putObject(object: SimS3Object): Promise<void>;
-    /**
-     * Get a simulated S3 Object from storage.
+     * Delete a key, answering what that did to the Bucket.
      *
-     * An Object a lifecycle rule has expired goes on the way past. Every read of
-     * it then finds the key empty.
+     * Real S3 DeleteObject is idempotent, so a key that was not there is not an
+     * error. What happened is still reported, because the event notification a
+     * deletion raises depends on it.
      */
-    getObject(key: string): Promise<SimS3Object | undefined>;
+    deleteObject(key: string): Promise<SimS3ObjectDeletion>;
     /**
-     * List simulated S3 Objects from storage.
+     * Remove one version of a key permanently, answering the version that went.
+     *
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back. Object Lock
+     * refuses the removal of a version it is holding.
      */
-    listObjects(prefix?: string): Promise<SimS3Object[]>;
+    deleteObjectVersion(key: string, versionId: string, bypassGovernance?: boolean): Promise<SimS3ObjectVersion | undefined>;
+    /** The versions this Bucket keeps, and whether it keeps any. */
+    getVersions(): SimS3BucketVersions;
+    /** How this Bucket is locked, and what that does to a write and a delete. */
+    getObjectLock(): SimS3BucketObjectLock;
     /**
-     * Remove a simulated S3 Object from storage.
-     *
-     * Real S3 DeleteObject is idempotent, so a key that was not there is not an
-     * error. Whether there was an Object to remove is still reported, because a
-     * deletion that removed nothing is not an event: real S3 raises
-     * `s3:ObjectRemoved:Delete` when an Object was deleted, not when a deletion
-     * was requested.
+     * Apply a versioning configuration to this Bucket.
      */
-    deleteObject(key: string): Promise<boolean>;
+    configureVersioning(versioning: SimS3BucketVersioning): Promise<void>;
     /**
      * The multipart uploads this Bucket has in progress.
-     *
-     * Kept apart from storage because the parts of an unfinished upload are not
-     * Objects: nothing that lists or reads a Bucket can see them, and only
-     * completing the upload puts anything under a key.
      */
     getMultipartUploads(): SimS3MultipartUploads;
     /**
@@ -172,7 +175,5 @@ export declare class SimS3Bucket {
      * Get the simulated S3 static website URL for this Bucket.
      */
     getWebsiteUrl(): URL;
-    /** What this Bucket's rules have expired, as they stand at this moment. */
-    private sweep;
 }
 export {};

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

@@ -1,15 +1,14 @@
 import { SimRealClock } from "../../../util/clock/sim-clock.js";
 import { MemoryS3BucketStorage } from "../storage/s3-memory-storage.js";
+import { SimS3BucketObjects } from "./sim-s3-bucket-objects.js";
 import { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
 import { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
 import { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
 import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-configuration.js";
-import { SimS3LifecycleSweep } from "./lifecycle/sim-s3-lifecycle-sweep.js";
 import { simS3BucketWebsiteUrl } from "./website/sim-s3-bucket-website-url.js";
 import { validateS3BucketName } from "./validate/validate-s3-bucket-name.js";
 import { simAwsAccountRegionScopeFactory } from "../../aws/sim-aws-account-region-scope.factory.js";
 import { SimS3BucketSystemMetadata } from "./sim-s3-bucket-system-metadata.js";
-import { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
 /**
  * Simulated S3 Bucket.
  */
@@ -17,79 +16,81 @@ export class SimS3Bucket {
     bucketName;
     creationDate;
     accountRegionScope;
-    clock;
     systemMetadata = new SimS3BucketSystemMetadata();
-    multipartUploads = new SimS3MultipartUploads();
-    storage;
+    objects;
     website;
     policy;
     publicAccessBlock;
     notifications;
-    lifecycle;
     constructor(properties) {
         const { bucketName, accountRegionScope = simAwsAccountRegionScopeFactory.make(), storage = new MemoryS3BucketStorage(), website = new SimS3BucketWebsite(), policy, publicAccessBlock = SimS3PublicAccessBlock.blockingAll(), notifications = SimS3NotificationConfiguration.empty(), lifecycle = SimS3LifecycleConfiguration.empty(), clock = new SimRealClock(), creationDate = clock.now(), } = properties;
         validateS3BucketName(bucketName);
         this.bucketName = bucketName;
         this.accountRegionScope = accountRegionScope;
-        this.clock = clock;
-        this.storage = storage;
+        this.objects = new SimS3BucketObjects({ storage, lifecycle, clock });
         this.website = website;
         this.policy = policy;
         this.publicAccessBlock = publicAccessBlock;
         this.notifications = notifications;
-        this.lifecycle = lifecycle;
         this.creationDate = creationDate;
     }
-    /**
-     * Put a simulated S3 Object into storage.
-     */
+    /** Put an Object into storage, answering the version it was given, if any. */
     async putObject(object) {
-        await this.storage.putObject(object);
+        return await this.objects.put(object);
     }
-    /**
-     * Get a simulated S3 Object from storage.
-     *
-     * An Object a lifecycle rule has expired goes on the way past. Every read of
-     * it then finds the key empty.
-     */
+    /** Get a simulated S3 Object from storage. */
     async getObject(key) {
-        return await this.sweep().object(await this.storage.getObject(key));
+        return await this.objects.get(key);
     }
-    /**
-     * List simulated S3 Objects from storage.
-     */
+    /** List simulated S3 Objects from storage. */
     async listObjects(prefix) {
-        return await this.sweep().objects(await this.storage.listObjects(prefix));
+        return await this.objects.list(prefix);
     }
     /**
-     * Remove a simulated S3 Object from storage.
+     * Delete a key, answering what that did to the Bucket.
      *
      * Real S3 DeleteObject is idempotent, so a key that was not there is not an
-     * error. Whether there was an Object to remove is still reported, because a
-     * deletion that removed nothing is not an event: real S3 raises
-     * `s3:ObjectRemoved:Delete` when an Object was deleted, not when a deletion
-     * was requested.
+     * error. What happened is still reported, because the event notification a
+     * deletion raises depends on it.
      */
     async deleteObject(key) {
-        return await this.storage.deleteObject(key);
+        return await this.objects.delete(key);
     }
     /**
-     * The multipart uploads this Bucket has in progress.
+     * Remove one version of a key permanently, answering the version that went.
      *
-     * Kept apart from storage because the parts of an unfinished upload are not
-     * Objects: nothing that lists or reads a Bucket can see them, and only
-     * completing the upload puts anything under a key.
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back. Object Lock
+     * refuses the removal of a version it is holding.
+     */
+    async deleteObjectVersion(key, versionId, bypassGovernance = false) {
+        return await this.objects.deleteVersion(key, versionId, bypassGovernance);
+    }
+    /** The versions this Bucket keeps, and whether it keeps any. */
+    getVersions() {
+        return this.objects.sweptVersions();
+    }
+    /** How this Bucket is locked, and what that does to a write and a delete. */
+    getObjectLock() {
+        return this.objects.objectLock;
+    }
+    /**
+     * Apply a versioning configuration to this Bucket.
+     */
+    async configureVersioning(versioning) {
+        await this.objects.configureVersioning(versioning);
+    }
+    /**
+     * The multipart uploads this Bucket has in progress.
      */
     getMultipartUploads() {
-        const now = this.clock.now();
-        this.multipartUploads.discardAbandoned((upload) => this.lifecycle.abandons(upload, now));
-        return this.multipartUploads;
+        return this.objects.multipartUploads();
     }
     /**
      * Change the storage implementation for this simulated S3 Bucket.
      */
     configureSimStorage(storage) {
-        this.storage = storage;
+        this.objects.configureStorage(storage);
     }
     /**
      * What this Bucket has been told about the Objects under its keys, beyond
@@ -178,13 +179,13 @@ export class SimS3Bucket {
      * this replaces what was there instead of adding to it.
      */
     configureLifecycle(lifecycle) {
-        this.lifecycle = lifecycle;
+        this.objects.configureLifecycle(lifecycle);
     }
     /**
      * Get this Bucket's lifecycle configuration.
      */
     getLifecycle() {
-        return this.lifecycle;
+        return this.objects.getLifecycle();
     }
     /**
      * Remove this Bucket's lifecycle configuration.
@@ -193,7 +194,7 @@ export class SimS3Bucket {
      * whether there were rules to remove.
      */
     deleteLifecycle() {
-        this.lifecycle = SimS3LifecycleConfiguration.empty();
+        this.objects.deleteLifecycle();
     }
     /**
      * Get the simulated AWS account Region scope for this Bucket.
@@ -207,8 +208,4 @@ export class SimS3Bucket {
     getWebsiteUrl() {
         return simS3BucketWebsiteUrl(this.bucketName, this.accountRegionScope, this.website);
     }
-    /** What this Bucket's rules have expired, as they stand at this moment. */
-    sweep() {
-        return new SimS3LifecycleSweep(this.storage, this.lifecycle, this.clock.now());
-    }
 }

package/dist/service/s3/bucket/sim-s3-object-deletion.d.ts

@@ -0,0 +1,30 @@
+import type { SimS3ObjectVersion } from "./versioning/sim-s3-object-version.js";
+interface SimS3ObjectDeletionProperties {
+    readonly removedObject?: boolean;
+    readonly deleteMarker?: SimS3ObjectVersion | undefined;
+}
+/**
+ * What a delete did to a simulated S3 Bucket.
+ *
+ * The two outcomes are separate because the event notification they raise is.
+ * A Bucket without versioning loses the Object and raises
+ * `s3:ObjectRemoved:Delete`. A versioned Bucket keeps the Object and hides it
+ * behind a marker, which is `s3:ObjectRemoved:DeleteMarkerCreated`. A delete
+ * of a key that held nothing raises neither.
+ */
+export declare class SimS3ObjectDeletion {
+    readonly removedObject: boolean;
+    readonly deleteMarker: SimS3ObjectVersion | undefined;
+    constructor(properties?: SimS3ObjectDeletionProperties);
+    /**
+     * What a response says about this delete.
+     *
+     * A versioned Bucket reports the marker it wrote and the id it wrote it
+     * under. A Bucket without versioning reports neither, as real S3 does.
+     */
+    get reported(): {
+        readonly DeleteMarker?: boolean;
+        readonly VersionId?: string;
+    };
+}
+export {};

package/dist/service/s3/bucket/sim-s3-object-deletion.js

@@ -0,0 +1,29 @@
+/**
+ * What a delete did to a simulated S3 Bucket.
+ *
+ * The two outcomes are separate because the event notification they raise is.
+ * A Bucket without versioning loses the Object and raises
+ * `s3:ObjectRemoved:Delete`. A versioned Bucket keeps the Object and hides it
+ * behind a marker, which is `s3:ObjectRemoved:DeleteMarkerCreated`. A delete
+ * of a key that held nothing raises neither.
+ */
+export class SimS3ObjectDeletion {
+    removedObject;
+    deleteMarker;
+    constructor(properties = {}) {
+        this.removedObject = properties.removedObject ?? false;
+        this.deleteMarker = properties.deleteMarker;
+    }
+    /**
+     * What a response says about this delete.
+     *
+     * A versioned Bucket reports the marker it wrote and the id it wrote it
+     * under. A Bucket without versioning reports neither, as real S3 does.
+     */
+    get reported() {
+        if (this.deleteMarker === undefined) {
+            return {};
+        }
+        return { DeleteMarker: true, VersionId: this.deleteMarker.versionId };
+    }
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Structural shape of an S3 VersioningConfiguration.
+ *
+ * Matches the AWS SDK and CloudFormation property shape, so the same object
+ * can come from either.
+ */
+export interface SimS3VersioningConfiguration {
+    readonly Status?: string | undefined;
+    readonly MFADelete?: string | undefined;
+}
+/**
+ * The version id S3 gives an Object written while versioning was off.
+ *
+ * Real S3 reports the literal string `null` for one, and accepts it back as a
+ * `VersionId` on a read or a delete.
+ */
+export declare const simS3NullVersionId = "null";
+/**
+ * Whether one simulated S3 Bucket keeps Object versions.
+ *
+ * There are three states and only two of them are reachable twice. A Bucket
+ * starts unversioned, and a Bucket that has been versioned can be suspended
+ * but never taken back to unversioned. Real S3 has no request that removes the
+ * configuration, which is what makes versioning the one Bucket setting a
+ * template cannot undo.
+ *
+ * Suspended is the state worth being careful about. It stops new versions
+ * being made without discarding the ones already there. An Object put while
+ * suspended takes the null version id and replaces whatever else holds it,
+ * leaving every earlier version readable by its own id.
+ */
+export declare class SimS3BucketVersioning {
+    private readonly state;
+    private constructor();
+    /**
+     * The state a Bucket nobody has configured is in.
+     */
+    static unversioned(): SimS3BucketVersioning;
+    /**
+     * The state a PutBucketVersioning request asks for.
+     */
+    static fromConfiguration(configuration: SimS3VersioningConfiguration): SimS3BucketVersioning;
+    /**
+     * What GetBucketVersioning answers with.
+     *
+     * A Bucket nobody has configured has no status at all, which real S3 reports
+     * as a response carrying neither `Status` nor `MFADelete`.
+     */
+    get status(): "Enabled" | "Suspended" | undefined;
+    /**
+     * Whether a write to this Bucket is given a version id of its own.
+     */
+    get isEnabled(): boolean;
+    /**
+     * Whether this Bucket holds a version history at all.
+     *
+     * A suspended Bucket still holds one. The versions written before the
+     * suspension stay readable, and only new writes stop adding to them.
+     */
+    get keepsVersions(): boolean;
+}

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

@@ -0,0 +1,65 @@
+/**
+ * The version id S3 gives an Object written while versioning was off.
+ *
+ * Real S3 reports the literal string `null` for one, and accepts it back as a
+ * `VersionId` on a read or a delete.
+ */
+export const simS3NullVersionId = "null";
+/**
+ * Whether one simulated S3 Bucket keeps Object versions.
+ *
+ * There are three states and only two of them are reachable twice. A Bucket
+ * starts unversioned, and a Bucket that has been versioned can be suspended
+ * but never taken back to unversioned. Real S3 has no request that removes the
+ * configuration, which is what makes versioning the one Bucket setting a
+ * template cannot undo.
+ *
+ * Suspended is the state worth being careful about. It stops new versions
+ * being made without discarding the ones already there. An Object put while
+ * suspended takes the null version id and replaces whatever else holds it,
+ * leaving every earlier version readable by its own id.
+ */
+export class SimS3BucketVersioning {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    /**
+     * The state a Bucket nobody has configured is in.
+     */
+    static unversioned() {
+        return new SimS3BucketVersioning("Unversioned");
+    }
+    /**
+     * The state a PutBucketVersioning request asks for.
+     */
+    static fromConfiguration(configuration) {
+        return configuration.Status === "Enabled"
+            ? new SimS3BucketVersioning("Enabled")
+            : new SimS3BucketVersioning("Suspended");
+    }
+    /**
+     * What GetBucketVersioning answers with.
+     *
+     * A Bucket nobody has configured has no status at all, which real S3 reports
+     * as a response carrying neither `Status` nor `MFADelete`.
+     */
+    get status() {
+        return this.state === "Unversioned" ? undefined : this.state;
+    }
+    /**
+     * Whether a write to this Bucket is given a version id of its own.
+     */
+    get isEnabled() {
+        return this.state === "Enabled";
+    }
+    /**
+     * Whether this Bucket holds a version history at all.
+     *
+     * A suspended Bucket still holds one. The versions written before the
+     * suspension stay readable, and only new writes stop adding to them.
+     */
+    get keepsVersions() {
+        return this.state !== "Unversioned";
+    }
+}