@stowage/conformance 0.0.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,2220 @@
+import { capabilityNames, isStorageError } from "@stowage/core";
+//#region src/result.ts
+/**
+* What a harness may carry out of a run (ADR 0006). Neither `cause` nor the thrown value
+* itself survives the trip out of a worker, so a result holds neither.
+*/
+function serializeError(thrown) {
+	const serialized = {
+		name: stringFieldOf(thrown, "name") ?? "Error",
+		message: stringFieldOf(thrown, "message") ?? stringOf(thrown)
+	};
+	const stack = stringFieldOf(thrown, "stack");
+	const code = storageErrorCodeOf(thrown);
+	if (stack !== void 0) serialized.stack = stack;
+	if (code !== void 0) serialized.code = code;
+	return serialized;
+}
+function stringFieldOf(value, field) {
+	if (typeof value !== "object" || value === null) return void 0;
+	try {
+		const held = Reflect.get(value, field);
+		return typeof held === "string" ? held : void 0;
+	} catch {
+		return;
+	}
+}
+function stringOf(value) {
+	try {
+		return String(value);
+	} catch {
+		return "Unknown error";
+	}
+}
+function storageErrorCodeOf(value) {
+	try {
+		return isStorageError(value) ? value.code : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/assertions.ts
+/**
+* What a case asserts with. The suite carries its own rather than the `expect` of a test
+* framework, because `runAll` runs the same cases where there is no framework (ADR 0006).
+*/
+function assert(condition, message) {
+	if (!condition) throw new Error(message);
+}
+/** The bytes a case wrote, read back, where a failure names the offset and not the body. */
+function assertSameBytes(actual, expected, what) {
+	assert(actual.byteLength === expected.byteLength, `${what} is ${actual.byteLength} bytes, and not the ${expected.byteLength} that were written`);
+	for (let index = 0; index < expected.byteLength; index += 1) assert(actual[index] === expected[index], `${what} holds ${actual[index]} at byte ${index}, and not the ${expected[index]} that was written`);
+}
+/**
+* A time the provider reported, as spec 4.4 and 4.6 have an object description and a
+* listing entry carry it. A target may be written in JavaScript, where the declared type
+* of a field promises nothing about what the storage hands over.
+*/
+function assertDate(value, what) {
+	assert(value instanceof Date && Number.isFinite(value.getTime()), `${what} is ${JSON.stringify(value)}, which is no \`Date\``);
+}
+/**
+* Two descriptions of one object, on the fields the row of spec 9.5 names. Spec 4.4
+* leaves `lastModified` free to differ between a write and a later read by the
+* provider's rounding, so a row names its fields rather than the whole description.
+*/
+function assertSameDescription(one, other, fields, what) {
+	for (const field of fields) assert(one[field] === other[field], `${what} report \`${field}\` as ${JSON.stringify(one[field])} and ${JSON.stringify(other[field])}`);
+}
+/**
+* A header of the answer a case read, which is how spec 9.5 and 9.6 have the two cases
+* that leave the API — a signed URL and the `Response` of flow 4 — read a content type.
+*/
+function assertHeader(response, name, expected) {
+	const held = response.headers.get(name);
+	assert(held === expected, `The answer reports \`${name}: ${JSON.stringify(held)}\` and not ${JSON.stringify(expected)}`);
+}
+/**
+* The `StorageError` the call is expected to reject with, handed back so that a case can
+* read it for what its row of spec 9.5 states beyond the fields it named here. A case
+* running the same call over a list of keys names the one it is at in `what`.
+*/
+async function expectStorageError(call, expected, what) {
+	const subject = what === void 0 ? "" : ` for ${what}`;
+	const expectation = `Expected a \`StorageError\` with \`code: "${expected.code}"\`${subject}`;
+	const thrown = storageErrorOf(await rejectionOf(call, expectation), expectation);
+	for (const [field, value] of Object.entries(expected)) {
+		const held = Reflect.get(thrown, field);
+		assert(held === value, `${expectation}, and the error carries \`${field}: ${JSON.stringify(held)}\` rather than ${JSON.stringify(value)}`);
+	}
+	return thrown;
+}
+/**
+* The `StorageError` a call rejected with, whatever its code, for a row that states the
+* failure and not the code behind it, and for `errors/shape`, which reads every field
+* spec 4.10 has an error carry off whichever error it provoked.
+*/
+async function expectAnyStorageError(call, what) {
+	const expectation = `Expected a \`StorageError\` for ${what}`;
+	return storageErrorOf(await rejectionOf(call, expectation), expectation);
+}
+/**
+* Spec 4.3 and 4.5 leave two failures to the runtime — the `AbortError` of a signal and
+* the `SyntaxError` of a body that is no JSON — which a caller branching on a
+* `StorageError` has to be able to tell apart from one.
+*/
+async function expectRuntimeError(call, name) {
+	const expectation = `Expected the runtime's \`${name}\``;
+	const thrown = await rejectionOf(call, expectation);
+	const serialized = serializeError(thrown);
+	assert(!isStorageError(thrown), `${expectation}, and the call rejected with a \`StorageError\`: ${serialized.message}`);
+	assert(serialized.name === name, `${expectation}, and the call threw ${serialized.name}: ${serialized.message}`);
+}
+/**
+* Spec 4.9 leaves a call needing a capability the storage does not declare with an
+* `Unsupported` error naming it, and spec 9.2 has most of the `runWithout` halves assert
+* that through this.
+*/
+async function expectUnsupported(call, capability) {
+	const expectation = `Expected \`Unsupported\` naming \`${capability}\``;
+	const thrown = storageErrorOf(await rejectionOf(call, expectation), expectation);
+	if (thrown.code !== "Unsupported" || thrown.capability !== capability) throw new Error(`${expectation}, and the call rejected with \`${thrown.code}\` naming \`${thrown.capability}\``);
+}
+function storageErrorOf(thrown, expectation) {
+	if (isStorageError(thrown)) return thrown;
+	const { name, message } = serializeError(thrown);
+	throw new Error(`${expectation}, and the call threw ${name}: ${message}`);
+}
+async function rejectionOf(call, expectation) {
+	try {
+		await call();
+	} catch (thrown) {
+		return thrown;
+	}
+	throw new Error(`${expectation}, and the call resolved`);
+}
+//#endregion
+//#region src/cases/keys.ts
+const utf8$6 = new TextEncoder();
+/** Spec 9.7 measures a key in UTF-8 bytes, and `adapter-fs` bounds one segment at 255. */
+const segmentLimit = 255;
+/**
+* The characters spec 4.8 refuses anywhere in a key, at both ends of the range it names
+* and the one above it. They are built from their code points rather than written down,
+* because a source file holding a `U+0000` is one no tool reads as text any more.
+*/
+const refusedControlCharacters = [
+	0,
+	31,
+	127
+];
+/**
+* A lone high and a lone low surrogate, which spec 4.8 refuses under every rule: a
+* JavaScript string holds either, and neither is a Unicode character with a UTF-8 form.
+*/
+const refusedLoneSurrogates = [55296, 56320];
+/** The byte length spec 4.8 allows a writable key, which two key lists sit on either side of. */
+const writableKeyLimit = 1024;
+/** The prefix one case writes below, which no other case reads or writes. */
+function prefixFor(ctx, caseName) {
+	return `${ctx.keyPrefix}${caseName}/`;
+}
+function keyFor(ctx, caseName, name = "object") {
+	return `${prefixFor(ctx, caseName)}${name}`;
+}
+/**
+* A key of exactly `bytes` UTF-8 bytes below `prefix`, in segments of at most 255 bytes:
+* the boundary key of spec 9.2 and the over-long key of spec 9.7 are both built here, so
+* that the run's prefix counts toward the length rather than being added to it.
+*/
+function keyOfBytes(prefix, bytes) {
+	const fill = bytes - utf8$6.encode(prefix).length;
+	if (fill < 1) throw new Error(`A key of ${bytes} bytes does not fit below ${JSON.stringify(prefix)}`);
+	const count = Math.ceil((fill + 1) / 256);
+	const characters = fill - (count - 1);
+	return `${prefix}${Array.from({ length: count }, (_, index) => "k".repeat(Math.floor(characters / count) + (index < characters % count ? 1 : 0))).join("/")}`;
+}
+/** The accepted list of spec 9.7, below the prefix of the case that writes it. */
+function acceptedKeys(prefix) {
+	return [
+		...acceptedNames.map((name) => ({
+			label: name,
+			key: `${prefix}${name}`
+		})),
+		{
+			label: "a key of 1024 bytes",
+			key: keyOfBytes(prefix, writableKeyLimit)
+		},
+		{
+			label: "a segment of 255 bytes",
+			key: `${prefix}${"k".repeat(segmentLimit)}`
+		}
+	];
+}
+const acceptedNames = [
+	"a",
+	"hello world.txt",
+	"docs/2026/report.pdf",
+	"a#b",
+	"100%",
+	"q?x=1",
+	"a+b",
+	"it's",
+	"Grüße/日本語/ключ.txt"
+];
+/**
+* The list of spec 9.7 that `put` refuses, below the prefix of the case wherever the
+* prefix leaves the violated rule as it is: a key that is about the start of a key is
+* given as the spec writes it, and every other one goes below the run's prefix, so that
+* a run against a shared bucket asks `exists` about its own key space alone.
+*/
+function refusedWritableKeys(prefix) {
+	return [
+		{
+			label: "the empty string",
+			key: "",
+			existsAnswers: "unasked"
+		},
+		{
+			label: "/a",
+			key: "/a",
+			existsAnswers: "unasked"
+		},
+		{
+			label: "a/",
+			key: `${prefix}a/`,
+			existsAnswers: "false"
+		},
+		{
+			label: "a//b",
+			key: `${prefix}a//b`,
+			existsAnswers: "unasked"
+		},
+		{
+			label: "./a",
+			key: `${prefix}./a`,
+			existsAnswers: "unasked"
+		},
+		{
+			label: "a/../b",
+			key: `${prefix}a/../b`,
+			existsAnswers: "unasked"
+		},
+		{
+			label: "..",
+			key: `${prefix}..`,
+			existsAnswers: "unasked"
+		},
+		{
+			label: "a\\b",
+			key: `${prefix}a\\b`,
+			existsAnswers: "false"
+		},
+		...[...refusedControlCharacters, ...refusedLoneSurrogates].map((code) => {
+			const { label, key } = keyHolding(prefix, code);
+			return {
+				label,
+				key,
+				existsAnswers: "unasked"
+			};
+		}),
+		{
+			label: "a key of 1025 bytes",
+			key: keyOfBytes(prefix, 1025),
+			existsAnswers: "false-or-refusal"
+		}
+	];
+}
+/**
+* The list of spec 9.7 that `get`, `stat` and `exists` refuse, placed as the refused
+* writable list places its keys.
+*/
+function refusedAddressableKeys(prefix) {
+	return [
+		{
+			label: "the empty string",
+			key: ""
+		},
+		{
+			label: "/a",
+			key: "/a"
+		},
+		{
+			label: "a//b",
+			key: `${prefix}a//b`
+		},
+		{
+			label: "./a",
+			key: `${prefix}./a`
+		},
+		{
+			label: "a/../b",
+			key: `${prefix}a/../b`
+		},
+		{
+			label: ".",
+			key: `${prefix}.`
+		},
+		keyHolding(prefix, 0),
+		...refusedLoneSurrogates.map((code) => keyHolding(prefix, code))
+	];
+}
+function keyHolding(prefix, code) {
+	return {
+		label: `a key holding U+${code.toString(16).toUpperCase().padStart(4, "0")}`,
+		key: `${prefix}a${String.fromCharCode(code)}b`
+	};
+}
+//#endregion
+//#region src/cases/objects.ts
+/**
+* What a case writes where it reads the content type back, under a key ending in `.txt`:
+* spec 6 has `adapter-fs` derive the type from the key rather than store the one it was
+* given, so the two have to agree.
+*/
+const textContentType = "text/plain";
+/**
+* How many writes a case keeps in flight. The cases past one thousand objects write more
+* than a provider answers at once: a thousand requests in flight come back as throttling
+* rather than as the objects the case is about.
+*/
+const inFlight = 32;
+/**
+* What the `slow` cases of spec 9.5 write: one past the thousand objects a provider
+* answers a listing with and takes in a delete at the most, so that the case reaches
+* past the one page and the one batch rather than filling them.
+*/
+const pastOneThousand = 1001;
+/** The keys of `count` objects below `prefix`, numbered so that a failure names one. */
+function keysBelow(prefix, count) {
+	const width = String(count - 1).length;
+	return Array.from({ length: count }, (_, index) => `${prefix}${String(index).padStart(width, "0")}`);
+}
+async function putEach(ctx, keys, body) {
+	for (let start = 0; start < keys.length; start += inFlight) {
+		const batch = keys.slice(start, start + inFlight);
+		await Promise.all(batch.map(async (key) => void await ctx.storage.put(key, body)));
+	}
+}
+async function collectEntries(listing) {
+	const entries = [];
+	for await (const entry of listing) entries.push(entry);
+	return entries;
+}
+/**
+* The keys a listing named, against the keys the case wrote. Spec 4.6 promises every
+* object below the prefix once and no order, so the two sides meet as sets.
+*/
+function assertNamesEachOnce(held, expected, what) {
+	const once = new Set(held);
+	assert(once.size === held.length, `${what} names ${held.length} keys, ${once.size} of them distinct`);
+	for (const key of expected) assert(once.has(key), `${what} names no ${JSON.stringify(key)}`);
+	const beyond = [...once].filter((key) => !expected.includes(key));
+	assert(beyond.length === 0, `${what} names ${beyond.map((key) => JSON.stringify(key)).join(", ")} beyond what the case wrote`);
+}
+/** That nothing is left below the prefix, which is how a deletion of many keys is read. */
+async function assertNothingBelow(ctx, prefix) {
+	const left = await collectEntries(ctx.storage.list({ prefix }));
+	assert(left.length === 0, `${left.length} objects are left below ${JSON.stringify(prefix)}, the first of them ${JSON.stringify(left[0]?.key)}`);
+}
+/** A report of spec 4.7 over keys the provider took: the count it covered, and no failure. */
+function assertAccepted(report, requested, what) {
+	assert(report.requested === requested, `${what} reports \`requested: ${report.requested}\` and not ${requested}`);
+	assert(report.failed.length === 0, `${what} reports the failure ${JSON.stringify(report.failed[0]?.message)}`);
+}
+//#endregion
+//#region src/cases/copy.ts
+const utf8$5 = new TextEncoder();
+const copyAndMoveCases = [
+	{
+		name: "copy/round-trip",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "copy/round-trip");
+			const source = await write(ctx, `${prefix}source.txt`, "the body to copy");
+			const to = `${prefix}destination.txt`;
+			assertNames(await ctx.storage.copy(source.key, to), to, "`copy`");
+			await assertHolds(ctx, to, source.body, "The destination");
+			await assertHolds(ctx, source.key, source.body, "The source after the copy");
+		}
+	},
+	{
+		name: "copy/overwrites",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "copy/overwrites");
+			const source = await write(ctx, `${prefix}source.txt`, "the body that replaces");
+			const destination = await write(ctx, `${prefix}destination.txt`, "the body that is replaced");
+			await ctx.storage.copy(source.key, destination.key);
+			await assertHolds(ctx, destination.key, source.body, "The destination that was there");
+			await assertHolds(ctx, source.key, source.body, "The source after the copy");
+		}
+	},
+	{
+		name: "copy/missing-source",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "copy/missing-source");
+			const to = `${prefix}destination.txt`;
+			await expectStorageError(() => ctx.storage.copy(`${prefix}absent.txt`, to), { code: "NotFound" });
+			await assertAbsent(ctx, to, "a copy whose source is not there");
+		}
+	},
+	{
+		name: "copy/onto-itself",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const source = await write(ctx, `${prefixFor(ctx, "copy/onto-itself")}object.txt`, "the body that stays");
+			await expectStorageError(() => ctx.storage.copy(source.key, source.key), {
+				code: "InvalidRequest",
+				attempts: 0
+			});
+			await assertHolds(ctx, source.key, source.body, "The object a copy onto itself refused");
+		}
+	},
+	{
+		name: "copy/invalid-keys",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "copy/invalid-keys");
+			const source = await write(ctx, `${prefix}source.txt`, "the body that stays");
+			const refusedDestination = `${prefix}destination/`;
+			const to = `${prefix}destination.txt`;
+			await expectStorageError(() => ctx.storage.copy(source.key, refusedDestination), { code: "InvalidKey" }, "a destination ending in a slash");
+			await expectStorageError(() => ctx.storage.copy(`${prefix}../source.txt`, to), { code: "InvalidKey" }, "a source holding a `..` segment");
+			await assertHolds(ctx, source.key, source.body, "The source a refused copy left");
+			await assertAbsent(ctx, refusedDestination, "a copy whose destination key was refused");
+			await assertAbsent(ctx, to, "a copy whose source key was refused");
+		}
+	},
+	{
+		name: "copy/user-metadata",
+		requires: ["userMetadata"],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "copy/user-metadata");
+			const from = `${prefix}source.txt`;
+			const to = `${prefix}destination.txt`;
+			await ctx.storage.put(from, "the body to copy", {
+				contentType: textContentType,
+				userMetadata: { WrittenBy: "stowage" }
+			});
+			await ctx.storage.copy(from, to);
+			const described = await ctx.storage.stat(to);
+			assert(new Map(Object.entries(described.userMetadata).map(([name, value]) => [name.toLowerCase(), value])).get("writtenby") === "stowage", `The destination carries the user metadata ${JSON.stringify(described.userMetadata)} and not the source's`);
+		},
+		async runWithout(ctx) {
+			const prefix = prefixFor(ctx, "copy/user-metadata");
+			const from = `${prefix}source.txt`;
+			const to = `${prefix}destination.txt`;
+			await ctx.storage.put(from, "the body to copy", { contentType: textContentType });
+			await ctx.storage.copy(from, to);
+			const described = await ctx.storage.stat(to);
+			assert(Object.keys(described.userMetadata).length === 0, `The destination reports the user metadata ${JSON.stringify(described.userMetadata)} on a storage that holds none`);
+		}
+	},
+	{
+		name: "move/round-trip",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "move/round-trip");
+			const source = await write(ctx, `${prefix}source.txt`, "the body to move");
+			const to = `${prefix}destination.txt`;
+			assertNames(await ctx.storage.move(source.key, to), to, "`move`");
+			await assertHolds(ctx, to, source.body, "The destination");
+			await assertAbsent(ctx, source.key, "a move");
+		}
+	},
+	{
+		name: "move/missing-source",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "move/missing-source");
+			const to = `${prefix}destination.txt`;
+			await expectStorageError(() => ctx.storage.move(`${prefix}absent.txt`, to), {
+				code: "NotFound",
+				operation: "move"
+			});
+			await assertAbsent(ctx, to, "a move whose source is not there");
+		}
+	}
+];
+async function write(ctx, key, text) {
+	await ctx.storage.put(key, text, { contentType: textContentType });
+	return {
+		key,
+		body: utf8$5.encode(text)
+	};
+}
+function assertNames(written, to, what) {
+	assert(written.key === to, `${what} reports the key ${JSON.stringify(written.key)} and not the destination ${JSON.stringify(to)}`);
+}
+async function assertHolds(ctx, key, body, what) {
+	const stored = await ctx.storage.get(key);
+	assert(stored.stat.contentType === textContentType, `${what} reports the content type ${JSON.stringify(stored.stat.contentType)} and not ${JSON.stringify(textContentType)}`);
+	assertSameBytes(await stored.bytes(), body, `The body under ${JSON.stringify(key)}`);
+}
+async function assertAbsent(ctx, key, after) {
+	assert(!await ctx.storage.exists(key), `The object under ${JSON.stringify(key)} is there after ${after}`);
+}
+//#endregion
+//#region src/cases/declaration.ts
+const declarationCases = [{
+	name: "declaration/valid-names",
+	requires: [],
+	cost: "fast",
+	async run(ctx) {
+		const declared = ctx.storage.capabilities;
+		const published = capabilityNames;
+		for (const name of declared) assert(published.includes(name), `\`capabilities\` holds ${JSON.stringify(name)}, which is no capability name`);
+		assert(new Set(declared).size === declared.length, `\`capabilities\` names a capability twice: ${JSON.stringify(declared)}`);
+	}
+}, {
+	name: "declaration/identity",
+	requires: [],
+	cost: "fast",
+	async run(ctx) {
+		assertNonEmptyString(ctx.storage.provider, "provider");
+		assertNonEmptyString(ctx.storage.bucket, "bucket");
+	}
+}];
+function assertNonEmptyString(value, field) {
+	assert(typeof value === "string" && value !== "", `\`${field}\` is ${JSON.stringify(value)}, and not a non-empty string`);
+}
+//#endregion
+//#region src/cases/bytes.ts
+const kibibyte = 1024;
+/** The bytes a body is measured in, where a case names a size spec 9.5 or 9.6 states. */
+const mebibyte = 1024 * kibibyte;
+/** ADR 0016 makes one part the threshold for a stream, so 17 MiB provokes a multipart upload. */
+const multipartSize = 17 * mebibyte;
+/**
+* The bytes a case writes: a pattern it rebuilds rather than holds, so that a body the
+* provider reassembled out of order or lost a part of shows up as a mismatch, which one
+* of the same byte repeated would not. Two patterns of different `seed` differ at every
+* byte, so an object holding parts of both matches neither.
+*/
+function patternOf(size, seed = 0) {
+	const bytes = new Uint8Array(size);
+	for (let index = 0; index < size; index += 1) bytes[index] = (index * 7 + seed) % 251;
+	return bytes;
+}
+/** The same bytes as a stream, which is the body spec 4.2 has an adapter send in parts. */
+function streamOf(bytes, chunkSize, onChunk) {
+	let sent = 0;
+	return new ReadableStream({ pull(controller) {
+		if (sent >= bytes.byteLength) {
+			controller.close();
+			return;
+		}
+		controller.enqueue(bytes.subarray(sent, Math.min(sent + chunkSize, bytes.byteLength)));
+		sent += chunkSize;
+		onChunk?.(Math.min(sent, bytes.byteLength));
+	} });
+}
+/**
+* The bodies of `put/concurrent-writers` as streams that each hold back their end until
+* every one was read to its last byte. An adapter cannot complete an upload before its
+* stream ends, so before either completes, each writer has read every byte and started
+* every full part, whatever the part size, and the pacing names no adapter. Whether a
+* started part was answered yet is the adapter's timing, which no stream can see.
+*/
+function streamsEndingTogether(bodies, chunkSize) {
+	const { promise: everyEndReached, resolve } = Promise.withResolvers();
+	let unended = bodies.length;
+	return bodies.map((bytes) => {
+		let sent = 0;
+		let reachedEnd = false;
+		let canceled = false;
+		const reachEnd = () => {
+			if (reachedEnd) return;
+			reachedEnd = true;
+			unended -= 1;
+			if (unended === 0) resolve();
+		};
+		return new ReadableStream({
+			async pull(controller) {
+				if (sent < bytes.byteLength) {
+					controller.enqueue(bytes.subarray(sent, Math.min(sent + chunkSize, bytes.byteLength)));
+					sent += chunkSize;
+					return;
+				}
+				reachEnd();
+				await everyEndReached;
+				if (!canceled) controller.close();
+			},
+			cancel() {
+				canceled = true;
+				reachEnd();
+			}
+		}, { highWaterMark: 0 });
+	});
+}
+async function collect(stream) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of stream) {
+		chunks.push(chunk);
+		size += chunk.byteLength;
+	}
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}
+/**
+* The stream of `put/abort-during-upload` and of flow 1: it fires the signal once half of
+* the body went out, which is where an upload is interrupted rather than refused.
+*/
+function streamAbortedMidway(bytes, chunkSize, controller) {
+	return streamOf(bytes, chunkSize, (sent) => {
+		if (sent >= bytes.byteLength / 2) controller.abort();
+	});
+}
+//#endregion
+//#region src/cases/delete.ts
+const deleteCases = [
+	{
+		name: "delete/single",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "delete/single");
+			await ctx.storage.put(key, patternOf(16));
+			assertAccepted(await ctx.storage.delete(key), 1, "Deleting one key");
+			assert(!await ctx.storage.exists(key), "`exists` answers true for the key that was deleted");
+		}
+	},
+	{
+		name: "delete/many",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "delete/many");
+			const keys = keysBelow(prefix, 30);
+			await putEach(ctx, keys, patternOf(8));
+			assertAccepted(await ctx.storage.delete(...keys), keys.length, "Deleting 30 keys in one call");
+			await assertNothingBelow(ctx, prefix);
+		}
+	},
+	{
+		name: "delete/absent-key-succeeds",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "delete/absent-key-succeeds", "absent");
+			assertAccepted(await ctx.storage.delete(key), 1, "Deleting an absent key");
+		}
+	},
+	{
+		name: "delete/nothing",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			assertAccepted(await ctx.storage.delete(), 0, "Deleting no key at all");
+		}
+	},
+	{
+		name: "delete/invalid-key-reported",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "delete/invalid-key-reported");
+			const one = `${prefix}one`;
+			const two = `${prefix}two`;
+			const invalid = `${prefix}../object`;
+			await putEach(ctx, [one, two], patternOf(8));
+			const report = await ctx.storage.delete(one, invalid, two);
+			assert(report.requested === 3, `Deleting three keys reports \`requested: ${report.requested}\``);
+			assert(report.failed.length === 1, `The report holds ${report.failed.length} failures for the one invalid key among three`);
+			const failure = report.failed[0];
+			assert(failure?.code === "InvalidKey", `The report holds the failure as \`${failure?.code}\` and not as \`InvalidKey\``);
+			assert(failure.key === invalid, `The failure names the key ${JSON.stringify(failure.key)} and not ${JSON.stringify(invalid)}`);
+			await assertNothingBelow(ctx, prefix);
+		}
+	},
+	{
+		name: "delete/past-one-thousand",
+		requires: [],
+		cost: "slow",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "delete/past-one-thousand");
+			const keys = keysBelow(prefix, pastOneThousand);
+			await putEach(ctx, keys, patternOf(8));
+			assertAccepted(await ctx.storage.delete(...keys), keys.length, `Deleting ${pastOneThousand} keys in one call`);
+			await assertNothingBelow(ctx, prefix);
+		}
+	},
+	{
+		name: "deleteAll/below-prefix",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "deleteAll/below-prefix");
+			const below = `${prefix}below/`;
+			const keys = keysBelow(below, 5);
+			const beside = `${prefix}beside`;
+			await putEach(ctx, [...keys, beside], patternOf(8));
+			assertAccepted(await ctx.storage.deleteAll(below), keys.length, "Deleting below a prefix");
+			await assertNothingBelow(ctx, below);
+			assert(await ctx.storage.exists(beside), "`deleteAll` deleted the object beside the prefix as well");
+		}
+	},
+	{
+		name: "deleteAll/nothing",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "deleteAll/nothing");
+			assertAccepted(await ctx.storage.deleteAll(prefix), 0, "Deleting below an empty prefix");
+		}
+	},
+	{
+		name: "deleteAll/past-one-thousand",
+		requires: [],
+		cost: "slow",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "deleteAll/past-one-thousand");
+			const keys = keysBelow(prefix, pastOneThousand);
+			await putEach(ctx, keys, patternOf(8));
+			assertAccepted(await ctx.storage.deleteAll(prefix), keys.length, `Deleting ${pastOneThousand} objects below a prefix in one call`);
+			await assertNothingBelow(ctx, prefix);
+		}
+	}
+];
+//#endregion
+//#region src/cases/errors.ts
+/**
+* The closed set of spec 4.10, which the core publishes as a type and not as a list the
+* way it publishes `capabilityNames`. A code outside it is one no caller can branch on.
+*/
+const storageErrorCodes = /* @__PURE__ */ new Set([
+	"NotFound",
+	"AccessDenied",
+	"InvalidCredentials",
+	"Expired",
+	"InvalidRequest",
+	"NetworkError",
+	"ProviderError",
+	"InvalidKey",
+	"InvalidOption",
+	"Unsupported"
+]);
+const errorCases = [
+	{
+		name: "errors/shape",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "errors/shape");
+			const key = `${prefix}object`;
+			await ctx.storage.put(key, patternOf(16));
+			for (const failure of provokedFailures(ctx, prefix, key)) assertShape(await expectAnyStorageError(async () => await failure.provoke(), failure.what), ctx.storage, failure);
+		}
+	},
+	{
+		name: "errors/not-a-storage-error",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "errors/not-a-storage-error");
+			const key = `${prefix}object.txt`;
+			await ctx.storage.put(key, "no JSON in here", { contentType: "text/plain" });
+			await expectRuntimeError(() => ctx.storage.put(`${prefix}aborted`, patternOf(16), { signal: AbortSignal.abort() }), "AbortError");
+			await expectRuntimeError(async () => await (await ctx.storage.get(key)).json(), "SyntaxError");
+		}
+	},
+	{
+		name: "errors/bad-credentials",
+		requires: [],
+		cost: "fast",
+		factory: "createStorageWithBadCredentials",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "errors/bad-credentials");
+			const storage = await storageFrom(ctx, "createStorageWithBadCredentials");
+			const refused = await expectStorageError(() => storage.get(`${prefix}object`), {
+				code: "InvalidCredentials",
+				retryable: false
+			});
+			assert(refused.attempts === 1 || refused.attempts === 2, `Expected \`InvalidCredentials\` from \`get\`, and the error carries \`attempts: ${refused.attempts}\` rather than 1 or 2`);
+			await expectAnyStorageError(() => storage.exists(`${prefix}object`), "`exists` under a credential the provider refuses");
+			await expectAnyStorageError(() => storage.list({ prefix }).page(), "`list` under a credential the provider refuses");
+		}
+	},
+	{
+		name: "errors/denied-credentials",
+		requires: [],
+		cost: "fast",
+		factory: "createStorageWithDeniedCredentials",
+		async run(ctx) {
+			const storage = await storageFrom(ctx, "createStorageWithDeniedCredentials");
+			const key = keyFor(ctx, "errors/denied-credentials");
+			await expectStorageError(() => storage.put(key, patternOf(16)), {
+				code: "AccessDenied",
+				retryable: false,
+				attempts: 1
+			});
+		}
+	},
+	{
+		name: "errors/expired-credentials",
+		requires: [],
+		cost: "slow",
+		factory: "createStorageWithExpiredCredentials",
+		async run(ctx) {
+			const storage = await storageFrom(ctx, "createStorageWithExpiredCredentials");
+			const key = keyFor(ctx, "errors/expired-credentials");
+			await expectStorageError(() => storage.get(key), {
+				code: "Expired",
+				attempts: 2
+			});
+		}
+	}
+];
+/**
+* One failure per code the parity core reaches without a capability or a credential of
+* its own, across the operations that report them, which is what `errors/shape` reads.
+*/
+function provokedFailures(ctx, prefix, key) {
+	return [
+		{
+			what: "`get` on a missing key",
+			operation: "get",
+			provoke: async () => await ctx.storage.get(`${prefix}absent`)
+		},
+		{
+			what: "`stat` on a missing key",
+			operation: "stat",
+			provoke: async () => await ctx.storage.stat(`${prefix}absent`)
+		},
+		{
+			what: "`put` under a key holding a `..` segment",
+			operation: "put",
+			provoke: async () => await ctx.storage.put(`${prefix}../object`, patternOf(16))
+		},
+		{
+			what: "`list` with a `pageSize` of 0",
+			operation: "list",
+			provoke: async () => await ctx.storage.list({
+				prefix,
+				pageSize: 0
+			}).page()
+		},
+		{
+			what: "`copy` onto itself",
+			operation: "copy",
+			provoke: async () => await ctx.storage.copy(key, key)
+		}
+	];
+}
+function assertShape(thrown, storage, failure) {
+	const code = thrown.code;
+	assert(storageErrorCodes.has(code), `The error for ${failure.what} carries the code ${JSON.stringify(code)}, which is none of spec 4.10`);
+	assertField(thrown, "operation", failure.operation, failure);
+	assertField(thrown, "bucket", storage.bucket, failure);
+	assertField(thrown, "provider", storage.provider, failure);
+	const retryable = thrown.retryable;
+	const attempts = thrown.attempts;
+	assert(typeof retryable === "boolean", `The error for ${failure.what} reports \`retryable: ${JSON.stringify(retryable)}\`, which is no boolean`);
+	assert(typeof attempts === "number" && Number.isInteger(attempts) && attempts >= 0, `The error for ${failure.what} reports \`attempts: ${JSON.stringify(attempts)}\`, which is no count`);
+}
+function assertField(thrown, field, expected, failure) {
+	const held = thrown[field];
+	assert(held === expected, `The error for ${failure.what} reports \`${field}: ${JSON.stringify(held)}\` and not ${JSON.stringify(expected)}`);
+}
+/** The storage of a credential factory, which spec 9.2 has kept the case out of a run without. */
+async function storageFrom(ctx, factory) {
+	const create = ctx.target[factory];
+	assert(create !== void 0, `The target supplies no \`${factory}\``);
+	return await create.call(ctx.target);
+}
+//#endregion
+//#region src/cases/exists.ts
+const existsCases = [{
+	name: "exists/answers",
+	requires: [],
+	cost: "fast",
+	async run(ctx) {
+		const stored = keyFor(ctx, "exists/answers", "object");
+		const absent = keyFor(ctx, "exists/answers", "absent");
+		const trailingSlash = keyFor(ctx, "exists/answers", "absent/");
+		await ctx.storage.put(stored, patternOf(16));
+		assert(await ctx.storage.exists(stored), "`exists` answers false for a stored key");
+		assert(!await ctx.storage.exists(absent), "`exists` answers true for an absent key");
+		assert(!await ctx.storage.exists(trailingSlash), "`exists` answers true for an absent key ending in a slash");
+	}
+}, {
+	name: "exists/invalid-key",
+	requires: [],
+	cost: "fast",
+	async run(ctx) {
+		const key = `${prefixFor(ctx, "exists/invalid-key")}../object`;
+		await expectStorageError(() => ctx.storage.exists(key), { code: "InvalidKey" });
+	}
+}];
+//#endregion
+//#region src/cases/presign.ts
+const utf8$4 = new TextEncoder();
+/** Past the second `presign/expired-url` signs for, which is what spec 9.5 waits out. */
+const pastTheLifetime = 2e3;
+/** The seconds spec 7.10 allows `expiresIn`, which the two refused values sit outside. */
+const refusedLifetimes = [0, 604801];
+const presignNames = ["presignGet", "presignPut"];
+const presignCases = [
+	{
+		name: "presign/get",
+		requires: ["presignedUrls"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "presign/get", "object.txt");
+			const body = "the body a signed `GET` hands out";
+			await ctx.storage.put(key, body, { contentType: textContentType });
+			const response = await fetch(await presignedGet(ctx, key, { expiresIn: 300 }));
+			assertStatus(response.status, 200, "`fetch` on a signed `GET`");
+			assertHeader(response, "content-type", textContentType);
+			assertSameBytes(new Uint8Array(await response.arrayBuffer()), utf8$4.encode(body), "the body a signed `GET` answered with");
+		},
+		runWithout: assertNeitherMethod
+	},
+	{
+		name: "presign/put",
+		requires: ["presignedUrls"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "presign/put", "object.txt");
+			const body = utf8$4.encode("the body a signed `PUT` takes");
+			const { url, headers } = await presignedPut(ctx, key, {
+				expiresIn: 300,
+				contentType: textContentType,
+				contentLength: body.byteLength
+			});
+			const response = await fetch(url, {
+				method: "PUT",
+				body,
+				headers
+			});
+			assert(response.ok, `\`fetch\` on a signed \`PUT\` answered ${response.status} and not a success`);
+			await response.arrayBuffer();
+			const described = await ctx.storage.stat(key);
+			assert(described.contentType === textContentType, `\`stat\` reports the content type ${JSON.stringify(described.contentType)} for what a signed \`PUT\` wrote`);
+			assert(described.size === body.byteLength, `\`stat\` reports ${described.size} bytes for the ${body.byteLength} a signed \`PUT\` wrote`);
+		},
+		runWithout: assertNeitherMethod
+	},
+	{
+		name: "presign/expires-in-bounds",
+		requires: ["presignedUrls"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "presign/expires-in-bounds", "object.txt");
+			for (const name of presignNames) for (const expiresIn of refusedLifetimes) await expectStorageError(async () => await presignerOf(ctx.storage, name)(key, lifetimeOptions(name, expiresIn)), { code: "InvalidOption" }, `\`${name}\` with an \`expiresIn\` of ${expiresIn}`);
+			assert(!await ctx.storage.exists(key), "A signature the lifetime was refused for wrote the object after all");
+		},
+		runWithout: assertNeitherMethod
+	},
+	{
+		name: "presign/put-rejects-type",
+		requires: ["presignedUrls"],
+		cost: "slow",
+		async run(ctx) {
+			const key = keyFor(ctx, "presign/put-rejects-type", "object.txt");
+			const body = utf8$4.encode("a body of another type than the signature binds");
+			const presigned = await presignedPut(ctx, key, {
+				expiresIn: 300,
+				contentType: textContentType,
+				contentLength: body.byteLength
+			});
+			const headers = new Headers(presigned.headers);
+			headers.set("content-type", "application/json");
+			assertStatus(await statusOf(await fetch(presigned.url, {
+				method: "PUT",
+				body,
+				headers
+			})), 403, "a signed `PUT` carrying another content type");
+		},
+		runWithout: assertNeitherMethod
+	},
+	{
+		name: "presign/put-rejects-length",
+		requires: ["presignedUrls"],
+		cost: "slow",
+		async run(ctx) {
+			const key = keyFor(ctx, "presign/put-rejects-length", "object.txt");
+			const body = utf8$4.encode("a body longer than the signature binds");
+			const { url, headers } = await presignedPut(ctx, key, {
+				expiresIn: 300,
+				contentType: textContentType,
+				contentLength: body.byteLength - 1
+			});
+			const status = await statusOf(await fetch(url, {
+				method: "PUT",
+				body,
+				headers
+			}));
+			assert(status >= 400 && status < 500, `A signed \`PUT\` carrying another length was answered ${status} and not refused`);
+		},
+		runWithout: assertNeitherMethod
+	},
+	{
+		name: "presign/expired-url",
+		requires: ["presignedUrls"],
+		cost: "slow",
+		async run(ctx) {
+			const key = keyFor(ctx, "presign/expired-url", "object.txt");
+			await ctx.storage.put(key, "the body the URL stops handing out", { contentType: textContentType });
+			const url = await presignedGet(ctx, key, { expiresIn: 1 });
+			await delay(pastTheLifetime);
+			assertStatus(await statusOf(await fetch(url)), 403, "a signed `GET` that has expired");
+		},
+		runWithout: assertNeitherMethod
+	}
+];
+/**
+* What every `runWithout` half of this file asserts: spec 4.9 keeps both methods off a
+* storage that declares no `presignedUrls`, so there is no call that could fail with
+* `Unsupported` and the absence itself is what the half reads.
+*/
+async function assertNeitherMethod(ctx) {
+	for (const name of presignNames) assert(!(name in ctx.storage), `The storage declares no \`presignedUrls\` and carries \`${name}\``);
+}
+/** The URL `presignGet` handed back, which a target may report as anything at runtime. */
+async function presignedGet(ctx, key, options) {
+	const url = await presignerOf(ctx.storage, "presignGet")(key, options);
+	assert(isUrl(url), `\`presignGet\` handed back ${JSON.stringify(url)} and not a URL`);
+	return url;
+}
+/**
+* What `presignPut` handed back, which a target may report as anything at runtime. The
+* upload sends its headers as they are, so the suite names no provider (spec 4.13).
+*/
+async function presignedPut(ctx, key, options) {
+	const presigned = await presignerOf(ctx.storage, "presignPut")(key, options);
+	assert(isPresignedPut(presigned), `\`presignPut\` handed back ${JSON.stringify(presigned)} and not a URL with the headers that go beside the body`);
+	return presigned;
+}
+function isUrl(value) {
+	return typeof value === "string" && value !== "";
+}
+/** The shape spec 4.13 gives `PresignedPut`, its rule on `Content-Length` included. */
+function isPresignedPut(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const url = Reflect.get(value, "url");
+	const headers = Reflect.get(value, "headers");
+	if (!isUrl(url) || !isPlainObject(headers)) return false;
+	return Object.entries(headers).every(([name, field]) => typeof field === "string" && name.toLowerCase() !== "content-length");
+}
+/**
+* An array or a `Headers` would pass the entries check above: the one lists its indices,
+* the other lists nothing at all.
+*/
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function presignerOf(storage, name) {
+	const held = Reflect.get(storage, name);
+	assert(typeof held === "function", `The storage declares \`presignedUrls\` and carries no \`${name}\``);
+	return held.bind(storage);
+}
+/** The options each method takes beside the lifetime the case is about (spec 7.10). */
+function lifetimeOptions(name, expiresIn) {
+	if (name === "presignGet") return { expiresIn };
+	return {
+		expiresIn,
+		contentType: textContentType,
+		contentLength: 0
+	};
+}
+function assertStatus(status, expected, what) {
+	assert(status === expected, `${what} was answered ${status} and not ${expected}`);
+}
+/** The status, with the body read, so that the runtime is free to close the connection. */
+async function statusOf(response) {
+	await response.arrayBuffer();
+	return response.status;
+}
+async function delay(milliseconds) {
+	await new Promise((resolve) => void setTimeout(resolve, milliseconds));
+}
+//#endregion
+//#region src/cases/flow.ts
+const utf8$3 = new TextEncoder();
+/** Small enough to read whole in an assertion, and long enough to hold a range within it. */
+const rangedSize$1 = 1024;
+/** The page size of the row, which spec 4.6 bounds the objects of one page with. */
+const pageSize = 5;
+/** The tree of flow 3: seven objects, three of them one level below the listed one. */
+const fileBrowserTree = [
+	"images/logo.txt",
+	"notes/monday.txt",
+	"reports/2026.txt",
+	"index.txt",
+	"readme.txt",
+	"settings.txt",
+	"wireframe.txt"
+];
+/** The objects flow 5 moves, below the source prefix it walks. */
+const movedObjects = [
+	"one.txt",
+	"notes/two.txt",
+	"notes/deep/three.txt"
+];
+const flowCases = [
+	{
+		name: "flow/1-large-upload",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "flow/1-large-upload");
+			const key = `${prefix}upload.txt`;
+			const bytes = patternOf(multipartSize);
+			await ctx.storage.put(key, streamOf(bytes, mebibyte), { contentType: textContentType });
+			const described = await ctx.storage.stat(key);
+			assert(described.contentType === textContentType, `\`stat\` reports the content type ${JSON.stringify(described.contentType)} for the upload`);
+			assertSameBytes(await collect((await ctx.storage.get(key)).stream()), bytes, "the body the upload left behind");
+			const aborted = `${prefix}aborted.txt`;
+			const controller = new AbortController();
+			await expectRuntimeError(() => ctx.storage.put(aborted, streamAbortedMidway(bytes, mebibyte, controller), {
+				contentType: textContentType,
+				signal: controller.signal
+			}), "AbortError");
+			assert(!await ctx.storage.exists(aborted), "The key of an aborted upload holds an object");
+		}
+	},
+	{
+		name: "flow/2-presigned-put",
+		requires: ["presignedUrls"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "flow/2-presigned-put", "upload.txt");
+			const body = utf8$3.encode("the body a browser uploads to the provider");
+			const { url, headers } = await presignedPut(ctx, key, {
+				expiresIn: 300,
+				contentType: textContentType,
+				contentLength: body.byteLength
+			});
+			const response = await fetch(url, {
+				method: "PUT",
+				body,
+				headers
+			});
+			assert(response.ok, `The upload to the presigned URL was answered ${response.status}`);
+			await response.arrayBuffer();
+			const described = await ctx.storage.stat(key);
+			assert(described.contentType === textContentType, `\`stat\` reports the content type ${JSON.stringify(described.contentType)} for the upload`);
+			assert(described.size === body.byteLength, `\`stat\` reports ${described.size} bytes for the ${body.byteLength} that were uploaded`);
+		},
+		runWithout: assertNeitherMethod
+	},
+	{
+		name: "flow/3-file-browser",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "flow/3-file-browser");
+			await Promise.all(fileBrowserTree.map(async (name) => await ctx.storage.put(`${prefix}${name}`, name)));
+			const page = await ctx.storage.list({
+				prefix,
+				delimiter: "/",
+				pageSize
+			}).page();
+			assertPageSize(page.objects.length, "The first page");
+			assert(page.cursor !== void 0, `The first page of ${fileBrowserTree.length} entries carries no cursor`);
+			const rest = await ctx.storage.list({
+				prefix,
+				delimiter: "/",
+				pageSize,
+				cursor: page.cursor
+			}).page();
+			assertPageSize(rest.objects.length, "The page the cursor continued with");
+			assert(rest.cursor === void 0, "The second page of the level carries a cursor");
+			assertNamesEachOnce([...page.objects, ...rest.objects].map((entry) => entry.key), levelOf(prefix), "The two pages of the level");
+			assertNamesEachOnce([...page.prefixes, ...rest.prefixes], pseudoDirectoriesOf(prefix), "The pseudo-directories of the level");
+		}
+	},
+	{
+		name: "flow/4-streaming-download",
+		requires: ["rangeReads"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "flow/4-streaming-download", "object.txt");
+			const bytes = patternOf(rangedSize$1);
+			await ctx.storage.put(key, bytes, { contentType: textContentType });
+			const stored = await ctx.storage.get(key, { range: {
+				start: 100,
+				end: 199
+			} });
+			const answer = answerWith(stored.stream(), stored.stat.contentType);
+			assertHeader(answer, "content-type", textContentType);
+			assertSameBytes(new Uint8Array(await answer.arrayBuffer()), bytes.subarray(100, 200), "the range the answer carried");
+		},
+		async runWithout(ctx) {
+			const key = keyFor(ctx, "flow/4-streaming-download", "object.txt");
+			const bytes = patternOf(rangedSize$1);
+			await ctx.storage.put(key, bytes, { contentType: textContentType });
+			const stored = await ctx.storage.get(key);
+			const answer = answerWith(stored.stream(), stored.stat.contentType);
+			assertHeader(answer, "content-type", textContentType);
+			assertSameBytes(new Uint8Array(await answer.arrayBuffer()), bytes, "the object the answer carried whole");
+			await expectUnsupported(() => ctx.storage.get(key, { range: {
+				start: 100,
+				end: 199
+			} }), "rangeReads");
+		}
+	},
+	{
+		name: "flow/5-prefix-move",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "flow/5-prefix-move");
+			const from = `${prefix}source/`;
+			const to = `${prefix}target/`;
+			await Promise.all(movedObjects.map(async (name) => await ctx.storage.put(`${from}${name}`, name, { contentType: textContentType })));
+			const moved = await collectEntries(ctx.storage.list({ prefix: from }));
+			for (const entry of moved) {
+				const stored = await ctx.storage.get(entry.key);
+				await ctx.storage.put(`${to}${entry.key.slice(from.length)}`, stored.stream(), { contentType: stored.stat.contentType });
+			}
+			const report = await ctx.storage.deleteAll(from);
+			assert(report.requested === movedObjects.length, `\`deleteAll\` reports ${report.requested} of the ${movedObjects.length} objects that moved`);
+			assert(report.failed.length === 0, `\`deleteAll\` reports ${report.failed.length} objects it could not delete`);
+			const listed = await collectEntries(ctx.storage.list({ prefix: to }));
+			assertNamesEachOnce(listed.map((entry) => entry.key), movedObjects.map((name) => `${to}${name}`), "The listing below the target prefix");
+			await assertSameBodies(ctx, listed, to);
+		}
+	}
+];
+/** The objects of the listed level, which are the keys of the tree holding no delimiter. */
+function levelOf(prefix) {
+	return fileBrowserTree.filter((name) => !name.includes("/")).map((name) => `${prefix}${name}`);
+}
+function pseudoDirectoriesOf(prefix) {
+	const directories = fileBrowserTree.filter((name) => name.includes("/")).map((name) => `${prefix}${name.slice(0, name.indexOf("/") + 1)}`);
+	return [...new Set(directories)];
+}
+/** Spec 4.6: a page holds at most `pageSize` objects, whatever the delimiter adds to it. */
+function assertPageSize(held, what) {
+	assert(held <= pageSize, `${what} holds ${held} objects, past the ${pageSize} it asked for`);
+}
+/** The answer flow 4 builds out of the stored object, which nothing reads in between. */
+function answerWith(body, type) {
+	return new Response(body, { headers: { "content-type": type } });
+}
+/** That every object arrived below the target prefix as it was written, name for name. */
+async function assertSameBodies(ctx, listed, to) {
+	await Promise.all(listed.map(async (entry) => {
+		const stored = await ctx.storage.get(entry.key);
+		assert(stored.stat.contentType === textContentType, `The moved object under ${JSON.stringify(entry.key)} reports the content type ${JSON.stringify(stored.stat.contentType)}`);
+		assertSameBytes(await stored.bytes(), utf8$3.encode(entry.key.slice(to.length)), `The moved object under ${JSON.stringify(entry.key)}`);
+	}));
+}
+//#endregion
+//#region src/cases/get.ts
+/** Small enough to read whole in an assertion, and long enough to hold a range within it. */
+const rangedSize = 1024;
+const getCases = [
+	{
+		name: "get/missing-key",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/missing-key", "absent");
+			await expectStorageError(() => ctx.storage.get(key), {
+				code: "NotFound",
+				key,
+				operation: "get",
+				retryable: false,
+				attempts: 1
+			});
+		}
+	},
+	{
+		name: "get/stream",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/stream");
+			const bytes = patternOf(4096);
+			await ctx.storage.put(key, bytes);
+			assertSameBytes(await collect((await ctx.storage.get(key)).stream()), bytes, "the body `stream()` yielded");
+			await (await ctx.storage.get(key)).stream().cancel();
+		}
+	},
+	{
+		name: "get/text-and-json",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/text-and-json", "object.json");
+			const other = keyFor(ctx, "get/text-and-json", "object.txt");
+			const text = "{\"grüße\":\"日本語\"}";
+			await ctx.storage.put(key, text, { contentType: "application/json" });
+			await ctx.storage.put(other, "no JSON in here", { contentType: "text/plain" });
+			const read = await (await ctx.storage.get(key)).text();
+			assert(read === text, `\`text()\` decoded ${JSON.stringify(read)}`);
+			const parsed = await (await ctx.storage.get(key)).json();
+			assert(parsed["grüße"] === "日本語", `\`json()\` parsed ${JSON.stringify(parsed)}`);
+			await expectRuntimeError(async () => await (await ctx.storage.get(other)).json(), "SyntaxError");
+		}
+	},
+	{
+		name: "get/body-read-once",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/body-read-once");
+			await ctx.storage.put(key, patternOf(32));
+			const stored = await ctx.storage.get(key);
+			await stored.bytes();
+			await expectStorageError(() => stored.text(), { code: "InvalidRequest" });
+		}
+	},
+	{
+		name: "get/stat-from-response",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/stat-from-response", "object.txt");
+			await ctx.storage.put(key, "a body to describe", { contentType: "text/plain" });
+			const stored = await ctx.storage.get(key);
+			const described = await ctx.storage.stat(key);
+			assertSameDescription(stored.stat, described, [
+				"key",
+				"size",
+				"contentType",
+				"etag"
+			], "`get` and `stat`");
+		}
+	},
+	{
+		name: "get/addressable-keys",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "get/addressable-keys");
+			const absent = [{
+				label: "a key ending in a slash",
+				key: `${prefix}absent/`
+			}, {
+				label: "a key holding a backslash",
+				key: `${prefix}absent\\key`
+			}];
+			await Promise.all(absent.map(async ({ label, key }) => await expectStorageError(() => ctx.storage.get(key), { code: "NotFound" }, label)));
+		}
+	},
+	{
+		name: "get/refused-keys",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const refused = refusedAddressableKeys(prefixFor(ctx, "get/refused-keys"));
+			const reads = [
+				["get", (key) => ctx.storage.get(key)],
+				["stat", (key) => ctx.storage.stat(key)],
+				["exists", (key) => ctx.storage.exists(key)]
+			];
+			await Promise.all(refused.flatMap(({ label, key }) => reads.map(async ([operation, read]) => await expectStorageError(() => read(key), {
+				code: "InvalidKey",
+				attempts: 0
+			}, `\`${operation}\` of ${label}`))));
+		}
+	},
+	{
+		name: "get/aborted-signal",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/aborted-signal");
+			await ctx.storage.put(key, patternOf(16));
+			await expectRuntimeError(() => ctx.storage.get(key, { signal: AbortSignal.abort() }), "AbortError");
+		}
+	},
+	{
+		name: "get/range",
+		requires: ["rangeReads"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/range");
+			const bytes = patternOf(rangedSize);
+			await ctx.storage.put(key, bytes);
+			const middle = await ctx.storage.get(key, { range: {
+				start: 100,
+				end: 199
+			} });
+			assertWholeSize(middle.stat);
+			assertSameBytes(await middle.bytes(), bytes.subarray(100, 200), "the bytes of a range");
+			const tail = await ctx.storage.get(key, { range: { start: 1e3 } });
+			assertWholeSize(tail.stat);
+			assertSameBytes(await tail.bytes(), bytes.subarray(1e3), "the bytes of a range without an end");
+		},
+		async runWithout(ctx) {
+			await refuseRanges(ctx, "get/range", [{
+				start: 0,
+				end: 15
+			}]);
+		}
+	},
+	{
+		name: "get/range-unsatisfiable",
+		requires: ["rangeReads"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/range-unsatisfiable");
+			await ctx.storage.put(key, patternOf(rangedSize));
+			await expectStorageError(() => ctx.storage.get(key, { range: { start: rangedSize } }), { code: "InvalidRequest" }, "a range starting at the size of the object");
+			await expectStorageError(() => ctx.storage.get(key, { range: {
+				start: 8,
+				end: 4
+			} }), { code: "InvalidOption" }, "a range whose start is above its end");
+		},
+		async runWithout(ctx) {
+			await refuseRanges(ctx, "get/range-unsatisfiable", [{ start: rangedSize }, {
+				start: 8,
+				end: 4
+			}]);
+		}
+	},
+	{
+		name: "get/range-clipped",
+		requires: ["rangeReads"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "get/range-clipped");
+			const bytes = patternOf(rangedSize);
+			await ctx.storage.put(key, bytes);
+			assertSameBytes(await (await ctx.storage.get(key, { range: {
+				start: 1016,
+				end: 4 * rangedSize
+			} })).bytes(), bytes.subarray(1016), "the bytes of a range reaching beyond the object");
+		},
+		async runWithout(ctx) {
+			await refuseRanges(ctx, "get/range-clipped", [{
+				start: 1016,
+				end: 4 * rangedSize
+			}]);
+		}
+	}
+];
+function assertWholeSize(described) {
+	assert(described.size === rangedSize, `A ranged \`get\` reports ${described.size} bytes for an object of ${rangedSize}`);
+}
+async function refuseRanges(ctx, caseName, ranges) {
+	const key = keyFor(ctx, caseName);
+	await ctx.storage.put(key, patternOf(rangedSize));
+	await Promise.all(ranges.map(async (range) => await expectUnsupported(() => ctx.storage.get(key, { range }), "rangeReads")));
+}
+//#endregion
+//#region src/cases/list.ts
+const utf8$2 = new TextEncoder();
+/** The page size spec 4.6 bounds a page at, which two page sizes sit on either side of. */
+const pageSizeLimit = 1e3;
+/**
+* One name in the two Unicode normal forms spec 4.8 leaves as two keys or as one. The
+* forms are built from their code points rather than written down, because two source
+* strings that differ in nothing a reader sees are two a tool folds into one.
+*/
+const normalForms = [{
+	form: "NFC",
+	name: `caf${String.fromCodePoint(233)}`
+}, {
+	form: "NFD",
+	name: `cafe${String.fromCodePoint(769)}`
+}];
+const listCases = [
+	{
+		name: "list/nothing",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/nothing");
+			const iterated = await collectEntries(ctx.storage.list({ prefix }));
+			assert(iterated.length === 0, `A listing below a prefix holding nothing yields ${iterated.length} entries`);
+			const page = await ctx.storage.list({ prefix }).page();
+			assert(page.objects.length === 0, `A page below a prefix holding nothing holds ${page.objects.length} objects`);
+			assert(page.prefixes.length === 0, `A page below a prefix holding nothing holds ${page.prefixes.length} pseudo-directories`);
+			assert(page.cursor === void 0, "A page below a prefix holding nothing carries a cursor, so the listing is not complete");
+		}
+	},
+	{
+		name: "list/every-object-once",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/every-object-once");
+			const keys = keysBelow(prefix, 25);
+			await putEach(ctx, keys, patternOf(8));
+			assertNamesEachOnce((await collectEntries(ctx.storage.list({ prefix }))).map((entry) => entry.key), keys, "The iteration below the prefix");
+		}
+	},
+	{
+		name: "list/entry-shape",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/entry-shape");
+			const sizes = new Map(keysBelow(prefix, 3).map((key, index) => [key, 16 * (index + 1)]));
+			await Promise.all([...sizes].map(async ([key, size]) => void await ctx.storage.put(key, patternOf(size))));
+			const iterated = await collectEntries(ctx.storage.list({ prefix }));
+			assertNamesEachOnce(iterated.map((entry) => entry.key), [...sizes.keys()], "The iteration below the prefix");
+			for (const entry of iterated) {
+				const written = sizes.get(entry.key);
+				assert(entry.size === written, `The entry for ${JSON.stringify(entry.key)} reports ${entry.size} bytes and not the ${written} that were written`);
+				assertDate(entry.lastModified, `The last modification of ${JSON.stringify(entry.key)}`);
+			}
+		}
+	},
+	{
+		name: "list/pages-and-cursor",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/pages-and-cursor");
+			const keys = keysBelow(prefix, 5);
+			await putEach(ctx, keys, patternOf(8));
+			const held = [];
+			const counts = [];
+			let cursor;
+			for (let page = 1; page <= 3; page += 1) {
+				const read = await ctx.storage.list({
+					prefix,
+					pageSize: 2,
+					cursor
+				}).page();
+				held.push(...read.objects.map((entry) => entry.key));
+				counts.push(read.objects.length);
+				cursor = read.cursor;
+				if (page === 3) assert(cursor === void 0, "Page 3 of 3 carries a cursor, so the listing continues after its final object");
+				else assert(cursor !== void 0, `Page ${page} of 3 carries no cursor, so the listing ends before its objects do`);
+			}
+			assert(counts.join(", ") === "2, 2, 1", `Pages of 2 over 5 objects hold ${counts.join(", ")} objects`);
+			assertNamesEachOnce(held, keys, "The three pages together");
+		}
+	},
+	{
+		name: "list/delimiter",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/delimiter");
+			const atTheLevel = [`${prefix}a.txt`, `${prefix}b.txt`];
+			const below = [
+				`${prefix}one/x.txt`,
+				`${prefix}one/y.txt`,
+				`${prefix}two/x.txt`
+			];
+			await putEach(ctx, [...atTheLevel, ...below], patternOf(8));
+			const page = await ctx.storage.list({
+				prefix,
+				delimiter: "/"
+			}).page();
+			assertNamesEachOnce(page.objects.map((entry) => entry.key), atTheLevel, "The objects of a page with a delimiter");
+			assertNamesEachOnce(page.prefixes, [`${prefix}one/`, `${prefix}two/`], "The pseudo-directories of a page with a delimiter");
+			assertNamesEachOnce((await collectEntries(ctx.storage.list({
+				prefix,
+				delimiter: "/"
+			}))).map((entry) => entry.key), atTheLevel, "The iteration with a delimiter");
+		}
+	},
+	{
+		name: "list/prefix-mid-segment",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/prefix-mid-segment");
+			const matching = [`${prefix}report-1.txt`, `${prefix}report-2.txt`];
+			const beside = `${prefix}receipt.txt`;
+			await putEach(ctx, [...matching, beside], patternOf(8));
+			assertNamesEachOnce((await collectEntries(ctx.storage.list({ prefix: `${prefix}report-` }))).map((entry) => entry.key), matching, "The iteration below a prefix ending inside a segment");
+		}
+	},
+	{
+		name: "list/lazy",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/lazy");
+			const listing = listWithoutReading(ctx, { prefix });
+			const key = `${prefix}written-after-the-listing-was-built`;
+			await ctx.storage.put(key, patternOf(8));
+			assertNamesEachOnce((await listing.page()).objects.map((entry) => entry.key), [key], "The first page of a listing built before the write");
+			const refused = listWithoutReading(ctx, {
+				prefix,
+				pageSize: 0
+			});
+			await expectStorageError(() => refused.page(), { code: "InvalidOption" });
+		}
+	},
+	{
+		name: "list/page-size-bounds",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/page-size-bounds");
+			await Promise.all([0, 1001].map(async (pageSize) => {
+				assertNamesTheOption((await expectStorageError(async () => await listWithoutReading(ctx, {
+					prefix,
+					pageSize
+				}).page(), { code: "InvalidOption" }, `a page size of ${pageSize}`)).message, "pageSize");
+			}));
+		}
+	},
+	{
+		name: "list/invalid-cursor",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/invalid-cursor");
+			const cursor = "this-is-no-cursor-the-storage-handed-out";
+			assertNamesTheOption((await expectStorageError(async () => await listWithoutReading(ctx, {
+				prefix,
+				cursor
+			}).page(), { code: "InvalidOption" })).message, "cursor");
+		}
+	},
+	{
+		name: "list/invalid-delimiter",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/invalid-delimiter");
+			await expectStorageError(async () => await listWithoutReading(ctx, {
+				prefix,
+				delimiter: ""
+			}).page(), { code: "InvalidOption" });
+		}
+	},
+	{
+		name: "list/past-one-thousand",
+		requires: [],
+		cost: "slow",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/past-one-thousand");
+			const keys = keysBelow(prefix, pastOneThousand);
+			await putEach(ctx, keys, patternOf(8));
+			assertNamesEachOnce((await collectEntries(ctx.storage.list({ prefix }))).map((entry) => entry.key), keys, "The iteration below the prefix");
+			const page = await ctx.storage.list({ prefix }).page();
+			assert(page.objects.length <= pageSizeLimit, `One page at the default size holds ${page.objects.length} objects`);
+			assert(page.cursor !== void 0, `A page of ${page.objects.length} objects out of ${pastOneThousand} carries no cursor`);
+		}
+	},
+	{
+		name: "list/key-bytes",
+		requires: ["keyBytesPreserved"],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/key-bytes");
+			await Promise.all(normalForms.map(async ({ form, name }) => void await ctx.storage.put(`${prefix}${name}`, utf8$2.encode(form))));
+			assertNamesEachOnce((await collectEntries(ctx.storage.list({ prefix }))).map((entry) => entry.key), normalForms.map(({ name }) => `${prefix}${name}`), "The iteration below the prefix");
+			await Promise.all(normalForms.map(async ({ form, name }) => {
+				assertSameBytes(await (await ctx.storage.get(`${prefix}${name}`)).bytes(), utf8$2.encode(form), `the object under the ${form} key`);
+			}));
+		},
+		async runWithout(ctx) {
+			await Promise.all(normalForms.map(async ({ form, name }) => {
+				const prefix = `${prefixFor(ctx, "list/key-bytes")}${form}/`;
+				const key = `${prefix}${name}`;
+				await ctx.storage.put(key, patternOf(8));
+				const iterated = await collectEntries(ctx.storage.list({ prefix }));
+				const listed = iterated[0]?.key;
+				assert(iterated.length === 1, `The listing below the ${form} prefix yields ${iterated.length} entries for the one object the case wrote`);
+				assert(listed?.normalize() === key.normalize(), `The listing names the ${form} key as ${JSON.stringify(listed)}, which is no Unicode equivalent of ${JSON.stringify(key)}`);
+			}));
+		}
+	},
+	{
+		name: "list/noncharacter-key",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "list/noncharacter-key");
+			const key = `${prefix}noncharacter-${String.fromCodePoint(65534)}.txt`;
+			const body = patternOf(16);
+			await ctx.storage.put(key, body);
+			assertNamesEachOnce((await collectEntries(ctx.storage.list({ prefix }))).map((entry) => entry.key), [key], "The iteration below the prefix");
+			const stored = await ctx.storage.get(key);
+			assert(stored.stat.key === key, `\`get\` describes the object as ${JSON.stringify(stored.stat.key)} and not as the key it was asked for`);
+			assertSameBytes(await stored.bytes(), body, "the object under the key holding U+FFFE");
+			assertAccepted(await ctx.storage.delete(key), 1, "Deleting the key holding U+FFFE");
+			await assertNothingBelow(ctx, prefix);
+		}
+	}
+];
+/**
+* A listing built but not read. Spec 4.6 has `list` perform no request until then, so it
+* reports nothing — not even an option it is going to refuse. A throw here is that
+* promise broken rather than the refusal the case is after, and worth saying apart.
+*/
+function listWithoutReading(ctx, options) {
+	try {
+		return ctx.storage.list(options);
+	} catch (thrown) {
+		throw new Error(`\`list\` refused ${JSON.stringify(options)} before the listing was read: ${serializeError(thrown).message}`, { cause: thrown });
+	}
+}
+function assertNamesTheOption(message, option) {
+	assert(message.includes(option), `The message ${JSON.stringify(message)} does not name the option \`${option}\``);
+}
+//#endregion
+//#region src/cases/put.ts
+const utf8$1 = new TextEncoder();
+/** Spec 4.3 takes an ASCII HTTP token as a user metadata key, which this is not. */
+const metadataKeyAboveAscii = { grüße: "hallo" };
+/** No Unicode character, so no UTF-8 form for the 2 KB of spec 4.3 to measure. */
+const metadataValueWithLoneSurrogate = { note: "lone-\ud800" };
+/** An ASCII HTTP token and no identifier, which spec 4.9 promises under `userMetadataTokenKeys`. */
+const metadataTokenKey = { "content-hash": "sha256-conformance" };
+/** Over the 2 KB of encoded header bytes spec 4.3 allows a whole user metadata set. */
+const metadataOverTheLimit = { note: "x".repeat(2 * kibibyte) };
+const putCases = [
+	{
+		name: "put/bytes-round-trip",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/bytes-round-trip", "object.json");
+			const bytes = patternOf(kibibyte);
+			const written = await ctx.storage.put(key, bytes, { contentType: "application/json" });
+			assertSameBytes(await (await ctx.storage.get(key)).bytes(), bytes, "the body `get` read back");
+			assertSameDescription(written, await ctx.storage.stat(key), [
+				"key",
+				"size",
+				"contentType"
+			], "`put` and a later `stat`");
+		}
+	},
+	{
+		name: "put/string-round-trip",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/string-round-trip");
+			const text = "Grüße aus 日本 — ключ";
+			const written = await ctx.storage.put(key, text, { contentType: "text/plain; charset=utf-8" });
+			const read = await (await ctx.storage.get(key)).text();
+			assert(read === text, `\`text()\` read back ${JSON.stringify(read)}`);
+			assert(written.size === utf8$1.encode(text).byteLength, `\`put\` reported ${written.size} bytes for a string of ${utf8$1.encode(text).byteLength} UTF-8 bytes`);
+		}
+	},
+	{
+		name: "put/stream-round-trip",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/stream-round-trip");
+			const bytes = patternOf(mebibyte);
+			await ctx.storage.put(key, streamOf(bytes, 64 * kibibyte));
+			assertSameBytes(await (await ctx.storage.get(key)).bytes(), bytes, "the body `get` read back");
+		}
+	},
+	{
+		name: "put/multipart-round-trip",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/multipart-round-trip");
+			const bytes = patternOf(multipartSize);
+			await ctx.storage.put(key, streamOf(bytes, mebibyte));
+			const described = await ctx.storage.stat(key);
+			assert(described.size === multipartSize, `\`stat\` reports ${described.size} bytes for an upload of ${multipartSize}`);
+			assertSameBytes(await collect((await ctx.storage.get(key)).stream()), bytes, "the body `get` read back");
+		}
+	},
+	{
+		name: "put/empty-body",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const empty = /* @__PURE__ */ new Uint8Array(0);
+			const bodies = [{
+				what: "an empty `Uint8Array`",
+				key: keyFor(ctx, "put/empty-body", "bytes"),
+				body: empty
+			}, {
+				what: "a stream that yields nothing",
+				key: keyFor(ctx, "put/empty-body", "stream"),
+				body: streamOf(empty, kibibyte)
+			}];
+			await Promise.all(bodies.map(async ({ what, key, body }) => {
+				const written = await ctx.storage.put(key, body);
+				assert(written.size === 0, `\`put\` reported ${written.size} bytes for ${what}`);
+				assertSameBytes(await (await ctx.storage.get(key)).bytes(), empty, `the body ${what} left behind`);
+			}));
+		}
+	},
+	{
+		name: "put/overwrites",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/overwrites", "object.json");
+			const second = patternOf(128);
+			await ctx.storage.put(key, patternOf(64), { contentType: "text/plain" });
+			await ctx.storage.put(key, second, { contentType: "application/json" });
+			const stored = await ctx.storage.get(key);
+			assert(stored.stat.contentType === "application/json", `The second \`put\` left the content type at ${JSON.stringify(stored.stat.contentType)}`);
+			assertSameBytes(await stored.bytes(), second, "the body of the overwritten object");
+		}
+	},
+	{
+		name: "put/content-type-stored",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/content-type-stored", "note.txt");
+			await ctx.storage.put(key, "a note", { contentType: "text/plain" });
+			assertContentType(await ctx.storage.stat(key), "text/plain", "`stat`");
+			assertContentType((await ctx.storage.get(key)).stat, "text/plain", "`get`");
+		}
+	},
+	{
+		name: "put/content-type-default",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/content-type-default", "object-without-an-extension");
+			await ctx.storage.put(key, patternOf(16));
+			assertContentType(await ctx.storage.stat(key), "application/octet-stream", "`stat`");
+		}
+	},
+	{
+		name: "put/accepted-keys",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const prefix = prefixFor(ctx, "put/accepted-keys");
+			const accepted = acceptedKeys(prefix);
+			await Promise.all(accepted.map(async ({ label, key }) => {
+				const bytes = utf8$1.encode(label);
+				await ctx.storage.put(key, bytes);
+				assertSameBytes(await (await ctx.storage.get(key)).bytes(), bytes, `the object under ${label}`);
+			}));
+			const listed = /* @__PURE__ */ new Set();
+			for await (const entry of ctx.storage.list({ prefix })) listed.add(entry.key.normalize());
+			for (const { label, key } of accepted) assert(listed.has(key.normalize()), `The listing below the prefix holds no ${label}`);
+		}
+	},
+	{
+		name: "put/refused-keys",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const refused = refusedWritableKeys(prefixFor(ctx, "put/refused-keys"));
+			const bytes = patternOf(16);
+			await Promise.all(refused.map(async (refusal) => {
+				await expectStorageError(() => ctx.storage.put(refusal.key, bytes), {
+					code: "InvalidKey",
+					...refusal.existsAnswers === "false-or-refusal" ? {} : { attempts: 0 }
+				}, refusal.label);
+				await assertNothingWasWritten(ctx, refusal);
+			}));
+		}
+	},
+	{
+		name: "put/unknown-option",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/unknown-option");
+			const option = "stowageTakesNoSuchOption";
+			const options = { [option]: true };
+			const refusal = await expectStorageError(() => ctx.storage.put(key, patternOf(16), options), { code: "InvalidOption" });
+			assert(refusal.message.includes(option), `The message ${JSON.stringify(refusal.message)} does not name the option`);
+			assert(!await ctx.storage.exists(key), "`put` wrote the object although it refused the option");
+		}
+	},
+	{
+		name: "put/aborted-signal",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/aborted-signal");
+			await expectRuntimeError(() => ctx.storage.put(key, patternOf(16), { signal: AbortSignal.abort() }), "AbortError");
+			assert(!await ctx.storage.exists(key), "`put` wrote the object although the signal was aborted");
+		}
+	},
+	{
+		name: "put/abort-during-upload",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/abort-during-upload");
+			const bytes = patternOf(multipartSize);
+			const controller = new AbortController();
+			await expectRuntimeError(() => ctx.storage.put(key, streamAbortedMidway(bytes, mebibyte, controller), { signal: controller.signal }), "AbortError");
+		}
+	},
+	{
+		name: "put/stream-consumed",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/stream-consumed");
+			const body = streamOf(patternOf(64 * kibibyte), 8 * kibibyte);
+			await ctx.storage.put(key, body);
+			assert(!body.locked, "The source stream is still locked to a reader `put` kept");
+			const { done } = await body.getReader().read();
+			assert(done, "The source stream is neither at its end nor canceled after `put`");
+		}
+	},
+	{
+		name: "put/user-metadata",
+		requires: ["userMetadata"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/user-metadata");
+			const userMetadata = {
+				WrittenBy: "stowage",
+				run: "conformance"
+			};
+			await ctx.storage.put(key, patternOf(16), { userMetadata });
+			assertHoldsMetadata((await ctx.storage.stat(key)).userMetadata, userMetadata, "`stat`");
+			assertHoldsMetadata((await ctx.storage.get(key)).stat.userMetadata, userMetadata, "`get`");
+		},
+		async runWithout(ctx) {
+			const refused = keyFor(ctx, "put/user-metadata", "refused");
+			const empty = keyFor(ctx, "put/user-metadata", "empty");
+			await expectUnsupported(() => ctx.storage.put(refused, patternOf(16), { userMetadata: { WrittenBy: "stowage" } }), "userMetadata");
+			await ctx.storage.put(empty, patternOf(16), { userMetadata: {} });
+			assertNoMetadata((await ctx.storage.stat(empty)).userMetadata, "`stat`");
+			assertNoMetadata((await ctx.storage.get(empty)).stat.userMetadata, "`get`");
+		}
+	},
+	{
+		name: "put/user-metadata-limits",
+		requires: ["userMetadata"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/user-metadata-limits");
+			const bytes = patternOf(16);
+			await expectStorageError(() => ctx.storage.put(key, bytes, { userMetadata: metadataKeyAboveAscii }), {
+				code: "InvalidRequest",
+				attempts: 0
+			}, "a user metadata key above ASCII");
+			await expectStorageError(() => ctx.storage.put(key, bytes, { userMetadata: metadataValueWithLoneSurrogate }), {
+				code: "InvalidRequest",
+				attempts: 0
+			}, "a user metadata value holding a lone surrogate");
+			await expectStorageError(() => ctx.storage.put(key, bytes, { userMetadata: metadataOverTheLimit }), {
+				code: "InvalidRequest",
+				attempts: 0
+			}, "a user metadata set over 2 KB");
+		},
+		async runWithout(ctx) {
+			const key = keyFor(ctx, "put/user-metadata-limits");
+			const bytes = patternOf(16);
+			await expectUnsupported(() => ctx.storage.put(key, bytes, { userMetadata: metadataKeyAboveAscii }), "userMetadata");
+			await expectUnsupported(() => ctx.storage.put(key, bytes, { userMetadata: metadataValueWithLoneSurrogate }), "userMetadata");
+			await expectUnsupported(() => ctx.storage.put(key, bytes, { userMetadata: metadataOverTheLimit }), "userMetadata");
+		}
+	},
+	{
+		name: "put/user-metadata-token-keys",
+		requires: ["userMetadata", "userMetadataTokenKeys"],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/user-metadata-token-keys");
+			await ctx.storage.put(key, patternOf(16), { userMetadata: metadataTokenKey });
+			assertHoldsMetadata((await ctx.storage.stat(key)).userMetadata, metadataTokenKey, "`stat`");
+			assertHoldsMetadata((await ctx.storage.get(key)).stat.userMetadata, metadataTokenKey, "`get`");
+		},
+		async runWithout(ctx) {
+			const key = keyFor(ctx, "put/user-metadata-token-keys");
+			await expectStorageError(() => ctx.storage.put(key, patternOf(16), { userMetadata: metadataTokenKey }), {
+				code: "Unsupported",
+				attempts: 0,
+				capability: ctx.declares("userMetadata") ? "userMetadataTokenKeys" : "userMetadata"
+			}, "a user metadata key beyond identifiers");
+		}
+	},
+	{
+		name: "put/concurrent-writers",
+		requires: [],
+		cost: "fast",
+		async run(ctx) {
+			const key = keyFor(ctx, "put/concurrent-writers");
+			const patterns = [patternOf(multipartSize), patternOf(multipartSize, 1)];
+			const bodies = streamsEndingTogether(patterns, mebibyte);
+			const outcomes = await Promise.allSettled(bodies.map((body) => ctx.storage.put(key, body)));
+			assert(outcomes.some((outcome) => outcome.status === "fulfilled"), `Both writers rejected: ${outcomes.map(describeOutcome).join("; ")}`);
+			const held = await collect((await ctx.storage.get(key)).stream());
+			assert(patterns.some((pattern) => sameBytes(held, pattern)), `The key holds ${held.byteLength} bytes that are neither writer's object whole`);
+		}
+	}
+];
+function describeOutcome(outcome) {
+	return outcome.status === "fulfilled" ? "resolved" : String(outcome.reason);
+}
+function sameBytes(one, other) {
+	return one.byteLength === other.byteLength && one.every((byte, index) => byte === other[index]);
+}
+function assertContentType(described, expected, where) {
+	assert(described.contentType === expected, `${where} reports the content type ${JSON.stringify(described.contentType)} and not ${JSON.stringify(expected)}`);
+}
+function assertHoldsMetadata(held, expected, where) {
+	const lowered = new Map(Object.entries(held).map(([name, value]) => [name.toLowerCase(), value]));
+	for (const [name, value] of Object.entries(expected)) {
+		const read = lowered.get(name.toLowerCase());
+		assert(read === value, `${where} reports the user metadata ${JSON.stringify(name)} as ${JSON.stringify(read)} and not as ${JSON.stringify(value)}`);
+	}
+}
+function assertNoMetadata(held, where) {
+	assert(Object.keys(held).length === 0, `${where} reports the user metadata ${JSON.stringify(held)} on a storage that holds none`);
+}
+async function assertNothingWasWritten(ctx, refused) {
+	if (refused.existsAnswers === "unasked") return;
+	assert(await existsOrRefusal(ctx, refused) !== true, `\`exists\` answers true for ${refused.label}, which \`put\` refused`);
+}
+async function existsOrRefusal(ctx, refused) {
+	try {
+		return await ctx.storage.exists(refused.key);
+	} catch (thrown) {
+		if (!(refused.existsAnswers === "false-or-refusal" && isStorageError(thrown) && thrown.code === "InvalidKey")) throw thrown;
+		return "refusal";
+	}
+}
+//#endregion
+//#region src/cases/stat.ts
+const utf8 = new TextEncoder();
+/** What spec 4.4 allows between the time the provider reported and the clock reading it. */
+const clockTolerance = 6e4;
+const statCases = [{
+	name: "stat/describes-object",
+	requires: [],
+	cost: "fast",
+	async run(ctx) {
+		const key = keyFor(ctx, "stat/describes-object", "object.txt");
+		const body = "a body to describe";
+		const size = utf8.encode(body).byteLength;
+		await ctx.storage.put(key, body, { contentType: "text/plain" });
+		const described = await ctx.storage.stat(key);
+		assert(described.key === key, `\`stat\` reports the key ${JSON.stringify(described.key)} for ${JSON.stringify(key)}`);
+		assert(described.size === size, `\`stat\` reports ${described.size} bytes and not ${size}`);
+		assert(described.contentType === "text/plain", `\`stat\` reports the content type ${JSON.stringify(described.contentType)}`);
+		assertWrittenJustNow(described.lastModified);
+		assert(typeof described.userMetadata === "object" && described.userMetadata !== null, `\`stat\` reports the user metadata as ${JSON.stringify(described.userMetadata)}`);
+	}
+}, {
+	name: "stat/missing-key",
+	requires: [],
+	cost: "fast",
+	async run(ctx) {
+		const key = keyFor(ctx, "stat/missing-key", "absent");
+		await expectStorageError(() => ctx.storage.stat(key), {
+			code: "NotFound",
+			operation: "stat"
+		});
+	}
+}];
+function assertWrittenJustNow(lastModified) {
+	assertDate(lastModified, "The last modification `stat` reports");
+	assert(Math.abs(Date.now() - lastModified.getTime()) <= clockTolerance, `\`stat\` reports the last modification as ${lastModified.toISOString()}, which is no moment ago`);
+}
+//#endregion
+//#region src/cases/index.ts
+const conformanceCaseSources = [
+	...declarationCases,
+	...putCases,
+	...getCases,
+	...statCases,
+	...existsCases,
+	...listCases,
+	...deleteCases,
+	...copyAndMoveCases,
+	...errorCases,
+	...presignCases,
+	...flowCases
+];
+/** The same cases as the package publishes them, without the factory of spec 9.3. */
+const conformanceCases = conformanceCaseSources;
+//#endregion
+//#region src/run.ts
+/** The cases a run performs: the `fast` tier alone unless it asks for both (spec 9.2). */
+function selectedCases(options) {
+	if (options?.includeSlow === true) return conformanceCaseSources;
+	return conformanceCaseSources.filter((source) => source.cost === "fast");
+}
+const keyPrefixRoot = "stowage-conformance";
+function createKeyPrefix() {
+	return `${keyPrefixRoot}/${crypto.randomUUID()}/`;
+}
+/**
+* Spec 9.2: the declaration is read once per run, before the first case, because every
+* storage the target creates in one run declares the same.
+*/
+async function startRun(target, keyPrefix) {
+	const storage = await target.createStorage();
+	const declared = new Set(storage.capabilities);
+	return {
+		storage,
+		keyPrefix,
+		target,
+		declares: (name) => declared.has(name)
+	};
+}
+/**
+* Spec 9.2: the default deletes below the prefix on a storage of its own, so that a run
+* whose storage broke on the way still clears what it wrote.
+*/
+async function cleanUp(target, keyPrefix) {
+	if (target.cleanup !== void 0) return await target.cleanup(keyPrefix);
+	const [failure] = (await (await target.createStorage()).deleteAll(keyPrefix)).failed;
+	if (failure !== void 0) throw failure;
+}
+/** The factory the case needs and the target left out, which spec 9.2 skips it for. */
+function skipReasonFor(source, target) {
+	if (source.factory === void 0 || target[source.factory] !== void 0) return void 0;
+	return source.factory;
+}
+/**
+* Spec 9.2: a case whose requirements are all declared runs `run`, and one missing a
+* name runs `runWithout`.
+*/
+function selectHalf(source, context) {
+	if ("runWithout" in source && !source.requires.every((name) => context.declares(name))) return {
+		mode: "without",
+		run: async () => await source.runWithout(context)
+	};
+	return {
+		mode: "declared",
+		run: async () => await source.run(context)
+	};
+}
+//#endregion
+//#region src/describe.ts
+/**
+* Maps every case onto one test of Vitest, `bun:test` or `Deno.test`, whose `describe`
+* and `test` agree in shape (ADR 0006), so that a failing case is a failing test of its
+* own rather than one red line covering the suite.
+*/
+function describeConformance(target, framework) {
+	describeCases(selectedCases(framework), target, framework);
+}
+/** The mapping behind `describeConformance`, over the cases a caller picked. */
+function describeCases(sources, target, framework) {
+	const keyPrefix = createKeyPrefix();
+	let opened;
+	const open = async () => await (opened ??= startRun(target, keyPrefix));
+	framework.describe(target.name, () => {
+		for (const source of sources) {
+			const skipped = skipReasonFor(source, target);
+			if (skipped !== void 0) {
+				framework.test(`${source.name} (skipped: ${skipped})`, async () => {});
+				continue;
+			}
+			framework.test(source.name, async () => {
+				await selectHalf(source, await open()).run();
+			});
+		}
+		framework.test("cleanup", async () => await cleanUp(target, keyPrefix));
+	});
+}
+//#endregion
+//#region src/case.ts
+function metadataOf(source) {
+	return {
+		name: source.name,
+		requires: [...source.requires],
+		cost: source.cost
+	};
+}
+//#endregion
+//#region src/run-all.ts
+/**
+* Runs the cases without a test framework and reports them, which is how a runtime that
+* has none — `workerd` — runs the suite (ADR 0006). A failing case is one result among
+* the others; only a target that cannot produce a storage at all rejects the run.
+*/
+async function runAll(target, options) {
+	return await runCases(selectedCases(options), target);
+}
+/** One run over the cases a caller picked, which is what `runAll` is around the suite. */
+async function runCases(sources, target) {
+	const keyPrefix = createKeyPrefix();
+	const context = await startRun(target, keyPrefix);
+	const results = [];
+	for (const source of sources) {
+		const skipped = skipReasonFor(source, target);
+		if (skipped !== void 0) {
+			results.push({
+				case: metadataOf(source),
+				status: "skipped",
+				reason: skipped
+			});
+			continue;
+		}
+		const half = selectHalf(source, context);
+		try {
+			await half.run();
+			results.push({
+				case: metadataOf(source),
+				status: "passed",
+				mode: half.mode
+			});
+		} catch (thrown) {
+			results.push({
+				case: metadataOf(source),
+				status: "failed",
+				mode: half.mode,
+				error: serializeError(thrown)
+			});
+		}
+	}
+	await cleanUp(target, keyPrefix);
+	return results;
+}
+//#endregion
+export { conformanceCases, describeConformance, expectUnsupported, runAll };