@stowage/conformance 0.1.0 → 0.2.0

package/README.md

@@ -14,7 +14,7 @@ npm install --save-dev @stowage/conformance
 A `ConformanceTarget` tells the suite how to construct the storage under test. `createStorage`
 returns a storage the run may write to below any prefix, constructed from outside the adapter the
 way a caller would construct it
-([spec 8.3](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/docs/spec.md#83-what-the-target-promises)).
+([spec 9.3](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/docs/spec.md#93-what-the-target-promises)).
 
 ```ts
 import { memoryStorage } from "@stowage/adapter-memory";
@@ -41,14 +41,15 @@ The optional members widen the run:
 The suite reads what the storage supports from its `capabilities`, once per run, before the first
 case. The storage lists every name out of `capabilityNames` it implements, each once, and the list
 is fixed when it is constructed
-([spec 4.9](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/docs/spec.md#49-capabilities)).
+([spec 4.9](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/docs/spec.md#49-capabilities)).
 Every storage the target creates in one run declares the same; two configurations are two targets.
 
-A case whose `requires` the storage declares runs its `run` half. A case it does not declare runs
-the `runWithout` half, which checks what the storage does without the capability: most refuse the
-call with `Unsupported` naming it, `presignedUrls` has `presignGet` and `presignPut` absent from the
-storage, and a few check the weaker behavior, such as a copy whose destination reads `{}`
-([spec 8.5](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/docs/spec.md#85-cases)).
+A case whose `requires` the storage declares runs its `run` half. A case missing a name of its
+`requires` runs the `runWithout` half, which checks what the storage does without the capability:
+most refuse the call with `Unsupported` naming it, `presignedUrls` has `presignGet` and
+`presignPut` absent from the storage, and a few check the weaker behavior, such as a copy whose
+destination reads `{}`
+([spec 9.5](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/docs/spec.md#95-cases)).
 An adapter refuses such a call like this:
 
 ```ts
@@ -73,7 +74,7 @@ export function refuseUserMetadata(bucket: string): StorageError {
 
 `describeConformance(target, framework)` maps every case onto the `describe` and `test` of the
 framework it is handed
-([spec 8.2](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/docs/spec.md#82-running-the-suite)).
+([spec 9.2](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/docs/spec.md#92-running-the-suite)).
 It runs the `fast` cases, and both tiers with `includeSlow: true`.
 
 Vitest:
@@ -156,27 +157,29 @@ A failed result carries the error as `name`, `message`, `stack` and, for a `Stor
 
 ## Read an adapter
 
-[`@stowage/adapter-memory`](https://github.com/stowage-js/stowage/tree/@stowage/adapter-memory@0.1.0/packages/adapter-memory/src)
-is the implementation a third-party adapter is read against. It enforces the key rule exactly,
-declares three of the four capabilities, and has no network in the way. The cases themselves are
+[`@stowage/adapter-memory`](https://github.com/stowage-js/stowage/tree/@stowage/adapter-memory@0.2.0/packages/adapter-memory/src)
+is the implementation a third-party adapter is read against, out of the four adapters of this
+repository that pass these cases: `@stowage/adapter-memory`, `@stowage/adapter-fs`,
+`@stowage/adapter-s3` and `@stowage/adapter-azure-blob`. It enforces the key rule exactly,
+declares four of the five capabilities, and has no network in the way. The cases themselves are
 written against the behavior of S3, not against it.
 
 What the suite leaves to an adapter's own tests, such as flat memory during a large upload or the
 retry curve, is listed in
-[spec 8.4](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/docs/spec.md#84-what-the-suite-does-not-assert).
+[spec 9.4](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/docs/spec.md#94-what-the-suite-does-not-assert).
 
 ## Runtimes
 
-Node 24 and later, Bun, Deno and `workerd` at the compatibility date `2026-09-01`. CI last ran green on Bun 1.4.2 and Deno 2.9.6.
+Node 24 and later, Bun, Deno and `workerd` at the compatibility date `2026-09-01` without Node APIs. CI last ran green on Bun 1.4.2 and Deno 2.9.6.
 
-The bundle measures 10.7 kB minified and gzipped, `@stowage/core` included.
+The bundle measures 11.6 kB minified and gzipped, `@stowage/core` included.
 
 ## Specification
 
-[`docs/spec.md` at `@stowage/conformance@0.1.0`](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/docs/spec.md#8-stowageconformance)
+[`docs/spec.md` at `@stowage/conformance@0.2.0`](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/docs/spec.md#9-stowageconformance)
 is the contract: a caller may rely on what it states and on nothing else this package happens to
-export. The [terms it uses](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.1.0/CONTEXT.md)
-and the [decisions behind it](https://github.com/stowage-js/stowage/tree/@stowage/conformance@0.1.0/docs/adr)
+export. The [terms it uses](https://github.com/stowage-js/stowage/blob/@stowage/conformance@0.2.0/CONTEXT.md)
+and the [decisions behind it](https://github.com/stowage-js/stowage/tree/@stowage/conformance@0.2.0/docs/adr)
 are at the same tag.
 
 ## License

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { CapabilityName, Storage, StorageErrorCode } from "@stowage/core";
 //#region src/assertions.d.ts
 /**
  * Spec 4.9 leaves a call needing a capability the storage does not declare with an
- * `Unsupported` error naming it, and spec 8.2 has most of the `runWithout` halves assert
+ * `Unsupported` error naming it, and spec 9.2 has most of the `runWithout` halves assert
  * that through this.
  */
 export declare function expectUnsupported(call: () => Promise<unknown>, capability: CapabilityName): Promise<void>;
@@ -43,7 +43,7 @@ interface ConformanceCaseMetadata {
 }
 //#endregion
 //#region src/cases/index.d.ts
-/** The same cases as the package publishes them, without the factory of spec 8.3. */
+/** The same cases as the package publishes them, without the factory of spec 9.3. */
 export declare const conformanceCases: readonly ConformanceCase[];
 //#endregion
 //#region src/result.d.ts

package/dist/index.js

@@ -61,7 +61,7 @@ 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 8.5 names. Spec 4.4
+* 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.
 */
@@ -69,7 +69,7 @@ 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 8.5 and 8.6 have the two cases
+* 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) {
@@ -78,7 +78,7 @@ function assertHeader(response, name, 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 8.5 states beyond the fields it named here. A case
+* 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) {
@@ -114,7 +114,7 @@ async function expectRuntimeError(call, name) {
 }
 /**
 * Spec 4.9 leaves a call needing a capability the storage does not declare with an
-* `Unsupported` error naming it, and spec 8.2 has most of the `runWithout` halves assert
+* `Unsupported` error naming it, and spec 9.2 has most of the `runWithout` halves assert
 * that through this.
 */
 async function expectUnsupported(call, capability) {
@@ -138,7 +138,7 @@ async function rejectionOf(call, expectation) {
 //#endregion
 //#region src/cases/keys.ts
 const utf8$6 = new TextEncoder();
-/** Spec 8.7 measures a key in UTF-8 bytes, and `adapter-fs` bounds one segment at 255. */
+/** 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
@@ -150,6 +150,11 @@ const refusedControlCharacters = [
 	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. */
@@ -161,7 +166,7 @@ function keyFor(ctx, caseName, name = "object") {
 }
 /**
 * A key of exactly `bytes` UTF-8 bytes below `prefix`, in segments of at most 255 bytes:
-* the boundary key of spec 8.2 and the over-long key of spec 8.7 are both built here, so
+* 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) {
@@ -171,7 +176,7 @@ function keyOfBytes(prefix, bytes) {
 	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 8.7, below the prefix of the case that writes it. */
+/** The accepted list of spec 9.7, below the prefix of the case that writes it. */
 function acceptedKeys(prefix) {
 	return [
 		...acceptedNames.map((name) => ({
@@ -200,7 +205,7 @@ const acceptedNames = [
 	"Grüße/日本語/ключ.txt"
 ];
 /**
-* The list of spec 8.7 that `put` refuses, below the prefix of the case wherever the
+* 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.
@@ -247,11 +252,14 @@ function refusedWritableKeys(prefix) {
 			key: `${prefix}a\\b`,
 			existsAnswers: "false"
 		},
-		...refusedControlCharacters.map((code) => ({
-			label: `a key holding U+${code.toString(16).toUpperCase().padStart(4, "0")}`,
-			key: `${prefix}a${String.fromCharCode(code)}b`,
-			existsAnswers: "unasked"
-		})),
+		...[...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),
@@ -259,6 +267,46 @@ function refusedWritableKeys(prefix) {
 		}
 	];
 }
+/**
+* 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
 /**
@@ -274,7 +322,7 @@ const textContentType = "text/plain";
 */
 const inFlight = 32;
 /**
-* What the `slow` cases of spec 8.5 write: one past the thousand objects a provider
+* 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.
 */
@@ -311,6 +359,11 @@ 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();
@@ -391,11 +444,11 @@ const copyAndMoveCases = [
 			const to = `${prefix}destination.txt`;
 			await ctx.storage.put(from, "the body to copy", {
 				contentType: textContentType,
-				userMetadata: { "Written-By": "stowage" }
+				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("written-by") === "stowage", `The destination carries the user metadata ${JSON.stringify(described.userMetadata)} and not the source's`);
+			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");
@@ -480,18 +533,19 @@ function assertNonEmptyString(value, field) {
 //#endregion
 //#region src/cases/bytes.ts
 const kibibyte = 1024;
-/** The bytes a body is measured in, where a case names a size spec 8.5 or 8.6 states. */
+/** 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.
+* 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) {
+function patternOf(size, seed = 0) {
 	const bytes = new Uint8Array(size);
-	for (let index = 0; index < size; index += 1) bytes[index] = index * 7 % 251;
+	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. */
@@ -507,6 +561,44 @@ function streamOf(bytes, chunkSize, onChunk) {
 		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;
@@ -642,11 +734,6 @@ const deleteCases = [
 		}
 	}
 ];
-/** 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/errors.ts
 /**
@@ -697,11 +784,11 @@ const errorCases = [
 		async run(ctx) {
 			const prefix = prefixFor(ctx, "errors/bad-credentials");
 			const storage = await storageFrom(ctx, "createStorageWithBadCredentials");
-			await expectStorageError(() => storage.get(`${prefix}object`), {
+			const refused = await expectStorageError(() => storage.get(`${prefix}object`), {
 				code: "InvalidCredentials",
-				retryable: false,
-				attempts: 1
+				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");
 		}
@@ -787,7 +874,7 @@ 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 8.2 has kept the case out of a run without. */
+/** 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}\``);
@@ -820,7 +907,7 @@ const existsCases = [{
 //#endregion
 //#region src/cases/presign.ts
 const utf8$4 = new TextEncoder();
-/** Past the second `presign/expired-url` signs for, which is what spec 8.5 waits out. */
+/** 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];
@@ -834,7 +921,7 @@ const presignCases = [
 			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 presignedUrl(ctx, "presignGet", key, { expiresIn: 300 }));
+			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");
@@ -848,7 +935,7 @@ const presignCases = [
 		async run(ctx) {
 			const key = keyFor(ctx, "presign/put", "object.txt");
 			const body = utf8$4.encode("the body a signed `PUT` takes");
-			const url = await presignedUrl(ctx, "presignPut", key, {
+			const { url, headers } = await presignedPut(ctx, key, {
 				expiresIn: 300,
 				contentType: textContentType,
 				contentLength: body.byteLength
@@ -856,7 +943,7 @@ const presignCases = [
 			const response = await fetch(url, {
 				method: "PUT",
 				body,
-				headers: { "content-type": textContentType }
+				headers
 			});
 			assert(response.ok, `\`fetch\` on a signed \`PUT\` answered ${response.status} and not a success`);
 			await response.arrayBuffer();
@@ -884,15 +971,17 @@ const presignCases = [
 		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 url = await presignedUrl(ctx, "presignPut", key, {
+			const presigned = await presignedPut(ctx, key, {
 				expiresIn: 300,
 				contentType: textContentType,
 				contentLength: body.byteLength
 			});
-			assertStatus(await statusOf(await fetch(url, {
+			const headers = new Headers(presigned.headers);
+			headers.set("content-type", "application/json");
+			assertStatus(await statusOf(await fetch(presigned.url, {
 				method: "PUT",
 				body,
-				headers: { "content-type": "application/json" }
+				headers
 			})), 403, "a signed `PUT` carrying another content type");
 		},
 		runWithout: assertNeitherMethod
@@ -904,7 +993,7 @@ const presignCases = [
 		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 = await presignedUrl(ctx, "presignPut", key, {
+			const { url, headers } = await presignedPut(ctx, key, {
 				expiresIn: 300,
 				contentType: textContentType,
 				contentLength: body.byteLength - 1
@@ -912,7 +1001,7 @@ const presignCases = [
 			const status = await statusOf(await fetch(url, {
 				method: "PUT",
 				body,
-				headers: { "content-type": textContentType }
+				headers
 			}));
 			assert(status >= 400 && status < 500, `A signed \`PUT\` carrying another length was answered ${status} and not refused`);
 		},
@@ -925,7 +1014,7 @@ const presignCases = [
 		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 presignedUrl(ctx, "presignGet", key, { expiresIn: 1 });
+			const url = await presignedGet(ctx, key, { expiresIn: 1 });
 			await delay(pastTheLifetime);
 			assertStatus(await statusOf(await fetch(url)), 403, "a signed `GET` that has expired");
 		},
@@ -940,12 +1029,41 @@ const presignCases = [
 async function assertNeitherMethod(ctx) {
 	for (const name of presignNames) assert(!(name in ctx.storage), `The storage declares no \`presignedUrls\` and carries \`${name}\``);
 }
-/** The URL the method handed back, which a target may report as anything at runtime. */
-async function presignedUrl(ctx, name, key, options) {
-	const url = await presignerOf(ctx.storage, name)(key, options);
-	assert(typeof url === "string" && url !== "", `\`${name}\` handed back ${JSON.stringify(url)} and not a URL`);
+/** 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}\``);
@@ -1023,7 +1141,7 @@ const flowCases = [
 		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 = await presignedUrl(ctx, "presignPut", key, {
+			const { url, headers } = await presignedPut(ctx, key, {
 				expiresIn: 300,
 				contentType: textContentType,
 				contentLength: body.byteLength
@@ -1031,7 +1149,7 @@ const flowCases = [
 			const response = await fetch(url, {
 				method: "PUT",
 				body,
-				headers: { "content-type": textContentType }
+				headers
 			});
 			assert(response.ok, `The upload to the presigned URL was answered ${response.status}`);
 			await response.arrayBuffer();
@@ -1238,6 +1356,23 @@ const getCases = [
 			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: [],
@@ -1539,6 +1674,23 @@ const listCases = [
 				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);
+		}
 	}
 ];
 /**
@@ -1561,6 +1713,10 @@ function assertNamesTheOption(message, option) {
 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 = [
@@ -1761,7 +1917,7 @@ const putCases = [
 		async run(ctx) {
 			const key = keyFor(ctx, "put/user-metadata");
 			const userMetadata = {
-				"Written-By": "stowage",
+				WrittenBy: "stowage",
 				run: "conformance"
 			};
 			await ctx.storage.put(key, patternOf(16), { userMetadata });
@@ -1771,7 +1927,7 @@ const putCases = [
 		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: { "Written-By": "stowage" } }), "userMetadata");
+			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`");
@@ -1788,6 +1944,10 @@ const putCases = [
 				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
@@ -1797,10 +1957,50 @@ const putCases = [
 			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)}`);
 }
@@ -1878,11 +2078,11 @@ const conformanceCaseSources = [
 	...presignCases,
 	...flowCases
 ];
-/** The same cases as the package publishes them, without the factory of spec 8.3. */
+/** 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 8.2). */
+/** 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");
@@ -1892,7 +2092,7 @@ function createKeyPrefix() {
 	return `${keyPrefixRoot}/${crypto.randomUUID()}/`;
 }
 /**
-* Spec 8.2: the declaration is read once per run, before the first case, because every
+* 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) {
@@ -1906,7 +2106,7 @@ async function startRun(target, keyPrefix) {
 	};
 }
 /**
-* Spec 8.2: the default deletes below the prefix on a storage of its own, so that a run
+* 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) {
@@ -1914,13 +2114,13 @@ async function cleanUp(target, 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 8.2 skips it for. */
+/** 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 8.2: a case whose requirements are all declared runs `run`, and one missing a
+* Spec 9.2: a case whose requirements are all declared runs `run`, and one missing a
 * name runs `runWithout`.
 */
 function selectHalf(source, context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stowage/conformance",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The cases every stowage adapter has to pass, as plain cases a test framework maps onto its own runner.",
   "keywords": [
     "adapter",
@@ -33,7 +33,7 @@
     "provenance": true
   },
   "dependencies": {
-    "@stowage/core": "^0.1.0"
+    "@stowage/core": "^0.2.0"
   },
   "engines": {
     "node": ">=24"