@vibedout/commerce 0.0.0-stage → 0.2.3

package/dist/testing.mjs

@@ -0,0 +1,2318 @@
+import { i as isRecord, t as SUBJECT_TYPE$1 } from "./internal-p2FS_A4L.mjs";
+import { a as isCurrencyCode, i as basisPointsOf, o as isMinorUnits, s as lineTotalMinor, u as taxIncludedIn } from "./money-aFFtGd0E.mjs";
+import { checkLineDiscounts, spreadDiscount } from "./discounts.mjs";
+import { DISCOUNT_REJECTIONS, MAX_HOLD_MS } from "./types.mjs";
+import { checkResolvedLines, holdsCapacity } from "./lines.mjs";
+import { checkStartPayment } from "./payments.mjs";
+import { computeTotals } from "./totals.mjs";
+//#region src/testing/context.ts
+/** 2026-10-08 12:00 UTC: a fixed "now" for tests, so a hold that expires does so when the test says. */
+const TEST_NOW = Date.UTC(2026, 9, 8, 12, 0, 0);
+const noDatabase = () => {
+	throw new Error("this test context has no database: pass a ctx with a D1 binding to a port that needs one");
+};
+/**
+* A {@link PortContext} for a test double: a fixed clock, no environment, and a `db` whose every method throws, so a double that reaches for
+* the database fails loudly. A port that really uses D1 is tested with the project's own `env.DB` instead.
+*/
+function testContext(overrides = {}) {
+	return {
+		env: {},
+		db: {
+			prepare: noDatabase,
+			batch: noDatabase,
+			exec: noDatabase,
+			dump: noDatabase,
+			withSession: noDatabase
+		},
+		now: TEST_NOW,
+		locale: "es-MX",
+		userId: null,
+		...overrides
+	};
+}
+//#endregion
+//#region src/testing/discount-conformance.ts
+/**
+* The behaviour every {@link DiscountPort} must have, as a test suite. A discount provider's rules are its data, so the suite cannot know which
+* order earns a discount: the caller hands it `scenarios`, inputs that make its rules apply (and `plain`, one that earns nothing), and the suite
+* holds every answer to the contract.
+*
+* What it fixes: amounts are whole minor units in the order's currency and each discount has a title; together they are at most the subtotal and
+* no line is discounted by more than it costs; a discount that names its lines names real ones and they add up to it; every code a buyer typed
+* is answered, as applied or rejected with a reason from the list, and never both; the same input gives the same answer and the input is left as
+* it was. Codes the provider knows are its own tests; this suite asks for one nobody has.
+*/
+/** A deep copy that cannot be edited: a provider that sorts or changes what it was given throws. */
+function frozen$1(value) {
+	const copy = structuredClone(value);
+	const freeze = (item) => {
+		if (typeof item !== "object" || item === null || Object.isFrozen(item)) return;
+		Object.freeze(item);
+		for (const child of Object.values(item)) freeze(child);
+	};
+	freeze(copy);
+	return copy;
+}
+/** A code no provider has, so it is rejected: upper-case letters and digits, as a code is usually written. */
+const NOBODY_HAS_THIS_CODE = "ZZ-NO-SUCH-CODE-0000";
+function runDiscountConformance(make, tools, options) {
+	const { describe, it, expect } = tools;
+	if (options.scenarios.length === 0) throw new Error("runDiscountConformance needs at least one scenario that earns a discount");
+	const contextAt = async (now = TEST_NOW) => options.context ? await options.context(now) : testContext({ now });
+	const apply = async (port, input) => port.apply(await contextAt(), frozen$1(input));
+	const subtotal = (input) => input.lines.reduce((sum, item) => sum + lineTotalMinor(item.unitAmountMinor, item.quantity), 0);
+	describe("DiscountPort conformance", () => {
+		for (const scenario of options.scenarios) {
+			it(`answers whole amounts in the order's currency with a title, never more than the subtotal (${scenario.name})`, async () => {
+				const result = await apply(await make(), scenario.input);
+				let total = 0;
+				for (const discount of result.applied) {
+					expect(isMinorUnits(discount.amountMinor)).toBe(true);
+					expect(isCurrencyCode(discount.currency) && discount.currency === scenario.input.currency).toBe(true);
+					expect(typeof discount.title === "string" && discount.title.length > 0).toBe(true);
+					total += discount.amountMinor;
+				}
+				expect(total <= subtotal(scenario.input)).toBe(true);
+			});
+			it(`names real lines that add up to the discount, none discounted by more than it costs (${scenario.name})`, async () => {
+				const named = (await apply(await make(), scenario.input)).applied.filter((discount) => discount.lines !== void 0);
+				const problems = checkLineDiscounts(scenario.input.lines, named);
+				expect(problems.map((item) => `${item.path}: ${item.message}`)).toEqual([]);
+			});
+			it(`gives the same answer to the same input, and leaves what it was given as it was (${scenario.name})`, async () => {
+				const port = await make();
+				const first = await apply(port, scenario.input);
+				const second = await apply(port, scenario.input);
+				expect(second).toEqual(first);
+			});
+		}
+		it("answers every code a buyer typed once, as applied or rejected with a reason from the list, not both", async () => {
+			const scenario = options.scenarios[0].input;
+			const result = await apply(await make(), {
+				...scenario,
+				codes: [NOBODY_HAS_THIS_CODE, NOBODY_HAS_THIS_CODE]
+			});
+			const rejected = result.rejected.filter((item) => item.code === NOBODY_HAS_THIS_CODE);
+			expect(rejected.length).toBe(1);
+			expect(DISCOUNT_REJECTIONS.includes(rejected[0]?.reason ?? "")).toBe(true);
+			expect(result.applied.some((discount) => discount.code === NOBODY_HAS_THIS_CODE)).toBe(false);
+		});
+		if (options.plain) {
+			const plain = options.plain;
+			it("gives nothing to an order that earns nothing", async () => {
+				const result = await apply(await make(), plain);
+				expect(result.applied).toEqual([]);
+			});
+		}
+	});
+}
+//#endregion
+//#region src/testing/fake-discount.ts
+/**
+* A discount port for tests: `percentBp` off every line of at least `fromQuantity`, with the lines it came off named. It knows no code, so a
+* code a buyer typed is `rejected` as `unknown`. The reference `runDiscountConformance` is written from.
+*/
+function createFlatDiscount(options = {}) {
+	const percentBp = options.percentBp ?? 1e3;
+	const fromQuantity = options.fromQuantity ?? 5;
+	const title = options.title ?? "Volume discount";
+	return { async apply(_ctx, input) {
+		const parts = input.lines.flatMap((line, index) => line.quantity >= fromQuantity ? [{
+			index,
+			amountMinor: basisPointsOf(lineTotalMinor(line.unitAmountMinor, line.quantity), percentBp)
+		}] : []);
+		const amountMinor = parts.reduce((sum, part) => sum + part.amountMinor, 0);
+		return {
+			applied: amountMinor > 0 ? [{
+				title,
+				amountMinor,
+				currency: input.currency,
+				lines: parts
+			}] : [],
+			rejected: [...new Set(input.codes)].map((code) => ({
+				code,
+				reason: "unknown"
+			}))
+		};
+	} };
+}
+//#endregion
+//#region src/testing/fake-tax.ts
+/**
+* A tax port for tests: one rate for everything, worked per line on what is paid (the line after its discount: `lineDiscountsMinor` when it is
+* given, else the discount spread in proportion), shipping taxed on top. A line whose price includes the tax contributes to `includedMinor`
+* (the tax inside the price), the others and the shipping to `addedMinor`. The rate and rounding are the money helpers', so it is also the
+* small reference the conformance suite is written from.
+*/
+function createFlatTax(options = {}) {
+	const rateBp = options.rateBp ?? 1600;
+	const code = options.code ?? "IVA";
+	return { async compute(_ctx, input) {
+		const shares = input.lineDiscountsMinor ?? spreadDiscount(input.lines, input.discountMinor);
+		let added = 0;
+		let included = 0;
+		input.lines.forEach((line, index) => {
+			const paid = lineTotalMinor(line.unitAmountMinor, line.quantity) - (shares[index] ?? 0);
+			if (line.taxIncluded) included += taxIncludedIn(paid, rateBp);
+			else added += basisPointsOf(paid, rateBp);
+		});
+		added += basisPointsOf(input.shippingMinor, rateBp);
+		const title = `${code} ${rateBp / 100}%`;
+		const breakdown = [];
+		if (added > 0) breakdown.push({
+			code,
+			title,
+			rateBp,
+			amountMinor: added,
+			included: false
+		});
+		if (included > 0) breakdown.push({
+			code,
+			title,
+			rateBp,
+			amountMinor: included,
+			included: true
+		});
+		return {
+			currency: input.currency,
+			addedMinor: added,
+			includedMinor: included,
+			breakdown
+		};
+	} };
+}
+//#endregion
+//#region src/testing/line-hold-conformance.ts
+/**
+* The behaviour every line source that holds its own places must have (`hold`, `commit` and `release`, optional on `LineSource` since
+* 0.2.0), as a test suite. Run it against the in-memory slots in Node (`runLineHoldConformance((places) => createMemorySlots(places), { describe,
+* it, expect })`) and against the feature's own source in workerd, with a `make` that writes the places into its tables (a slot of N seats
+* for each ref) and a `context` that carries the project's `env.DB`. Each test makes a source of its own, so `make` must return one with
+* nothing else in it.
+*
+* The rules are the stock port's, by the ask instead of a stock subject (`runStockConformance`): a hold is every ask or none and the same
+* `holdId` is the same hold; the last place goes to exactly one of two buyers; a ref the source does not have is never held; the clock is
+* `ctx.now`; places come back at `expiresAt` by themselves; a payment after that still commits and says it was late (and oversold when the
+* place went meanwhile); `release` after `commit` is refused; `resolve` counts what a hold took. The suite reads the places left from what a
+* hold of more than there is answers (`short[0].available`), and once from `resolve` (`sold_out` when none is left).
+*/
+/** More places than any test makes: a hold of this many is always short, and its answer says how many are left. */
+const PROBE = 1e3;
+function runLineHoldConformance(make, tools, options = {}) {
+	const { describe, it, expect } = tools;
+	const contextAt = async (now) => options.context ? await options.context(now) : testContext({ now });
+	const T0 = TEST_NOW;
+	const TTL = 1e3;
+	let probes = 0;
+	const source = async (places) => {
+		const made = await make(places);
+		if (!holdsCapacity(made)) throw new Error("this source does not hold its own places: runLineHoldConformance is for a source with hold, commit and release");
+		return made;
+	};
+	const ask = (ref, quantity, options) => ({
+		ref,
+		quantity,
+		...options ? { options } : {}
+	});
+	const hold = async (port, holdId, lines, now = T0, ttl = TTL) => port.hold(await contextAt(now), {
+		holdId,
+		lines,
+		expiresAt: now + ttl
+	});
+	const settle = async (port, what, holdId, now = T0) => port[what](await contextAt(now), holdId);
+	/** The places of `ref` left at `now`, from what a hold of more than there is answers. It holds nothing. */
+	const left = async (port, ref, now = T0) => {
+		probes += 1;
+		const probe = await hold(port, `conformance-probe-${probes}`, [ask(ref, PROBE)], now);
+		return probe.ok || probe.code !== "insufficient_stock" ? void 0 : probe.short[0]?.available;
+	};
+	describe("LineSource holds conformance", () => {
+		it("is a source that holds: hold, commit and release are all there", async () => {
+			expect(holdsCapacity(await source({ a: 1 }))).toBe(true);
+		});
+		it("holds places and gives them back on release", async () => {
+			const port = await source({ a: 3 });
+			const held = await hold(port, "h1", [ask("a", 2)]);
+			expect(held.ok && [
+				held.hold.status,
+				held.hold.expiresAt,
+				held.hold.lines
+			]).toEqual([
+				"held",
+				T0 + TTL,
+				[ask("a", 2)]
+			]);
+			expect(await left(port, "a")).toBe(1);
+			const released = await settle(port, "release", "h1");
+			expect(released.ok && [released.changed, released.hold.status]).toEqual([true, "released"]);
+			expect(await left(port, "a")).toBe(3);
+		});
+		it("counts the places a hold took when it resolves, and gives them back", async () => {
+			const port = await source({
+				a: 1,
+				b: 3
+			});
+			const resolved = async (ref) => (await port.resolve(await contextAt(T0), [ask(ref, 1)]))[0];
+			expect((await resolved("a"))?.availability).toBe("available");
+			await hold(port, "h1", [ask("a", 1)]);
+			expect((await resolved("a"))?.availability).toBe("sold_out");
+			await settle(port, "release", "h1");
+			expect((await resolved("a"))?.availability).toBe("available");
+			await hold(port, "h2", [ask("b", 2)]);
+			const one = await resolved("b");
+			expect([one?.availability, typeof one?.maxQuantity === "number" && one.maxQuantity <= 1]).toEqual(["available", true]);
+		});
+		it("treats the same hold id as the same hold, and other asks under it as a conflict", async () => {
+			const port = await source({
+				a: 5,
+				b: 5
+			});
+			expect((await hold(port, "h1", [ask("a", 1)])).ok).toBe(true);
+			expect((await hold(port, "h1", [ask("a", 1)])).ok).toBe(true);
+			expect(await left(port, "a")).toBe(4);
+			for (const lines of [
+				[ask("a", 2)],
+				[ask("b", 1)],
+				[ask("a", 1), ask("b", 1)],
+				[ask("a", 1, { staff: "ana" })]
+			]) expect(await hold(port, "h1", lines)).toEqual({
+				ok: false,
+				code: "hold_conflict"
+			});
+			expect([await left(port, "a"), await left(port, "b")]).toEqual([4, 5]);
+		});
+		it("adds up two asks of one ref before it checks", async () => {
+			const port = await source({ a: 3 });
+			expect(await hold(port, "h1", [ask("a", 2), ask("a", 2)])).toEqual({
+				ok: false,
+				code: "insufficient_stock",
+				short: [{
+					ref: "a",
+					requested: 4,
+					available: 3
+				}]
+			});
+			expect(await left(port, "a")).toBe(3);
+		});
+		it("holds every ask or none: a short ask takes nothing of the others", async () => {
+			const port = await source({
+				a: 1,
+				b: 5
+			});
+			expect(await hold(port, "h1", [ask("b", 2), ask("a", 2)])).toEqual({
+				ok: false,
+				code: "insufficient_stock",
+				short: [{
+					ref: "a",
+					requested: 2,
+					available: 1
+				}]
+			});
+			expect([await left(port, "a"), await left(port, "b")]).toEqual([1, 5]);
+		});
+		it("gives the last place to exactly one of two buyers", async () => {
+			const port = await source({ last: 1 });
+			const results = await Promise.all([hold(port, "buyer-1", [ask("last", 1)]), hold(port, "buyer-2", [ask("last", 1)])]);
+			expect(results.filter((result) => result.ok).length).toBe(1);
+			expect(results.filter((result) => !result.ok && result.code === "insufficient_stock").length).toBe(1);
+			expect(await left(port, "last")).toBe(0);
+		});
+		it("cannot hold a ref it does not have", async () => {
+			const port = await source({ a: 1 });
+			expect(await hold(port, "h1", [ask("nope", 1)])).toEqual({
+				ok: false,
+				code: "insufficient_stock",
+				short: [{
+					ref: "nope",
+					requested: 1,
+					available: 0
+				}]
+			});
+			const both = await hold(port, "h2", [ask("a", 1), ask("nope", 1)]);
+			expect(both.ok === false && both.code).toBe("insufficient_stock");
+			expect(await left(port, "a")).toBe(1);
+		});
+		it("keeps the places sold on commit, and commits once", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			const committed = await settle(port, "commit", "h1");
+			expect(committed.ok && [
+				committed.changed,
+				committed.hold.status,
+				committed.late
+			]).toEqual([
+				true,
+				"committed",
+				void 0
+			]);
+			const again = await settle(port, "commit", "h1");
+			expect(again.ok && again.changed).toBe(false);
+			expect(await left(port, "a")).toBe(1);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(1);
+		});
+		it("refuses to release a hold that was committed", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			await settle(port, "commit", "h1");
+			expect(await settle(port, "release", "h1")).toEqual({
+				ok: false,
+				code: "invalid_state",
+				status: "committed"
+			});
+			expect(await left(port, "a")).toBe(1);
+		});
+		it("releases once, then says nothing changed, and answers a hold it does not know", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			expect((await settle(port, "release", "h1")).ok).toBe(true);
+			const again = await settle(port, "release", "h1");
+			expect(again.ok && again.changed).toBe(false);
+			expect(await settle(port, "commit", "nope")).toEqual({
+				ok: false,
+				code: "unknown_hold"
+			});
+			expect(await settle(port, "release", "nope")).toEqual({
+				ok: false,
+				code: "unknown_hold"
+			});
+			expect(await left(port, "a")).toBe(3);
+		});
+		it("gives the places back by themselves at expiresAt, by the context's clock", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			expect(await left(port, "a", T0 + TTL - 1)).toBe(1);
+			expect(await left(port, "a", T0 + TTL)).toBe(3);
+		});
+		it("commits a payment that arrives after the hold ran out, takes the places again and says it was late", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			const late = await settle(port, "commit", "h1", T0 + 2 * TTL);
+			expect(late.ok && [
+				late.changed,
+				late.late,
+				late.oversold
+			]).toEqual([
+				true,
+				true,
+				void 0
+			]);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(1);
+		});
+		it("leaves a hold that ran out expired, not released, when it is released late", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			const result = await settle(port, "release", "h1", T0 + 2 * TTL);
+			expect(result.ok && [result.changed, result.hold.status]).toEqual([false, "expired"]);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(3);
+		});
+		it("does not call a late commit oversold when it takes the places exactly to none", async () => {
+			const port = await source({ a: 2 });
+			await hold(port, "h1", [ask("a", 2)]);
+			const late = await settle(port, "commit", "h1", T0 + 2 * TTL);
+			expect(late.ok && [late.late, late.oversold]).toEqual([true, void 0]);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(0);
+		});
+		it("flags a late commit that finds the places gone", async () => {
+			const port = await source({ a: 2 });
+			await hold(port, "h1", [ask("a", 2)]);
+			expect((await hold(port, "h2", [ask("a", 2)], T0 + 2 * TTL)).ok).toBe(true);
+			const late = await settle(port, "commit", "h1", T0 + 2 * TTL);
+			expect(late.ok && [late.late, late.oversold]).toEqual([true, true]);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(0);
+		});
+		it("answers hold_closed for a hold id whose hold is over, after a release, an expiry or a commit", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "released", [ask("a", 1)]);
+			await settle(port, "release", "released");
+			expect(await hold(port, "released", [ask("a", 1)])).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "released"
+			});
+			await hold(port, "expired", [ask("a", 1)]);
+			expect(await hold(port, "expired", [ask("a", 1)], T0 + 2 * TTL)).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "expired"
+			});
+			await hold(port, "committed", [ask("a", 1)], T0 + 3 * TTL);
+			await settle(port, "commit", "committed", T0 + 3 * TTL);
+			expect(await hold(port, "committed", [ask("a", 1)], T0 + 3 * TTL)).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "committed"
+			});
+			expect(await left(port, "a", T0 + 3 * TTL)).toBe(2);
+		});
+		it("extends a live hold when it is asked again with a later time, and never shortens it", async () => {
+			const port = await source({ a: 3 });
+			await hold(port, "h1", [ask("a", 2)]);
+			const longer = await hold(port, "h1", [ask("a", 2)], T0, 5 * TTL);
+			expect(longer.ok && longer.hold.expiresAt).toBe(T0 + 5 * TTL);
+			const shorter = await hold(port, "h1", [ask("a", 2)], T0, TTL / 10);
+			expect(shorter.ok && shorter.hold.expiresAt).toBe(T0 + 5 * TTL);
+			expect(await left(port, "a", T0 + 4 * TTL)).toBe(1);
+			expect(await left(port, "a", T0 + 5 * TTL)).toBe(3);
+		});
+		it("holds for at most 14 days", async () => {
+			const port = await source({ a: 3 });
+			expect((await hold(port, "ok", [ask("a", 1)], T0, MAX_HOLD_MS)).ok).toBe(true);
+			const past = await hold(port, "late", [ask("a", 1)], T0, MAX_HOLD_MS + 1);
+			expect(past.ok === false && past.code).toBe("invalid_request");
+			expect(await left(port, "a")).toBe(2);
+		});
+		it("refuses a request that is not valid and takes nothing", async () => {
+			const port = await source({ a: 3 });
+			const ctx = await contextAt(T0);
+			const bad = [
+				{
+					holdId: "",
+					lines: [ask("a", 1)],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [ask("a", 0)],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [ask("a", 1.5)],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [ask("a", 1)],
+					expiresAt: T0
+				}
+			];
+			for (const request of bad) {
+				const result = await port.hold(ctx, request);
+				expect(result.ok === false && result.code).toBe("invalid_request");
+			}
+			expect(await left(port, "a")).toBe(3);
+		});
+	});
+}
+//#endregion
+//#region src/testing/line-source.ts
+const HARNESS_CHECKS = [
+	"empty",
+	"shape",
+	"order",
+	"unknown",
+	"unavailable",
+	"server-prices",
+	"no-mutation",
+	"repeatable",
+	"duplicates",
+	"buyer-price",
+	"holds"
+];
+/** Refs a hostile buyer sends. A source answers each with a `not_found` line, whatever it does with a ref. */
+const HOSTILE_REFS = [
+	"' OR 1=1 --",
+	"__proto__",
+	"constructor",
+	"toString",
+	"../../etc/passwd",
+	"%00%0a",
+	"ñandú 🌮",
+	"x".repeat(120)
+];
+/**
+* The option names the harness tries as a browser's own price. A source may not read a price from any of them (except the one `buyerPrice`
+* declares); add the names your source reads for other things with `extraPriceOptions`.
+*/
+const PRICE_OPTION_NAMES = [
+	"price",
+	"amount",
+	"unitAmountMinor",
+	"unit_price",
+	"total",
+	"currency",
+	"discount"
+];
+const PRICE_OPTIONS = {
+	price: "1",
+	amount: "1",
+	unitAmountMinor: "1",
+	unit_price: "1",
+	total: "1",
+	currency: "USD",
+	discount: "100"
+};
+const asks = (...items) => items.map(([ref, quantity, options]) => ({
+	ref,
+	quantity,
+	...options ? { options } : {}
+}));
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const item of Object.values(value)) deepFreeze(item);
+	}
+	return value;
+}
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+async function resolveOnce(source, ctx, given) {
+	try {
+		return {
+			ok: true,
+			lines: await source.resolve(ctx, deepFreeze(structuredClone(given)))
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+		};
+	}
+}
+/** Runs the checks and returns what failed; an empty list is a source a checkout can rely on. */
+async function checkLineSource(source, fixtures, only) {
+	const ctx = fixtures.ctx ?? testContext();
+	const findings = [];
+	const want = (check) => !only || only.includes(check);
+	const fail = (check, message, problems) => findings.push({
+		check,
+		message,
+		...problems ? { problems } : {}
+	});
+	/** Resolves, and reports a throw or a malformed answer under `check`. */
+	const resolve = async (check, label, given) => {
+		const result = await resolveOnce(source, ctx, given);
+		if (!result.ok) {
+			fail(check, `${label}: the source threw ${result.error}`);
+			return;
+		}
+		const problems = checkResolvedLines(given, result.lines);
+		if (problems.length > 0) {
+			fail(check, `${label}: the answer is not valid`, problems);
+			return;
+		}
+		return result.lines;
+	};
+	if (fixtures.known.length === 0) {
+		fail("shape", "fixtures.known is empty: name at least one ref the source can sell");
+		return findings;
+	}
+	const first = fixtures.known[0];
+	if (want("empty")) {
+		const result = await resolveOnce(source, ctx, []);
+		if (!result.ok) fail("empty", `no asks: the source threw ${result.error}`);
+		else if (!Array.isArray(result.lines) || result.lines.length !== 0) fail("empty", "no asks: the source must answer with an empty list");
+	}
+	if (want("shape")) for (const known of fixtures.known) for (const quantity of [
+		1,
+		3,
+		99
+	]) {
+		const label = `${known.ref} x${quantity}`;
+		const line = (await resolve("shape", label, asks([
+			known.ref,
+			quantity,
+			known.options
+		])))?.[0];
+		if (!line) continue;
+		if (line.availability !== "available") fail("shape", `${label}: a known ref must be available, got ${line.availability}`);
+		if (known.unitAmountMinor !== void 0 && line.unitAmountMinor !== known.unitAmountMinor) fail("shape", `${label}: the price is ${line.unitAmountMinor}, expected ${known.unitAmountMinor}`);
+		if (known.currency !== void 0 && line.currency !== known.currency) fail("shape", `${label}: the currency is ${line.currency}, expected ${known.currency}`);
+	}
+	if (want("order")) {
+		const given = asks(...fixtures.known.map((known, index) => [
+			known.ref,
+			index + 1,
+			known.options
+		]));
+		given.push(...asks([fixtures.missingRef ?? "no-such-thing-here", 2]));
+		const batch = await resolve("order", "a batch", given);
+		const reversed = await resolve("order", "the same batch reversed", [...given].reverse());
+		if (batch && reversed && !same([...batch].reverse(), reversed)) fail("order", "the same asks in another order give different lines: lines must follow the asks one to one");
+		if (batch) for (const [index, ask] of given.entries()) {
+			const alone = await resolve("order", `${ask.ref} alone`, [ask]);
+			if (alone && !same(alone[0], batch[index])) fail("order", `${ask.ref} is priced differently alone and in a batch`);
+		}
+	}
+	if (want("unknown")) {
+		const refs = [fixtures.missingRef ?? "no-such-thing-here", ...HOSTILE_REFS];
+		for (const ref of refs) {
+			const line = (await resolve("unknown", `ref ${JSON.stringify(ref.length > 30 ? `${ref.slice(0, 27)}...` : ref)}`, asks([ref, 1])))?.[0];
+			if (line && line.availability !== "not_found") fail("unknown", `ref ${JSON.stringify(ref.slice(0, 30))} does not exist but came back ${line.availability}`);
+		}
+	}
+	if (want("unavailable")) for (const item of fixtures.unavailable ?? []) {
+		const line = (await resolve("unavailable", item.ref, asks([item.ref, 1])))?.[0];
+		if (line && line.availability !== item.availability) fail("unavailable", `${item.ref} must be ${item.availability}, got ${line.availability}`);
+	}
+	if (want("server-prices")) for (const known of fixtures.known) {
+		const plain = await resolve("server-prices", known.ref, asks([
+			known.ref,
+			1,
+			known.options
+		]));
+		const names = [...Object.entries(PRICE_OPTIONS), ...(fixtures.extraPriceOptions ?? []).map((name) => [name, "1"])].filter(([name]) => !(fixtures.buyerPrice?.ref === known.ref && fixtures.buyerPrice.option === name));
+		const hostile = await resolve("server-prices", `${known.ref} with a price in its options`, asks([
+			known.ref,
+			1,
+			{
+				...known.options,
+				...Object.fromEntries(names)
+			}
+		]));
+		const a = plain?.[0];
+		const b = hostile?.[0];
+		if (a && b && (a.unitAmountMinor !== b.unitAmountMinor || a.currency !== b.currency)) fail("server-prices", `${known.ref}: options the buyer sent changed the price (${a.unitAmountMinor} ${a.currency} became ${b.unitAmountMinor} ${b.currency}): a price is the source's alone`);
+	}
+	if (want("no-mutation")) {
+		const result = await resolveOnce(source, ctx, asks([
+			first.ref,
+			2,
+			first.options
+		], [fixtures.missingRef ?? "no-such-thing-here", 1]));
+		if (!result.ok) fail("no-mutation", `the source cannot be given read-only asks (does it sort or edit them in place?): ${result.error}`);
+	}
+	if (want("repeatable")) {
+		const given = asks([
+			first.ref,
+			2,
+			first.options
+		]);
+		const one = await resolve("repeatable", "the first call", given);
+		const two = await resolve("repeatable", "the second call", given);
+		if (one && two && !same(one, two)) fail("repeatable", "the same ask twice gives different lines (a price must come from data, not from the clock or a counter)");
+	}
+	if (want("duplicates")) await resolve("duplicates", "the same ref twice", asks([
+		first.ref,
+		1,
+		first.options
+	], [
+		first.ref,
+		2,
+		first.options
+	]));
+	if (want("holds")) {
+		const methods = [
+			"hold",
+			"commit",
+			"release"
+		].filter((method) => source[method] !== void 0);
+		const functions = methods.filter((method) => typeof source[method] === "function");
+		if (methods.length > 0 && (methods.length < 3 || functions.length < 3)) fail("holds", `the source has ${methods.join(", ")}: a source that holds its own places has hold, commit and release, all functions (run runLineHoldConformance on it), or none`);
+	}
+	if (want("buyer-price") && fixtures.buyerPrice) {
+		const { ref, option, min, max } = fixtures.buyerPrice;
+		const base = fixtures.known.find((known) => known.ref === ref);
+		if (!base) fail("buyer-price", `buyerPrice.ref ${ref} is not in fixtures.known`);
+		else {
+			const priced = async (value) => (await resolve("buyer-price", `${ref} at ${JSON.stringify(value)}`, asks([
+				ref,
+				1,
+				{
+					...base.options,
+					[option]: value
+				}
+			])))?.[0];
+			for (const amount of [
+				min,
+				Math.floor((min + max) / 2),
+				max
+			]) {
+				const line = await priced(String(amount));
+				if (line && (line.availability !== "available" || line.unitAmountMinor !== amount)) fail("buyer-price", `an amount of ${amount} inside ${min} to ${max} must be priced as ${amount} and available, got ${line.availability} at ${line.unitAmountMinor}`);
+				else if (line && amount === max && line.maxQuantity !== 1) fail("buyer-price", `a line the buyer prices must have maxQuantity 1, or a quantity multiplies the amount past ${max}; got ${line.maxQuantity}`);
+			}
+			const refused = [
+				String(max + 1),
+				"12.5",
+				"1e3",
+				"-5",
+				"0x10",
+				"",
+				" 100",
+				"100 ",
+				"abc",
+				"٣٠٠",
+				"9".repeat(30),
+				"+100",
+				"1_000",
+				"NaN",
+				"Infinity"
+			];
+			refused.push(String(min - 1));
+			for (const value of refused) {
+				const line = await priced(value);
+				if (line?.availability === "available") fail("buyer-price", `${JSON.stringify(value)} is not a whole amount inside ${min} to ${max} but the line is available at ${line.unitAmountMinor}`);
+			}
+		}
+	}
+	return findings;
+}
+const WHAT = {
+	empty: "answers no asks with no lines",
+	shape: "answers a known ref with a valid, available line at the server's price",
+	order: "returns one line per ask, in the order asked, whatever else is in the batch",
+	unknown: "answers a ref that does not exist, or a hostile one, with a not_found line and no exception",
+	unavailable: "reports a sold out or not orderable item as such",
+	"server-prices": "ignores a price the buyer put in the options",
+	"no-mutation": "leaves the asks it was given alone",
+	repeatable: "gives the same line for the same ask",
+	duplicates: "keeps two asks for one ref as two lines",
+	"buyer-price": "prices the amount a buyer chooses only when it is a whole number inside the bounds",
+	holds: "holds its own places with hold, commit and release together, or not at all"
+};
+/** The checks as a test suite: one `it` for each, failing with the findings. Run it in the feature's own tests, in workerd for a source that reads D1. */
+function runLineSourceConformance(source, fixtures, tools) {
+	const { describe, it, expect } = tools;
+	describe("line source conformance", () => {
+		for (const check of HARNESS_CHECKS) {
+			if (check === "buyer-price" && !fixtures.buyerPrice) continue;
+			it(WHAT[check], async () => {
+				expect(await checkLineSource(source, fixtures, [check])).toEqual([]);
+			});
+		}
+	});
+}
+//#endregion
+//#region src/testing/payments.ts
+/**
+* A payments port for tests: it checks each request the way a real one must (`checkStartPayment`), answers a payment id and a redirect URL,
+* and is idempotent by `reference` (the same request again is the same payment; a different one under the same reference is refused). It
+* cancels a payment that is not paid, once, and then refuses to start its reference again; `markPaid` stands in for the provider's event.
+*/
+function createFakePayments() {
+	const accepted = /* @__PURE__ */ new Map();
+	const started = [];
+	const cancelled = [];
+	let failure;
+	return {
+		started,
+		cancelled,
+		failNext(next) {
+			failure = next;
+		},
+		markPaid(reference) {
+			const payment = accepted.get(reference);
+			if (!payment) throw new Error(`markPaid: no payment was ever started for ${reference}`);
+			payment.state = "paid";
+		},
+		async start(_ctx, input) {
+			if (failure) {
+				const next = failure;
+				failure = void 0;
+				return next;
+			}
+			const problems = checkStartPayment(input);
+			if (problems.length > 0) return {
+				ok: false,
+				code: "invalid_request",
+				message: problems.map((item) => `${item.path}: ${item.message}`).join("; ")
+			};
+			const key = JSON.stringify(input);
+			const seen = accepted.get(input.reference);
+			if (seen) {
+				if (seen.state === "cancelled") return {
+					ok: false,
+					code: "invalid_request",
+					message: "reference: the payment for this reference was cancelled"
+				};
+				if (seen.state === "paid") return {
+					ok: false,
+					code: "invalid_request",
+					message: "reference: this reference has already been paid"
+				};
+				return seen.input === key ? seen.result : {
+					ok: false,
+					code: "invalid_request",
+					message: "reference: this reference was already used for a different payment"
+				};
+			}
+			const paymentId = `pay_fake_${accepted.size + 1}`;
+			const result = {
+				ok: true,
+				paymentId,
+				redirectUrl: `https://pay.example.test/${paymentId}`,
+				...input.expiresAt === void 0 ? {} : { expiresAt: input.expiresAt }
+			};
+			accepted.set(input.reference, {
+				input: key,
+				result,
+				state: "open"
+			});
+			started.push(input);
+			return result;
+		},
+		async cancel(_ctx, reference) {
+			const payment = accepted.get(reference);
+			if (!payment) return {
+				ok: false,
+				code: "unknown_payment",
+				message: "no payment was started for this reference"
+			};
+			if (payment.state === "paid") return {
+				ok: false,
+				code: "already_paid",
+				message: "this payment was paid: refund it instead"
+			};
+			if (payment.state === "cancelled") return {
+				ok: true,
+				changed: false
+			};
+			payment.state = "cancelled";
+			cancelled.push(reference);
+			return {
+				ok: true,
+				changed: true
+			};
+		}
+	};
+}
+//#endregion
+//#region src/testing/payments-conformance.ts
+const SHIPPING = {
+	kind: "shipping",
+	title: "Envío",
+	amountMinor: 9900,
+	currency: "MXN"
+};
+const TAX = {
+	kind: "tax",
+	title: "IVA",
+	amountMinor: 4800,
+	currency: "MXN"
+};
+const discount = (amountMinor) => ({
+	kind: "discount",
+	title: "Promo",
+	amountMinor,
+	currency: "MXN"
+});
+/** Two of a thing at 150.00 and shipping of 99.00: 399.00. */
+const request = (reference, patch = {}) => ({
+	reference,
+	lines: [{
+		ref: "conformance-item",
+		title: "Conformance item",
+		quantity: 2,
+		unitAmountMinor: 15e3,
+		currency: "MXN"
+	}],
+	adjustments: [SHIPPING],
+	totalMinor: 39900,
+	currency: "MXN",
+	successUrl: "https://shop.example/orders/ok",
+	cancelUrl: "https://shop.example/orders/cancel",
+	...patch
+});
+const isPage = (value) => {
+	if (typeof value !== "string") return false;
+	try {
+		return ["https:", "http:"].includes(new URL(value).protocol);
+	} catch {
+		return false;
+	}
+};
+function runPaymentsConformance(make, tools, options = {}) {
+	const { describe, it, expect } = tools;
+	const contextAt = async (now = TEST_NOW) => options.context ? await options.context(now) : testContext({ now });
+	let made = 0;
+	const reference = () => `${options.referencePrefix ?? "conformance"}-${++made}`;
+	const start = async (port, input) => port.start(await contextAt(), input);
+	const codeOf = (result) => result.ok ? "ok" : result.code;
+	describe("PaymentsPort conformance", () => {
+		it("starts a payment and answers its id and the page to send the payer to", async () => {
+			const result = await start(await make(), request(reference()));
+			expect(result.ok).toBe(true);
+			expect(result.ok && typeof result.paymentId === "string" && result.paymentId.length > 0).toBe(true);
+			expect(result.ok && isPage(result.redirectUrl)).toBe(true);
+		});
+		it("is the same payment when the same reference is started again", async () => {
+			const port = await make();
+			const ref = reference();
+			const first = await start(port, request(ref));
+			const again = await start(port, request(ref));
+			expect(again.ok && first.ok && [again.paymentId, again.redirectUrl]).toEqual(first.ok && [first.paymentId, first.redirectUrl]);
+		});
+		it("refuses another amount under a reference it has started", async () => {
+			const port = await make();
+			const ref = reference();
+			expect(codeOf(await start(port, request(ref)))).toBe("ok");
+			const cheaper = request(ref, {
+				lines: [{
+					ref: "conformance-item",
+					title: "Conformance item",
+					quantity: 1,
+					unitAmountMinor: 15e3,
+					currency: "MXN"
+				}],
+				totalMinor: 24900
+			});
+			expect(codeOf(await start(port, cheaper))).toBe("invalid_request");
+		});
+		it("refuses a request whose lines and adjustments do not add up to the total", async () => {
+			const port = await make();
+			expect(codeOf(await start(port, request(reference(), { totalMinor: 39899 })))).toBe("invalid_request");
+			expect(codeOf(await start(port, request(reference(), { adjustments: [SHIPPING, TAX] })))).toBe("invalid_request");
+		});
+		it("refuses a discount larger than the items, even when the shipping and the tax would pay for it", async () => {
+			const port = await make();
+			const over = request(reference(), {
+				adjustments: [
+					SHIPPING,
+					TAX,
+					discount(30001)
+				],
+				totalMinor: 14699
+			});
+			expect(codeOf(await start(port, over))).toBe("invalid_request");
+			const whole = request(reference(), {
+				adjustments: [
+					SHIPPING,
+					TAX,
+					discount(3e4)
+				],
+				totalMinor: 14700
+			});
+			expect(codeOf(await start(port, whole))).toBe("ok");
+		});
+		it("refuses a total of zero: a free order is paid without a provider", async () => {
+			const port = await make();
+			const free = request(reference(), {
+				adjustments: [discount(3e4)],
+				totalMinor: 0
+			});
+			expect(codeOf(await start(port, free))).toBe("invalid_request");
+		});
+		it("refuses a request that is not valid: no lines, a return address that is not https", async () => {
+			const port = await make();
+			expect(codeOf(await start(port, request(reference(), { lines: [] })))).toBe("invalid_request");
+			expect(codeOf(await start(port, request(reference(), { successUrl: "http://shop.example/ok" })))).toBe("invalid_request");
+		});
+		if (options.skipCancel) return;
+		const cancelOf = async (port, ref) => {
+			if (typeof port.cancel !== "function") throw new Error("this provider has no cancel: pass { skipCancel: true } to runPaymentsConformance when it cannot stop a payment");
+			return port.cancel(await contextAt(), ref);
+		};
+		it("cancels a payment once: a second call says nothing changed", async () => {
+			const port = await make();
+			const ref = reference();
+			await start(port, request(ref));
+			expect(await cancelOf(port, ref)).toEqual({
+				ok: true,
+				changed: true
+			});
+			expect(await cancelOf(port, ref)).toEqual({
+				ok: true,
+				changed: false
+			});
+		});
+		it("refuses to start a cancelled reference again", async () => {
+			const port = await make();
+			const ref = reference();
+			await start(port, request(ref));
+			await cancelOf(port, ref);
+			expect(codeOf(await start(port, request(ref)))).toBe("invalid_request");
+		});
+		it("cancels only the payment it is asked to: another one stays payable", async () => {
+			const port = await make();
+			const [one, other] = [reference(), reference()];
+			const first = await start(port, request(other));
+			await start(port, request(one));
+			await cancelOf(port, one);
+			const again = await start(port, request(other));
+			expect(again.ok && first.ok && again.paymentId).toBe(first.ok && first.paymentId);
+		});
+		it("answers unknown_payment for a reference it never started", async () => {
+			const port = await make();
+			const result = await cancelOf(port, reference());
+			expect(result.ok === false && result.code).toBe("unknown_payment");
+		});
+	});
+}
+//#endregion
+//#region src/testing/stock.ts
+/**
+* A stock port that lives in memory, with the semantics the contract fixes: a hold is atomic (every line or none) and idempotent by
+* `holdId`, the last unit goes to one buyer, a hold that is not committed by `expiresAt` frees its units by itself, and a payment that comes
+* after that still commits (the money is in) and says it was late; a committed hold is fulfilled once, when its units leave, or uncommitted
+* once, when the sale is undone before they do. It is the
+* double a checkout is tested against, and the reference `runStockConformance` is written from. The inventory feature's D1 implementation
+* passes the same suite.
+*/
+const subjectKey = (subject) => `${subject.subjectType}:${subject.subjectId}`;
+const available = (state) => Math.max(0, state.onHand - state.reserved - state.committed);
+function createMemoryStock(seed = {}) {
+	const items = new Map(Object.entries(seed));
+	const counts = /* @__PURE__ */ new Map();
+	for (const [key, item] of items) if (item.tracking === "count") counts.set(key, {
+		onHand: item.onHand,
+		reserved: 0,
+		committed: 0,
+		allowOversell: item.allowOversell ?? false
+	});
+	const holds = /* @__PURE__ */ new Map();
+	const view = (hold) => ({
+		holdId: hold.holdId,
+		status: hold.status,
+		expiresAt: hold.expiresAt,
+		lines: hold.lines.map((line) => ({
+			...line,
+			subject: { ...line.subject }
+		})),
+		...hold.fulfilledAt === void 0 ? {} : { fulfilledAt: hold.fulfilledAt }
+	});
+	/** Frees the units of every hold whose time has come, the way the inventory feature's minute sweep does. */
+	const sweep = (now) => {
+		for (const hold of holds.values()) {
+			if (hold.status !== "held" || hold.expiresAt > now) continue;
+			hold.status = "expired";
+			for (const line of hold.lines) {
+				const state = counts.get(subjectKey(line.subject));
+				if (state) state.reserved -= line.quantity;
+			}
+		}
+	};
+	const level = (subject, now) => {
+		const key = subjectKey(subject);
+		const item = items.get(key) ?? { tracking: "none" };
+		if (item.tracking === "none") return {
+			subject,
+			tracking: "none",
+			inStock: true,
+			available: null
+		};
+		if (item.tracking === "toggle") return item.out === true && !(typeof item.outUntil === "number" && item.outUntil <= now) ? {
+			subject,
+			tracking: "toggle",
+			inStock: false,
+			available: 0,
+			outUntil: item.outUntil ?? null
+		} : {
+			subject,
+			tracking: "toggle",
+			inStock: true,
+			available: null
+		};
+		const state = counts.get(key);
+		const left = available(state);
+		return {
+			subject,
+			tracking: "count",
+			inStock: state.allowOversell || left > 0,
+			available: left
+		};
+	};
+	const merge = (lines) => {
+		const merged = /* @__PURE__ */ new Map();
+		for (const line of lines) {
+			const key = subjectKey(line.subject);
+			const seen = merged.get(key);
+			if (seen) seen.quantity += line.quantity;
+			else merged.set(key, {
+				subject: {
+					subjectType: line.subject.subjectType,
+					subjectId: line.subject.subjectId
+				},
+				quantity: line.quantity
+			});
+		}
+		return [...merged.values()];
+	};
+	const sameLines = (a, b) => {
+		if (a.length !== b.length) return false;
+		const wanted = new Map(b.map((line) => [subjectKey(line.subject), line.quantity]));
+		return a.every((line) => wanted.get(subjectKey(line.subject)) === line.quantity);
+	};
+	const validRequest = (request, now) => {
+		if (typeof request?.holdId !== "string" || request.holdId === "") return "holdId is required";
+		if (!Array.isArray(request.lines) || request.lines.length === 0) return "a hold has at least one line";
+		for (const line of request.lines) {
+			if (typeof line?.subject?.subjectType !== "string" || !SUBJECT_TYPE$1.test(line.subject.subjectType) || typeof line.subject.subjectId !== "string" || line.subject.subjectId === "") return "every line names a subject: a dotted lowercase type (catalog.variant) and an id";
+			if (!Number.isSafeInteger(line.quantity) || line.quantity < 1) return "every quantity is a whole number of at least 1";
+		}
+		if (!Number.isSafeInteger(request.expiresAt) || request.expiresAt <= now) return "expiresAt is a time in the future";
+		if (request.expiresAt - now > 12096e5) return "expiresAt is more than 14 days away: is it in milliseconds?";
+	};
+	return {
+		async availability(ctx, subjects) {
+			sweep(ctx.now);
+			return subjects.map((subject) => level(subject, ctx.now));
+		},
+		async hold(ctx, request) {
+			sweep(ctx.now);
+			const invalid = validRequest(request, ctx.now);
+			if (invalid) return {
+				ok: false,
+				code: "invalid_request",
+				message: invalid
+			};
+			const lines = merge(request.lines);
+			const existing = holds.get(request.holdId);
+			if (existing) {
+				if (!sameLines(existing.lines, lines)) return {
+					ok: false,
+					code: "hold_conflict"
+				};
+				if (existing.status !== "held") return {
+					ok: false,
+					code: "hold_closed",
+					status: existing.status
+				};
+				existing.expiresAt = Math.max(existing.expiresAt, request.expiresAt);
+				return {
+					ok: true,
+					hold: view(existing)
+				};
+			}
+			const short = [];
+			for (const line of lines) {
+				const current = level(line.subject, ctx.now);
+				const state = counts.get(subjectKey(line.subject));
+				if (current.tracking === "count" && state && !state.allowOversell && available(state) < line.quantity) short.push({
+					subject: line.subject,
+					requested: line.quantity,
+					available: available(state)
+				});
+				else if (current.tracking === "toggle" && !current.inStock) short.push({
+					subject: line.subject,
+					requested: line.quantity,
+					available: 0
+				});
+			}
+			if (short.length > 0) return {
+				ok: false,
+				code: "insufficient_stock",
+				short
+			};
+			for (const line of lines) {
+				const state = counts.get(subjectKey(line.subject));
+				if (state) state.reserved += line.quantity;
+			}
+			const hold = {
+				holdId: request.holdId,
+				status: "held",
+				expiresAt: request.expiresAt,
+				lines
+			};
+			holds.set(hold.holdId, hold);
+			return {
+				ok: true,
+				hold: view(hold)
+			};
+		},
+		async commit(ctx, holdId) {
+			sweep(ctx.now);
+			const hold = holds.get(holdId);
+			if (!hold) return {
+				ok: false,
+				code: "unknown_hold"
+			};
+			if (hold.status === "committed") return {
+				ok: true,
+				hold: view(hold),
+				changed: false
+			};
+			const late = hold.status !== "held";
+			let oversold = false;
+			for (const line of hold.lines) {
+				const state = counts.get(subjectKey(line.subject));
+				if (!state) continue;
+				if (!late) state.reserved -= line.quantity;
+				state.committed += line.quantity;
+				if (state.onHand - state.reserved - state.committed < 0 && !state.allowOversell) oversold = true;
+			}
+			hold.status = "committed";
+			return {
+				ok: true,
+				hold: view(hold),
+				changed: true,
+				...late ? { late: true } : {},
+				...oversold ? { oversold: true } : {}
+			};
+		},
+		async release(ctx, holdId) {
+			sweep(ctx.now);
+			const hold = holds.get(holdId);
+			if (!hold) return {
+				ok: false,
+				code: "unknown_hold"
+			};
+			if (hold.status === "committed") return {
+				ok: false,
+				code: "invalid_state",
+				status: "committed"
+			};
+			if (hold.status !== "held") return {
+				ok: true,
+				hold: view(hold),
+				changed: false
+			};
+			hold.status = "released";
+			for (const line of hold.lines) {
+				const state = counts.get(subjectKey(line.subject));
+				if (state) state.reserved -= line.quantity;
+			}
+			return {
+				ok: true,
+				hold: view(hold),
+				changed: true
+			};
+		},
+		async fulfil(ctx, holdId) {
+			sweep(ctx.now);
+			const hold = holds.get(holdId);
+			if (!hold) return {
+				ok: false,
+				code: "unknown_hold"
+			};
+			if (hold.status !== "committed") return {
+				ok: false,
+				code: "invalid_state",
+				status: hold.status
+			};
+			if (hold.fulfilledAt !== void 0) return {
+				ok: true,
+				hold: view(hold),
+				changed: false
+			};
+			for (const line of hold.lines) {
+				const state = counts.get(subjectKey(line.subject));
+				if (!state) continue;
+				state.committed -= line.quantity;
+				state.onHand -= line.quantity;
+			}
+			hold.fulfilledAt = ctx.now;
+			return {
+				ok: true,
+				hold: view(hold),
+				changed: true
+			};
+		},
+		async uncommit(ctx, holdId) {
+			sweep(ctx.now);
+			const hold = holds.get(holdId);
+			if (!hold) return {
+				ok: false,
+				code: "unknown_hold"
+			};
+			if (hold.status === "released" || hold.status === "expired") return {
+				ok: true,
+				hold: view(hold),
+				changed: false
+			};
+			if (hold.status !== "committed" || hold.fulfilledAt !== void 0) return {
+				ok: false,
+				code: "invalid_state",
+				status: hold.status
+			};
+			for (const line of hold.lines) {
+				const state = counts.get(subjectKey(line.subject));
+				if (state) state.committed -= line.quantity;
+			}
+			hold.status = "released";
+			return {
+				ok: true,
+				hold: view(hold),
+				changed: true
+			};
+		},
+		counts() {
+			return Object.fromEntries([...counts].map(([key, state]) => [key, {
+				onHand: state.onHand,
+				reserved: state.reserved,
+				committed: state.committed,
+				available: available(state)
+			}]));
+		}
+	};
+}
+//#endregion
+//#region src/testing/slots.ts
+/**
+* A line source with places of its own (a booking slot and its seats), in memory: the reference `runLineHoldConformance` is written
+* from, and the double a checkout tests its handling of such a source against. Its holds are the in-memory stock's (`createMemoryStock`),
+* one counted subject per ref, so the two doubles keep the same rules; what it adds is the line source around them: a price, the places
+* left in `resolve`, and holds made of asks.
+*/
+const SUBJECT_TYPE = "memory.slot";
+const subject$1 = (ref) => ({
+	subjectType: SUBJECT_TYPE,
+	subjectId: ref
+});
+/** Asks with the same ref and options are one, their quantities added; the order of first appearance is kept. */
+function merged(asks) {
+	const out = /* @__PURE__ */ new Map();
+	for (const ask of asks) {
+		const options = ask.options ? Object.fromEntries(Object.entries(ask.options).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : void 0;
+		const key = JSON.stringify([ask.ref, options ?? null]);
+		const seen = out.get(key);
+		if (seen) seen.quantity += ask.quantity;
+		else out.set(key, {
+			ref: ask.ref,
+			quantity: ask.quantity,
+			...options ? { options } : {}
+		});
+	}
+	return [...out.values()];
+}
+const sameAsks = (a, b) => JSON.stringify([...a].map((ask) => JSON.stringify(ask)).sort()) === JSON.stringify([...b].map((ask) => JSON.stringify(ask)).sort());
+const copy = (asks) => asks.map((ask) => ({
+	...ask,
+	...ask.options ? { options: { ...ask.options } } : {}
+}));
+const validAsk = (ask) => isRecord(ask) && typeof ask.ref === "string" && ask.ref !== "" && typeof ask.quantity === "number" && Number.isSafeInteger(ask.quantity) && ask.quantity >= 1 && (ask.options === void 0 || isRecord(ask.options) && Object.values(ask.options).every((value) => typeof value === "string"));
+function createMemorySlots(places, options = {}) {
+	const priceMinor = options.unitAmountMinor ?? 1e4;
+	const stock = createMemoryStock(Object.fromEntries(Object.entries(places).map(([ref, count]) => [subjectKey(subject$1(ref)), {
+		tracking: "count",
+		onHand: count
+	}])));
+	const known = (ref) => Object.hasOwn(places, ref);
+	/** The asks each hold was made of, by hold id: the stock keeps the places, this keeps what the buyer asked for. */
+	const asksOf = /* @__PURE__ */ new Map();
+	const view = (hold) => ({
+		holdId: hold.holdId,
+		status: hold.status,
+		expiresAt: hold.expiresAt,
+		lines: copy(asksOf.get(hold.holdId) ?? [])
+	});
+	const settled = (result) => result.ok ? {
+		...result,
+		hold: view(result.hold)
+	} : result;
+	return {
+		async resolve(ctx, asks) {
+			const levels = await stock.availability(ctx, asks.filter((ask) => known(ask.ref)).map((ask) => subject$1(ask.ref)));
+			const left = new Map(levels.map((level) => [level.subject.subjectId, level.available ?? 0]));
+			return asks.map((ask) => {
+				if (!known(ask.ref)) return {
+					ref: ask.ref,
+					title: ask.ref,
+					quantity: ask.quantity,
+					unitAmountMinor: 0,
+					currency: "MXN",
+					availability: "not_found",
+					taxIncluded: true,
+					fulfilment: "service",
+					snapshot: {}
+				};
+				const free = left.get(ask.ref) ?? 0;
+				return {
+					ref: ask.ref,
+					title: ask.ref,
+					quantity: ask.quantity,
+					unitAmountMinor: priceMinor,
+					currency: "MXN",
+					availability: free > 0 ? "available" : "sold_out",
+					...free > 0 ? { maxQuantity: free } : {},
+					taxIncluded: true,
+					fulfilment: "service",
+					snapshot: { slot: ask.ref }
+				};
+			});
+		},
+		async hold(ctx, request) {
+			if (typeof request?.holdId !== "string" || request.holdId === "") return {
+				ok: false,
+				code: "invalid_request",
+				message: "holdId is required"
+			};
+			if (!Array.isArray(request.lines) || request.lines.length === 0) return {
+				ok: false,
+				code: "invalid_request",
+				message: "a hold has at least one ask"
+			};
+			if (!request.lines.every(validAsk)) return {
+				ok: false,
+				code: "invalid_request",
+				message: "every ask has a ref, a whole quantity of at least 1 and options of strings"
+			};
+			const asks = merged(request.lines);
+			const earlier = asksOf.get(request.holdId);
+			if (earlier && !sameAsks(earlier, asks)) return {
+				ok: false,
+				code: "hold_conflict"
+			};
+			if (!Number.isSafeInteger(request.expiresAt) || request.expiresAt <= ctx.now || request.expiresAt - ctx.now > 12096e5) return {
+				ok: false,
+				code: "invalid_request",
+				message: "expiresAt is a time in the future, at most 14 days away"
+			};
+			const unknown = asks.filter((ask) => !known(ask.ref));
+			if (unknown.length > 0) return {
+				ok: false,
+				code: "insufficient_stock",
+				short: unknown.map((ask) => ({
+					ref: ask.ref,
+					requested: ask.quantity,
+					available: 0
+				}))
+			};
+			const lines = asks.map((ask) => ({
+				subject: subject$1(ask.ref),
+				quantity: ask.quantity
+			}));
+			const result = await stock.hold(ctx, {
+				holdId: request.holdId,
+				lines,
+				expiresAt: request.expiresAt
+			});
+			if (result.ok) {
+				if (!earlier) asksOf.set(request.holdId, asks);
+				return {
+					ok: true,
+					hold: view(result.hold)
+				};
+			}
+			if (result.code === "insufficient_stock") return {
+				ok: false,
+				code: "insufficient_stock",
+				short: result.short.map((line) => ({
+					ref: line.subject.subjectId,
+					requested: line.requested,
+					available: line.available
+				}))
+			};
+			return result;
+		},
+		async commit(ctx, holdId) {
+			return settled(await stock.commit(ctx, holdId));
+		},
+		async release(ctx, holdId) {
+			return settled(await stock.release(ctx, holdId));
+		}
+	};
+}
+//#endregion
+//#region src/testing/stock-conformance.ts
+/**
+* The behaviour every {@link StockPort} must have, as a test suite. Run it against the in-memory stock in Node
+* (`runStockConformance((seed) => createMemoryStock(seed), { describe, it, expect })`) and against the inventory feature's own port in
+* workerd on a migrated D1, with a `make` that writes the seed into its tables. Each test seeds a stock of its own, so `make` must return
+* one with nothing else in it.
+*
+* What it fixes: a hold is every line or none, and the same `holdId` is the same hold; the last unit goes to exactly one of two buyers; the
+* clock is `ctx.now`, never the database's; units come back at `expiresAt` by themselves; a payment that comes after that still commits and
+* says it was late; `release` after `commit` is refused; `fulfil` (optional) moves a committed hold's units off the shelf once and never
+* changes what can be bought; `uncommit` (optional) gives the units of a committed, unfulfilled hold back to what can be bought, once. What
+* `fulfil` does to the counts on hand and sold is not visible through the port: a provider's own tests read it (`counts()` of the in-memory
+* stock, the inventory feature's levels and ledger).
+*/
+const subject = (id) => ({
+	subjectType: "conformance.item",
+	subjectId: id
+});
+const line$1 = (id, quantity) => ({
+	subject: subject(id),
+	quantity
+});
+const key = (id) => subjectKey(subject(id));
+function runStockConformance(make, tools, options = {}) {
+	const { describe, it, expect } = tools;
+	const contextAt = async (now) => options.context ? await options.context(now) : testContext({ now });
+	const T0 = TEST_NOW;
+	const TTL = 1e3;
+	const left = async (port, id, now = T0) => (await port.availability(await contextAt(now), [subject(id)]))[0]?.available;
+	const hold = async (port, holdId, lines, now = T0, ttl = TTL) => port.hold(await contextAt(now), {
+		holdId,
+		lines,
+		expiresAt: now + ttl
+	});
+	const settle = async (port, what, holdId, now = T0) => port[what](await contextAt(now), holdId);
+	describe("StockPort conformance", () => {
+		it("reports a subject nobody tracks as always available", async () => {
+			const [level] = await (await make({})).availability(await contextAt(T0), [subject("untracked")]);
+			expect(level?.tracking).toBe("none");
+			expect(level?.inStock).toBe(true);
+			expect(level?.available).toBe(null);
+		});
+		it("reports counts, a toggle that is out and a toggle that is in", async () => {
+			const levels = await (await make({
+				[key("counted")]: {
+					tracking: "count",
+					onHand: 3
+				},
+				[key("out")]: {
+					tracking: "toggle",
+					out: true
+				},
+				[key("in")]: {
+					tracking: "toggle",
+					out: false
+				}
+			})).availability(await contextAt(T0), [
+				subject("counted"),
+				subject("out"),
+				subject("in")
+			]);
+			expect(levels.map((level) => [
+				level.tracking,
+				level.inStock,
+				level.available
+			])).toEqual([
+				[
+					"count",
+					true,
+					3
+				],
+				[
+					"toggle",
+					false,
+					0
+				],
+				[
+					"toggle",
+					true,
+					null
+				]
+			]);
+		});
+		it("brings a toggle back at its outUntil time", async () => {
+			const port = await make({ [key("dish")]: {
+				tracking: "toggle",
+				out: true,
+				outUntil: T0 + 5e3
+			} });
+			expect((await port.availability(await contextAt(T0 + 4999), [subject("dish")]))[0]?.inStock).toBe(false);
+			expect((await port.availability(await contextAt(T0 + 5e3), [subject("dish")]))[0]?.inStock).toBe(true);
+		});
+		it("holds units and gives them back on release", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			const held = await hold(port, "h1", [line$1("a", 2)]);
+			expect(held.ok).toBe(true);
+			expect(held.ok && held.hold.status).toBe("held");
+			expect(held.ok && held.hold.expiresAt).toBe(T0 + TTL);
+			expect(await left(port, "a")).toBe(1);
+			const released = await settle(port, "release", "h1");
+			expect(released.ok && released.changed).toBe(true);
+			expect(await left(port, "a")).toBe(3);
+		});
+		it("treats the same hold id as the same hold, and a different request under it as a conflict", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			expect((await hold(port, "h1", [line$1("a", 2)])).ok).toBe(true);
+			expect((await hold(port, "h1", [line$1("a", 2)])).ok).toBe(true);
+			expect(await left(port, "a")).toBe(1);
+			expect(await hold(port, "h1", [line$1("a", 1)])).toEqual({
+				ok: false,
+				code: "hold_conflict"
+			});
+			expect(await left(port, "a")).toBe(1);
+		});
+		it("adds up two lines of one subject before it checks", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			expect(await hold(port, "h1", [line$1("a", 2), line$1("a", 2)])).toEqual({
+				ok: false,
+				code: "insufficient_stock",
+				short: [{
+					subject: subject("a"),
+					requested: 4,
+					available: 3
+				}]
+			});
+			expect(await left(port, "a")).toBe(3);
+		});
+		it("holds every line or none: a short line releases the ones before it", async () => {
+			const port = await make({
+				[key("a")]: {
+					tracking: "count",
+					onHand: 1
+				},
+				[key("b")]: {
+					tracking: "count",
+					onHand: 5
+				}
+			});
+			const result = await hold(port, "h1", [line$1("b", 2), line$1("a", 2)]);
+			expect(result).toEqual({
+				ok: false,
+				code: "insufficient_stock",
+				short: [{
+					subject: subject("a"),
+					requested: 2,
+					available: 1
+				}]
+			});
+			expect(await left(port, "b")).toBe(5);
+			expect(await left(port, "a")).toBe(1);
+		});
+		it("gives the last unit to exactly one of two buyers", async () => {
+			const port = await make({ [key("last")]: {
+				tracking: "count",
+				onHand: 1
+			} });
+			const results = await Promise.all([hold(port, "buyer-1", [line$1("last", 1)]), hold(port, "buyer-2", [line$1("last", 1)])]);
+			expect(results.filter((result) => result.ok).length).toBe(1);
+			expect(results.filter((result) => !result.ok && result.code === "insufficient_stock").length).toBe(1);
+			expect(await left(port, "last")).toBe(0);
+		});
+		it("refuses a toggle that is out, takes one that is in, and takes a subject nobody tracks", async () => {
+			const port = await make({
+				[key("out")]: {
+					tracking: "toggle",
+					out: true
+				},
+				[key("in")]: {
+					tracking: "toggle",
+					out: false
+				}
+			});
+			expect(await hold(port, "h1", [line$1("out", 1)])).toEqual({
+				ok: false,
+				code: "insufficient_stock",
+				short: [{
+					subject: subject("out"),
+					requested: 1,
+					available: 0
+				}]
+			});
+			expect((await hold(port, "h2", [line$1("in", 1)])).ok).toBe(true);
+			expect((await hold(port, "h3", [line$1("untracked", 5)])).ok).toBe(true);
+		});
+		it("sells past zero only for an item that allows it", async () => {
+			const port = await make({
+				[key("pre")]: {
+					tracking: "count",
+					onHand: 1,
+					allowOversell: true
+				},
+				[key("firm")]: {
+					tracking: "count",
+					onHand: 1
+				}
+			});
+			expect((await hold(port, "h1", [line$1("pre", 3)])).ok).toBe(true);
+			expect((await hold(port, "h2", [line$1("firm", 3)])).ok).toBe(false);
+		});
+		it("keeps the units sold on commit, and commits only once", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			const committed = await settle(port, "commit", "h1");
+			expect(committed.ok && committed.changed).toBe(true);
+			expect(committed.ok && committed.hold.status).toBe("committed");
+			expect(committed.ok && committed.late).toBe(void 0);
+			expect(await left(port, "a")).toBe(1);
+			const again = await settle(port, "commit", "h1");
+			expect(again.ok && again.changed).toBe(false);
+			expect(await left(port, "a")).toBe(1);
+		});
+		it("refuses to release a hold that was committed", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			await settle(port, "commit", "h1");
+			expect(await settle(port, "release", "h1")).toEqual({
+				ok: false,
+				code: "invalid_state",
+				status: "committed"
+			});
+			expect(await left(port, "a")).toBe(1);
+		});
+		it("releases once and then says nothing changed", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			expect((await settle(port, "release", "h1")).ok).toBe(true);
+			const again = await settle(port, "release", "h1");
+			expect(again.ok && again.changed).toBe(false);
+			expect(await left(port, "a")).toBe(3);
+		});
+		it("answers a hold it does not know", async () => {
+			const port = await make({});
+			expect(await settle(port, "commit", "nope")).toEqual({
+				ok: false,
+				code: "unknown_hold"
+			});
+			expect(await settle(port, "release", "nope")).toEqual({
+				ok: false,
+				code: "unknown_hold"
+			});
+		});
+		it("gives the units back by itself at expiresAt, by the context's clock", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			expect(await left(port, "a", T0 + TTL - 1)).toBe(1);
+			expect(await left(port, "a", T0 + TTL)).toBe(3);
+		});
+		it("commits a payment that arrives after the hold expired, takes the units again and says it was late", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			const late = await settle(port, "commit", "h1", T0 + 2 * TTL);
+			expect(late.ok && late.changed).toBe(true);
+			expect(late.ok && late.late).toBe(true);
+			expect(late.ok && late.oversold).toBe(void 0);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(1);
+		});
+		it("flags a late commit that finds the stock gone, and never reports a negative number", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 2
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			expect((await hold(port, "h2", [line$1("a", 2)], T0 + 2 * TTL)).ok).toBe(true);
+			const late = await settle(port, "commit", "h1", T0 + 2 * TTL);
+			expect(late.ok && late.late).toBe(true);
+			expect(late.ok && late.oversold).toBe(true);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(0);
+		});
+		it("leaves an expired hold released, not committed, when it is released late", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			const result = await settle(port, "release", "h1", T0 + 2 * TTL);
+			expect(result.ok && result.changed).toBe(false);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(3);
+		});
+		it("reports a count at zero, and one that has just been held, as out of stock", async () => {
+			const port = await make({
+				[key("none")]: {
+					tracking: "count",
+					onHand: 0
+				},
+				[key("last")]: {
+					tracking: "count",
+					onHand: 1
+				}
+			});
+			const levelOf = async (id) => {
+				const level = (await port.availability(await contextAt(T0), [subject(id)]))[0];
+				return [level?.inStock, level?.available];
+			};
+			expect(await levelOf("none")).toEqual([false, 0]);
+			expect(await levelOf("last")).toEqual([true, 1]);
+			await hold(port, "h1", [line$1("last", 1)]);
+			expect(await levelOf("last")).toEqual([false, 0]);
+		});
+		it("treats the same hold id with other lines as a conflict: another quantity, another subject, one line more", async () => {
+			const port = await make({
+				[key("a")]: {
+					tracking: "count",
+					onHand: 5
+				},
+				[key("b")]: {
+					tracking: "count",
+					onHand: 5
+				}
+			});
+			expect((await hold(port, "h1", [line$1("a", 1)])).ok).toBe(true);
+			for (const lines of [
+				[line$1("a", 2)],
+				[line$1("b", 1)],
+				[line$1("a", 1), line$1("b", 1)],
+				[line$1("a", 1), line$1("a", 1)]
+			]) expect(await hold(port, "h1", lines)).toEqual({
+				ok: false,
+				code: "hold_conflict"
+			});
+			expect(await left(port, "a")).toBe(4);
+			expect(await left(port, "b")).toBe(5);
+		});
+		it("does not call a late commit oversold when it takes the stock exactly to zero", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 2
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			const late = await settle(port, "commit", "h1", T0 + 2 * TTL);
+			expect(late.ok && late.late).toBe(true);
+			expect(late.ok && late.oversold).toBe(void 0);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(0);
+		});
+		it("answers hold_closed for a hold id whose hold is over, after a release, an expiry or a commit, and holds nothing", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "released", [line$1("a", 1)]);
+			await settle(port, "release", "released");
+			expect(await hold(port, "released", [line$1("a", 1)])).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "released"
+			});
+			await hold(port, "expired", [line$1("a", 1)]);
+			expect(await hold(port, "expired", [line$1("a", 1)], T0 + 2 * TTL, TTL)).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "expired"
+			});
+			await hold(port, "committed", [line$1("a", 1)], T0 + 3 * TTL, TTL);
+			await settle(port, "commit", "committed", T0 + 3 * TTL);
+			expect(await hold(port, "committed", [line$1("a", 1)], T0 + 3 * TTL, TTL)).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "committed"
+			});
+			expect(await left(port, "a", T0 + 3 * TTL)).toBe(2);
+		});
+		it("extends a live hold when it is asked again with a later time, and never shortens it", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			const longer = await hold(port, "h1", [line$1("a", 2)], T0, 5 * TTL);
+			expect(longer.ok && longer.hold.expiresAt).toBe(T0 + 5 * TTL);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(1);
+			const shorter = await hold(port, "h1", [line$1("a", 2)], T0, TTL / 10);
+			expect(shorter.ok && shorter.hold.expiresAt).toBe(T0 + 5 * TTL);
+			expect(await left(port, "a", T0 + 4 * TTL)).toBe(1);
+			expect(await left(port, "a", T0 + 5 * TTL)).toBe(3);
+		});
+		it("holds for at most 14 days, so a time in the wrong unit is refused and not kept for years", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			expect((await hold(port, "ok", [line$1("a", 1)], T0, MAX_HOLD_MS)).ok).toBe(true);
+			const past = await hold(port, "late", [line$1("a", 1)], T0, MAX_HOLD_MS + 1);
+			expect(past.ok === false && past.code).toBe("invalid_request");
+			const wrongUnit = await hold(port, "units", [line$1("a", 1)], T0, 18e8);
+			expect(wrongUnit.ok === false && wrongUnit.code).toBe("invalid_request");
+			expect(await left(port, "a")).toBe(2);
+		});
+		it("refuses a subject type that is not a dotted lowercase key", async () => {
+			const port = await make({});
+			for (const subjectType of [
+				"Shop.Sku",
+				"shop sku",
+				"a:b",
+				"",
+				"shop..sku",
+				"shop."
+			]) {
+				const result = await port.hold(await contextAt(T0), {
+					holdId: "h",
+					lines: [{
+						subject: {
+							subjectType,
+							subjectId: "x"
+						},
+						quantity: 1
+					}],
+					expiresAt: T0 + TTL
+				});
+				expect(`${subjectType} -> ${result.ok === false && result.code}`).toBe(`${subjectType} -> invalid_request`);
+			}
+		});
+		it("refuses a request that is not valid and changes nothing", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			const ctx = await contextAt(T0);
+			const bad = [
+				{
+					holdId: "",
+					lines: [line$1("a", 1)],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [line$1("a", 0)],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [line$1("a", 1.5)],
+					expiresAt: T0 + TTL
+				},
+				{
+					holdId: "h",
+					lines: [line$1("a", 1)],
+					expiresAt: T0
+				}
+			];
+			for (const request of bad) {
+				const result = await port.hold(ctx, request);
+				expect(result.ok === false && result.code).toBe("invalid_request");
+			}
+			expect(await left(port, "a")).toBe(3);
+		});
+		if (!options.skipFulfil) {
+			const fulfil = async (port, holdId, now = T0) => {
+				if (typeof port.fulfil !== "function") throw new Error("this provider has no fulfil: pass { skipFulfil: true } to runStockConformance when it tracks no units on hand");
+				return port.fulfil(await contextAt(now), holdId);
+			};
+			it("fulfils a committed hold once and leaves what can be bought as it was", async () => {
+				const port = await make({ [key("a")]: {
+					tracking: "count",
+					onHand: 5
+				} });
+				await hold(port, "h1", [line$1("a", 2)]);
+				await settle(port, "commit", "h1");
+				expect(await left(port, "a")).toBe(3);
+				const done = await fulfil(port, "h1", T0 + 10);
+				expect(done.ok && done.changed).toBe(true);
+				expect(done.ok && done.hold.status).toBe("committed");
+				expect(done.ok && done.hold.fulfilledAt).toBe(T0 + 10);
+				expect(await left(port, "a", T0 + 10)).toBe(3);
+				const again = await fulfil(port, "h1", T0 + 20);
+				expect(again.ok && again.changed).toBe(false);
+				expect(again.ok && again.hold.fulfilledAt).toBe(T0 + 10);
+				expect(await left(port, "a", T0 + 20)).toBe(3);
+			});
+			it("refuses to fulfil a hold that is not committed, says its status and moves nothing", async () => {
+				const port = await make({ [key("a")]: {
+					tracking: "count",
+					onHand: 5
+				} });
+				await hold(port, "held", [line$1("a", 1)]);
+				expect(await fulfil(port, "held")).toEqual({
+					ok: false,
+					code: "invalid_state",
+					status: "held"
+				});
+				await hold(port, "released", [line$1("a", 1)]);
+				await settle(port, "release", "released");
+				expect(await fulfil(port, "released")).toEqual({
+					ok: false,
+					code: "invalid_state",
+					status: "released"
+				});
+				expect(await fulfil(port, "nope")).toEqual({
+					ok: false,
+					code: "unknown_hold"
+				});
+				expect(await left(port, "a")).toBe(4);
+				expect(await fulfil(port, "held", T0 + 2 * TTL)).toEqual({
+					ok: false,
+					code: "invalid_state",
+					status: "expired"
+				});
+				expect(await left(port, "a", T0 + 2 * TTL)).toBe(5);
+			});
+			it("keeps a fulfilled hold committed: it cannot be released, and its id stays closed", async () => {
+				const port = await make({ [key("a")]: {
+					tracking: "count",
+					onHand: 5
+				} });
+				await hold(port, "h1", [line$1("a", 2)]);
+				await settle(port, "commit", "h1");
+				await fulfil(port, "h1");
+				expect(await settle(port, "release", "h1")).toEqual({
+					ok: false,
+					code: "invalid_state",
+					status: "committed"
+				});
+				expect(await hold(port, "h1", [line$1("a", 2)])).toEqual({
+					ok: false,
+					code: "hold_closed",
+					status: "committed"
+				});
+				const committed = await settle(port, "commit", "h1");
+				expect(committed.ok && committed.changed).toBe(false);
+				expect(await left(port, "a")).toBe(3);
+			});
+			it("fulfils a late commit, and a hold of things nobody counts", async () => {
+				const port = await make({ [key("a")]: {
+					tracking: "count",
+					onHand: 3
+				} });
+				await hold(port, "late", [line$1("a", 2)]);
+				await settle(port, "commit", "late", T0 + 2 * TTL);
+				const late = await fulfil(port, "late", T0 + 2 * TTL);
+				expect(late.ok && late.changed).toBe(true);
+				expect(await left(port, "a", T0 + 2 * TTL)).toBe(1);
+				await hold(port, "free", [line$1("untracked", 4)], T0 + 2 * TTL);
+				await settle(port, "commit", "free", T0 + 2 * TTL);
+				const free = await fulfil(port, "free", T0 + 2 * TTL);
+				expect(free.ok && free.changed).toBe(true);
+			});
+			it("fulfils once when two calls arrive together", async () => {
+				const port = await make({ [key("a")]: {
+					tracking: "count",
+					onHand: 5
+				} });
+				await hold(port, "h1", [line$1("a", 2)]);
+				await settle(port, "commit", "h1");
+				const results = await Promise.all([fulfil(port, "h1"), fulfil(port, "h1")]);
+				expect(results.filter((result) => result.ok && result.changed).length).toBe(1);
+				expect(results.filter((result) => result.ok && !result.changed).length).toBe(1);
+				expect(await left(port, "a")).toBe(3);
+			});
+		}
+		if (options.skipUncommit) return;
+		const uncommit = async (port, holdId, now = T0) => {
+			if (typeof port.uncommit !== "function") throw new Error("this provider has no uncommit: pass { skipUncommit: true } to runStockConformance when it does not count units");
+			return port.uncommit(await contextAt(now), holdId);
+		};
+		it("gives the units of a committed hold back once, and ends the hold as released", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 5
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			await settle(port, "commit", "h1");
+			expect(await left(port, "a")).toBe(3);
+			const undone = await uncommit(port, "h1", T0 + 10);
+			expect(undone.ok && undone.changed).toBe(true);
+			expect(undone.ok && undone.hold.status).toBe("released");
+			expect(await left(port, "a", T0 + 10)).toBe(5);
+			const again = await uncommit(port, "h1", T0 + 20);
+			expect(again.ok && again.changed).toBe(false);
+			expect(again.ok && again.hold.status).toBe("released");
+			expect(await left(port, "a", T0 + 20)).toBe(5);
+		});
+		it("can sell the units again after an uncommit", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 2
+			} });
+			await hold(port, "first", [line$1("a", 2)]);
+			await settle(port, "commit", "first");
+			expect((await hold(port, "second", [line$1("a", 1)])).ok).toBe(false);
+			await uncommit(port, "first");
+			const second = await hold(port, "second", [line$1("a", 2)]);
+			expect(second.ok).toBe(true);
+			expect(await left(port, "a")).toBe(0);
+		});
+		it("refuses to uncommit a hold that is still held, says its status and moves nothing", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 5
+			} });
+			await hold(port, "held", [line$1("a", 1)]);
+			expect(await uncommit(port, "held")).toEqual({
+				ok: false,
+				code: "invalid_state",
+				status: "held"
+			});
+			expect(await uncommit(port, "nope")).toEqual({
+				ok: false,
+				code: "unknown_hold"
+			});
+			expect(await left(port, "a")).toBe(4);
+		});
+		it("takes a hold that is already released or expired as nothing to do", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 5
+			} });
+			await hold(port, "released", [line$1("a", 1)]);
+			await settle(port, "release", "released");
+			const released = await uncommit(port, "released");
+			expect(released.ok).toBe(true);
+			expect(released.ok && released.changed).toBe(false);
+			await hold(port, "expired", [line$1("a", 2)]);
+			const expired = await uncommit(port, "expired", T0 + 2 * TTL);
+			expect(expired.ok).toBe(true);
+			expect(expired.ok && expired.changed).toBe(false);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(5);
+		});
+		it("keeps the id of an uncommitted hold closed to a new hold", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 5
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			await settle(port, "commit", "h1");
+			await uncommit(port, "h1");
+			expect(await hold(port, "h1", [line$1("a", 2)])).toEqual({
+				ok: false,
+				code: "hold_closed",
+				status: "released"
+			});
+			expect(await left(port, "a")).toBe(5);
+		});
+		it("uncommits a late commit, and a hold of things nobody counts", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 3
+			} });
+			await hold(port, "late", [line$1("a", 2)]);
+			await settle(port, "commit", "late", T0 + 2 * TTL);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(1);
+			const late = await uncommit(port, "late", T0 + 2 * TTL);
+			expect(late.ok && late.changed).toBe(true);
+			expect(await left(port, "a", T0 + 2 * TTL)).toBe(3);
+			await hold(port, "free", [line$1("untracked", 4)], T0 + 2 * TTL);
+			await settle(port, "commit", "free", T0 + 2 * TTL);
+			const free = await uncommit(port, "free", T0 + 2 * TTL);
+			expect(free.ok && free.changed).toBe(true);
+		});
+		it("uncommits once when two calls arrive together", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 5
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			await settle(port, "commit", "h1");
+			const results = await Promise.all([uncommit(port, "h1"), uncommit(port, "h1")]);
+			expect(results.filter((result) => result.ok && result.changed).length).toBe(1);
+			expect(results.filter((result) => result.ok && !result.changed).length).toBe(1);
+			expect(await left(port, "a")).toBe(5);
+		});
+		it("refuses to uncommit a hold whose units already left the shelf", async () => {
+			const port = await make({ [key("a")]: {
+				tracking: "count",
+				onHand: 5
+			} });
+			await hold(port, "h1", [line$1("a", 2)]);
+			await settle(port, "commit", "h1");
+			if (typeof port.fulfil !== "function") return;
+			await port.fulfil(await contextAt(T0), "h1");
+			expect(await uncommit(port, "h1")).toEqual({
+				ok: false,
+				code: "invalid_state",
+				status: "committed"
+			});
+			expect(await left(port, "a")).toBe(3);
+		});
+	});
+}
+//#endregion
+//#region src/testing/tax-conformance.ts
+/**
+* The behaviour every {@link TaxPort} must have, as a test suite. Run it against the flat double in Node
+* (`runTaxConformance(() => createFlatTax(), { describe, it, expect })`) and against a tax feature's own port in workerd, with a `context` that
+* carries the project's `env.DB`.
+*
+* What it fixes, whatever the country's rules: the answer is in the order's currency and in whole minor units; a breakdown adds up to the
+* headline, so `computeTotals` takes the answer; a price that includes the tax adds nothing on top, and the tax inside it is part of the price;
+* a discount never raises the tax; a free line carries none; the same input gives the same answer and the input is left as it was. The rates
+* themselves (16% in Mexico, 8% at the border, 0% and exempt) are the provider's own golden files, because they are law and not contract.
+*/
+const line = (ref, patch = {}) => ({
+	ref,
+	title: `Conformance ${ref}`,
+	quantity: 2,
+	unitAmountMinor: 11600,
+	currency: "MXN",
+	availability: "available",
+	taxIncluded: true,
+	fulfilment: "ship",
+	snapshot: { sku: ref },
+	...patch
+});
+/** A deep copy that cannot be edited: a provider that sorts or changes what it was given throws. */
+function frozen(value) {
+	const copy = structuredClone(value);
+	const freeze = (item) => {
+		if (typeof item !== "object" || item === null || Object.isFrozen(item)) return;
+		Object.freeze(item);
+		for (const child of Object.values(item)) freeze(child);
+	};
+	freeze(copy);
+	return copy;
+}
+function runTaxConformance(make, tools, options = {}) {
+	const { describe, it, expect } = tools;
+	const currency = options.currency ?? "MXN";
+	const contextAt = async (now = TEST_NOW) => options.context ? await options.context(now) : testContext({ now });
+	const asked = (patch = {}) => ({
+		currency,
+		lines: [line("a", { currency }), line("b", {
+			currency,
+			taxIncluded: false,
+			unitAmountMinor: 5e3,
+			quantity: 3
+		})],
+		discountMinor: 0,
+		shippingMinor: 0,
+		...options.destination ? { destination: options.destination } : {},
+		...patch
+	});
+	const compute = async (port, input) => port.compute(await contextAt(), frozen(input));
+	const sum = (result) => result.addedMinor + result.includedMinor;
+	describe("TaxPort conformance", () => {
+		it("answers in the order's currency, in whole minor units of zero or more", async () => {
+			const result = await compute(await make(), asked({ shippingMinor: 9900 }));
+			expect(result.currency).toBe(currency);
+			for (const amount of [result.addedMinor, result.includedMinor]) expect(Number.isSafeInteger(amount) && amount >= 0).toBe(true);
+		});
+		it("adds up: a breakdown sums to the headline, so the totals take the answer", async () => {
+			const port = await make();
+			const input = asked({
+				shippingMinor: 9900,
+				discountMinor: 1e3
+			});
+			const result = await compute(port, input);
+			const part = (included) => (result.breakdown ?? []).filter((item) => item.included === included).reduce((total, item) => total + item.amountMinor, 0);
+			if (result.breakdown) {
+				expect(part(false)).toBe(result.addedMinor);
+				expect(part(true)).toBe(result.includedMinor);
+			}
+			const totals = computeTotals({
+				lines: input.lines,
+				shipping: {
+					title: "Envío",
+					amountMinor: 9900,
+					currency
+				},
+				tax: result
+			});
+			expect(totals.ok).toBe(true);
+			if (totals.ok) expect(totals.totals.taxMinor).toBe(result.addedMinor);
+		});
+		it("adds nothing on top of prices that already include the tax", async () => {
+			const result = await compute(await make(), asked({ lines: [line("a", { currency }), line("c", {
+				currency,
+				unitAmountMinor: 2500
+			})] }));
+			expect(result.addedMinor).toBe(0);
+		});
+		it("keeps the tax inside a price smaller than the price", async () => {
+			const result = await compute(await make(), asked({ lines: [line("a", { currency })] }));
+			expect(result.includedMinor <= 23200).toBe(true);
+		});
+		it("never taxes more when there is a discount", async () => {
+			const port = await make();
+			const without = await compute(port, asked({ discountMinor: 0 }));
+			const withDiscount = await compute(port, asked({ discountMinor: 5e3 }));
+			expect(sum(withDiscount) <= sum(without)).toBe(true);
+		});
+		it("taxes a line that costs nothing at nothing", async () => {
+			const free = await compute(await make(), asked({ lines: [line("free", {
+				currency,
+				unitAmountMinor: 0
+			})] }));
+			expect(sum(free)).toBe(0);
+		});
+		it("gives the same answer to the same input, and leaves what it was given as it was", async () => {
+			const port = await make();
+			const input = asked({
+				shippingMinor: 9900,
+				discountMinor: 1e3
+			});
+			const first = await compute(port, input);
+			const second = await compute(port, input);
+			expect(second).toEqual(first);
+		});
+	});
+}
+//#endregion
+export { HARNESS_CHECKS, HOSTILE_REFS, PRICE_OPTION_NAMES, TEST_NOW, checkLineSource, createFakePayments, createFlatDiscount, createFlatTax, createMemorySlots, createMemoryStock, runDiscountConformance, runLineHoldConformance, runLineSourceConformance, runPaymentsConformance, runStockConformance, runTaxConformance, subjectKey, testContext };