better-supabase 0.13.0 → 0.15.0

package/dist/testing/index.js

@@ -1,33 +1,35 @@
-import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { n as dbError } from "../errors-D7u24ZJH.js";
-import { d as temporalText } from "../temporal-DLZlWbOi.js";
-import { t as temporal } from "../temporal-required-Dt4mcPsi.js";
-import { a as ok } from "../result-DIT_qp4G.js";
-import { t as BetterSupabase } from "../define-DwZ_LQVO.js";
+import { t as DbException } from "../db-exception-Lngc1W49.js";
+import { n as dbError } from "../errors-BVFgt8BZ.js";
 import { t as isList } from "../guards-6F2bCtQR.js";
+import { d as temporalText } from "../temporal-DLZlWbOi.js";
+import { t as temporal } from "../temporal-required-Dy0GGD8E.js";
+import { a as ok } from "../result-ntFBW2p2.js";
+import { t as BetterSupabase } from "../define-DlUeKHce.js";
 import { a as toBase64Url, r as fromBase64, t as base64ToText } from "../base64-B9Wlsdj7.js";
-import { o as resolveConfig } from "../config-xUf0dj0t.js";
-import { a as isScopeName, c as templateFunctions, l as templatePlaceholders, n as TEMPLATE_PLACEHOLDERS, s as scopeProblems, u as templateProblems } from "../access-sql-BpOdJvfj.js";
+import { c as resolveConfig } from "../config-DWGgUQCh.js";
+import { a as isScopeName, c as templateFunctions, l as templatePlaceholders, n as TEMPLATE_PLACEHOLDERS, s as scopeProblems, u as templateProblems } from "../access-sql-B-MkVARa.js";
+import { r as TRACKING_STATUSES, t as LABEL_FORMATS } from "../statuses-zRcc2TeZ.js";
 import { i as seedLite, n as loadLite, r as migrateLite, t as LITE_INSTALL } from "../runtime-CoKxZibd.js";
 import { ENV_VARIABLES } from "../env/index.js";
 import { t as defineController } from "../controller-BEliOBOv.js";
-import "../replicas-BvIL4_jL.js";
-import { a as tenantCredentialRef } from "../provider-BhIkKBOh.js";
-import { o as onBlockEvent } from "../block-events-BURaqwyp.js";
-import { n as rawError } from "../block-transport-Ds0C2mUf.js";
-import { t as postgresExecutor } from "../executor-C5uyGttm.js";
-import { i as requestOf, n as checkPermission, r as defineAuthorizer } from "../authorizer-BVR2vPGA.js";
-import { n as parseDbStats } from "../timing-C5NzaEgy.js";
+import { t as onBlockEvent } from "../block-event-listener-Bu6G0TFH.js";
+import { V as rawError } from "../block-helpers-CtBdjgO4.js";
+import "../replicas-Dyoh3CEg.js";
+import { i as defineAuthorizer, r as checkPermission, s as requestOf } from "../authorizer-BGhXaDmo.js";
+import { a as tenantCredentialRef } from "../provider-B6g7rBZX.js";
+import { t as postgresExecutor } from "../executor-3qcMhg6R.js";
+import { n as parseDbStats } from "../timing-dypS0nxW.js";
+import { r as subjectKey } from "../block-subjects-BhDKK_j7.js";
 import { t as organizationsEvents } from "../events-SqJLbb8q.js";
 import { t as mailHeaders } from "../delivery-Bm0jxmzI.js";
 import { toCloudEvents } from "../events/index.js";
-import { d as money, l as isRate } from "../money-BZl985O-.js";
-import { t as SHIPPING_LINE } from "../tax-keSd-q_1.js";
-import { t as buildApiModel } from "../build-DxzJf79X.js";
-import { timestamps } from "../plugins/timestamps/index.js";
-import { softDelete } from "../plugins/soft-delete/index.js";
-import { tenant } from "../plugins/tenant/index.js";
-import { actor } from "../plugins/actor/index.js";
+import { c as isMoney, d as money, l as isRate } from "../money-BZl985O-.js";
+import { t as SHIPPING_LINE } from "../tax-BkCNWWMc.js";
+import { t as trashExtension } from "../extension-DzCc0IOd.js";
+import { t as membershipsExtension } from "../extension-DeAd_MqI.js";
+import { t as createdByExtension } from "../extension-B-lajjex.js";
+import { t as updatedAtExtension } from "../extension-B0EjCYhO.js";
+import { t as buildApiModel } from "../build-QitPVzzO.js";
 import { createClient } from "@supabase/supabase-js";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -175,13 +177,13 @@ async function findSigningKeys(from) {
 const isSigningKey = (value) => typeof value === "object" && value !== null && "kid" in value && typeof value.kid === "string" && "d" in value && typeof value.d === "string";
 /**
 * The key the local stack signs with: the first entry of the file
-* `better-supabase keys` wrote. `path` defaults to
+* `better-supabase dev keys` wrote. `path` defaults to
 * `$SUPABASE_SIGNING_KEYS_PATH`, then `signing_keys_path` from the nearest
 * `supabase/config.toml`.
 */
 async function localSigningKey(path) {
 	const file = path ?? process.env["SUPABASE_SIGNING_KEYS_PATH"] ?? await findSigningKeys(process.cwd());
-	if (!file || !existsSync(file)) throw new TypeError("No local signing key. Run `better-supabase keys`, set `signing_keys_path` in supabase/config.toml and restart the stack, or pass { alg: \"HS256\" } to sign with the local JWT secret.");
+	if (!file || !existsSync(file)) throw new TypeError("No local signing key. Run `better-supabase dev keys`, set `signing_keys_path` in supabase/config.toml and restart the stack, or pass { alg: \"HS256\" } to sign with the local JWT secret.");
 	const keys = JSON.parse(await readFile(file, "utf-8"));
 	const first = Array.isArray(keys) ? keys[0] : void 0;
 	if (!isSigningKey(first)) throw new TypeError(`${file} has no private ES256 key first.`);
@@ -224,7 +226,7 @@ async function signFor(stack, url, claims) {
 	switch (alg) {
 		case "ES256": return signTestJwtWithKey(stack.signingKey ?? await localSigningKey(stack.signingKeysPath), claims);
 		case "HS256":
-			if (!LOCAL_HOSTS.has(new URL(url).hostname)) throw new TypeError(`asUser signs HS256 tokens only for a local stack, not ${url}. Use the ES256 key from \`better-supabase keys\`.`);
+			if (!LOCAL_HOSTS.has(new URL(url).hostname)) throw new TypeError(`asUser signs HS256 tokens only for a local stack, not ${url}. Use the ES256 key from \`better-supabase dev keys\`.`);
 			return signTestJwt(stack.jwtSecret ?? env$2("SUPABASE_JWT_SECRET") ?? "super-secret-jwt-token-with-at-least-32-characters-long", claims);
 		default: throw new TypeError(`asUser: unknown alg "${String(alg)}"`);
 	}
@@ -232,8 +234,8 @@ async function signFor(stack, url, claims) {
 /**
 * A test user against the local stack: a signed token and repositories that run
 * as that user, for live RLS tests. The token is ES256-signed with the key from
-* `better-supabase keys`; pass `{ alg: 'HS256' }` for a stack that still uses
-* the shared JWT secret.
+* `better-supabase dev keys`; pass `{ alg: 'HS256' }` for a stack that still
+* uses the shared JWT secret.
 *
 * ```ts
 * const alice = await asUser(betterSupabase, {
@@ -246,7 +248,7 @@ async function signFor(stack, url, claims) {
 async function asUser(betterSupabase, claims, stack = {}) {
 	const url = stack.url ?? env$2(...ENV_VARIABLES.url) ?? "http://127.0.0.1:54321";
 	const publishableKey = stack.publishableKey ?? env$2(...ENV_VARIABLES.publishableKey, "SUPABASE_ANON_KEY");
-	if (!publishableKey) throw new TypeError("asUser needs publishableKey or $SUPABASE_PUBLISHABLE_KEY. Run `better-supabase env` to write it to .env.local.");
+	if (!publishableKey) throw new TypeError("asUser needs publishableKey or $SUPABASE_PUBLISHABLE_KEY. Run `better-supabase dev env` to write it to .env.local.");
 	const token = await signFor(stack, url, claims);
 	const full = {
 		role: "authenticated",
@@ -395,7 +397,7 @@ function settle(promise, ms) {
 	});
 }
 function expectResponseBudget(response, expectation) {
-	const header = expectation.header ?? "x-bs-db-calls";
+	const header = expectation.header ?? "x-bsb-db-calls";
 	const stats = parseDbStats(response.headers.get(header));
 	if (!stats) throw new Error(`expectDbBudget: the response has no ${header} header. Add withDbStats() to the entries.`);
 	if (expectation.maxCalls !== void 0 && stats.calls > expectation.maxCalls || expectation.maxWaves !== void 0 && stats.waves > expectation.maxWaves) throw new Error(`expectDbBudget: ${stats.calls} calls in ${stats.waves} waves, over the budget of ${expectation.maxCalls ?? "∞"} calls and ${expectation.maxWaves ?? "∞"} waves`);
@@ -410,8 +412,8 @@ async function expectPageBudget(page, expectation) {
 	let lastSeen = 0;
 	const listener = (response) => {
 		const headers = response.headers();
-		const id = headers["x-bs-request-id"];
-		const stats = headers["x-bs-stats"];
+		const id = headers["x-bsb-request-id"];
+		const stats = headers["x-bsb-stats"];
 		if (!id || !stats || !expectation.prefetches && isPrefetch(response)) return;
 		lastSeen = Date.now();
 		seen.push({
@@ -456,7 +458,7 @@ async function expectPageBudget(page, expectation) {
 		}
 		if (seen.length === 0) {
 			if (expectation.requireRequest === false) return [];
-			throw new Error("expectDbBudget: no response carried x-bs-request-id. Enable createNext(betterSupabase, { debug: { enabled: true } }) and run the proxy.");
+			throw new Error("expectDbBudget: no response carried x-bsb-request-id. Enable createNext(betterSupabase, { debug: { enabled: true } }) and run the proxy.");
 		}
 		await Promise.all(seen.map(({ response }) => settle(ended(response), timeoutMs)));
 	} finally {
@@ -465,7 +467,7 @@ async function expectPageBudget(page, expectation) {
 	const renders = [];
 	for (const { response, id, url } of seen) {
 		const reply = await page.request.get(url);
-		if (!reply.ok()) throw new Error(`expectDbBudget: ${url} answered ${reply.status()}. Mount bs.debugRoute() at that path.`);
+		if (!reply.ok()) throw new Error(`expectDbBudget: ${url} answered ${reply.status()}. Mount bsb.debugRoute() at that path.`);
 		renders.push({
 			url: response.url(),
 			requestId: id,
@@ -613,7 +615,7 @@ function statementsOf(meta, fixtures, label) {
 }
 /**
 * Typed fixtures shared by `supabase/seeds` and your tests. Rows use app casing
-* and Insert types; `better-supabase seed` renders them to SQL.
+* and Insert types; `better-supabase db seed` renders them to SQL.
 *
 * ```ts
 * export const seed = defineSeed(betterSupabase, {
@@ -639,9 +641,9 @@ function isTenantSeed(value) {
 	return typeof value === "object" && value !== null && TENANT_SEED in value;
 }
 /**
-* Fixtures for one tenant, built from its id. `better-supabase seed --tenant`
-* applies them to existing tenants, and `seedTenantOnCreate` to each tenant
-* created in development.
+* Fixtures for one tenant, built from its id. `better-supabase db seed
+* --tenant` applies them to existing tenants, and `seedTenantOnCreate` to each
+* tenant created in development.
 *
 * ```ts
 * export const seed = defineTenantSeed(betterSupabase, (tenant) => ({
@@ -725,7 +727,7 @@ async function scopedSeed(betterSupabase, build, options = {}) {
 		const created = result.data;
 		if (meta && meta.primaryKey.length > 0) {
 			const where = Object.fromEntries(meta.primaryKey.map((column) => [column, created[column]]));
-			cleanup.push(() => repository.deleteMany({ where }));
+			cleanup.push(() => repository.delete({ where }));
 		}
 		return created;
 	};
@@ -820,6 +822,57 @@ async function rolledBack(postgres, claims, fn) {
 	return outcome.value;
 }
 //#endregion
+//#region src/testing/factory.ts
+function isRow(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+/**
+* A factory from the defaults of call `n` and the foreign keys it resolves,
+* each mapped to the column it references in the parent row. `factories()`
+* generates one per table:
+*
+* ```ts
+* const tasks = defineFactory<
+*   InsertOf<"tasks">,
+*   "customerId",
+*   "customerId"
+* >((n) => ({ title: `title ${n}` }), { customerId: "id" });
+* tasks({ customerId: acme });
+* ```
+*/
+function defineFactory(defaults, refs) {
+	const columns = refs;
+	let calls = 0;
+	const build = (input = {}) => {
+		calls += 1;
+		const row = { ...defaults(calls) };
+		for (const [key, value] of Object.entries(input)) {
+			const column = columns[key];
+			row[key] = column !== void 0 && isRow(value) ? value[column] : value;
+		}
+		return row;
+	};
+	const factory = (...args) => build(args[0]);
+	return Object.assign(factory, {
+		many: (count, ...args) => Array.from({ length: count }, () => build(args[0])),
+		create: (repository, ...args) => repository.create(build(args[0]))
+	});
+}
+/** A storage path in bucket `B` for a factory default. */
+function factoryPath(_bucket, path) {
+	return path;
+}
+/**
+* The fixed times the generated factories use (2026-01-01), read through the
+* Temporal the app provides.
+*/
+const factoryTime = {
+	instant: () => temporal().Instant.from("2026-01-01T00:00:00Z"),
+	plainDate: () => temporal().PlainDate.from("2026-01-01"),
+	plainDateTime: () => temporal().PlainDateTime.from("2026-01-01T00:00:00"),
+	plainTime: () => temporal().PlainTime.from("00:00:00")
+};
+//#endregion
 //#region src/testing/conformance.ts
 /**
 * Thrown by a conformance kit when any check fails. Lists every failure, not
@@ -896,8 +949,9 @@ function env(names) {
 * Checks row-level security between two tenants against a running stack: for
 * each table, a user of one tenant must not select, insert, update or delete
 * the other tenant's rows. Runs without `betterSupabase`'s plugins, so the
-* `tenant()` plugin can't hide a missing policy. Throws a `ConformanceError`
-* naming each table and command that leaks; removes every row it created.
+* `membershipsExtension()` plugin can't hide a missing policy. Throws a
+* `ConformanceError` naming each table and command that leaks; removes every
+* row it created.
 *
 * ```ts
 * await expectTenantIsolation(betterSupabase, {
@@ -942,7 +996,7 @@ async function expectTenantIsolation(betterSupabase, options) {
 			for (const tenant of tenants) {
 				const [row] = await rowsOf(admin[key].create(spec.row(tenant, 0)));
 				const where = keyOf(table, row);
-				cleanup.push(() => admin[key].deleteMany({ where }));
+				cleanup.push(() => admin[key].delete({ where }));
 				seeded.push(row);
 			}
 			for (const [self, other] of [[0, 1], [1, 0]]) {
@@ -951,17 +1005,17 @@ async function expectTenantIsolation(betterSupabase, options) {
 				const whose = `${label(tenants[other])}'s`;
 				const own = keyOf(table, seeded[self]);
 				const target = keyOf(table, seeded[other]);
-				const current = async () => (await rowsOf(admin[key].findMany({ where: target })))[0];
+				const current = async () => (await rowsOf(admin[key].list({ where: target })))[0];
 				reads.push([`${key}: ${who} reads its own row`, async () => {
-					expect((await rowsOf(user.findMany({ where: own }))).length === 1, `${who} can't read its own row, so the other checks prove nothing; check its claims and memberships`);
+					expect((await rowsOf(user.list({ where: own }))).length === 1, `${who} can't read its own row, so the other checks prove nothing; check its claims and memberships`);
 				}], [`${key}: ${who} can't select ${whose} rows`, async () => {
-					expect((await rowsOf(user.findMany({ where: target }))).length === 0, `select returned ${whose} row`);
+					expect((await rowsOf(user.list({ where: target }))).length === 0, `select returned ${whose} row`);
 				}], [`${key}: ${who} can't insert ${whose} rows`, async () => {
 					const row = spec.row(tenants[other], 1);
 					const result = await user.create(row, { returning: false });
 					if (result.ok) {
 						const where = Object.fromEntries(Object.entries(row).filter(([, value]) => scalar(value)));
-						cleanup.push(() => admin[key].deleteMany({ where }));
+						cleanup.push(() => admin[key].delete({ where }));
 					}
 					expect(!result.ok, `insert of a row for ${whose} tenant succeeded`);
 					expect(result.error.kind === "forbidden", `insert failed with ${result.error.kind} (${result.error.message}), not an RLS error; check the row factory`);
@@ -969,16 +1023,12 @@ async function expectTenantIsolation(betterSupabase, options) {
 					const before = await current();
 					const patch = spec.update;
 					expect(Object.entries(patch).some(([column, value]) => before?.[column] !== value), "update must change the row to detect a leak");
-					await user.updateMany({
-						where: target,
-						data: patch,
-						returning: false
-					});
+					await user.update({ where: target }, patch, { returning: false });
 					const after = await current();
 					expect(Object.entries(patch).every(([column]) => after?.[column] === before?.[column]), `update changed ${whose} row`);
 				}]);
 				deletes.push([`${key}: ${who} can't delete ${whose} rows`, async () => {
-					await user.deleteMany({ where: target });
+					await user.delete({ where: target });
 					expect(await current() !== void 0, `delete removed ${whose} row`);
 				}]);
 			}
@@ -1342,7 +1392,7 @@ const hasName = (subject) => ["has a name", () => {
 /**
 * Proves an `Executor` meets the contract: rows keyed by the selection's
 * aliases, counts, `aborted` errors, failures returned as `Result`s rather than
-* thrown, and (with `create`) a write round trip and a `deleteMany` that
+* thrown, and (with `create`) a write round trip and a `delete({ where })` that
 * `maxAffected` refuses without deleting anything.
 *
 * ```ts
@@ -1358,7 +1408,7 @@ function testExecutor(executor, options) {
 	const { betterSupabase } = options;
 	const table = tableKey(betterSupabase, options.table);
 	const context = { errorMappers: [] };
-	const read = () => captureOp(betterSupabase, (db) => db[table]["findMany"]({ limit: 2 }));
+	const read = () => captureOp(betterSupabase, (db) => db[table]["list"]({ limit: 2 }));
 	const create = options.create;
 	return conform(`Executor "${executor.name}"`, [
 		hasName(executor),
@@ -1454,7 +1504,7 @@ function testExecutor(executor, options) {
 			expect(primary, "write checks need a table with a primary key");
 			const removed = await repository["delete"](row[primary]);
 			expect(removed.ok, `delete failed: ${JSON.stringify(removed.error)}`);
-			const again = await repository["findFirst"]({ where: { [primary]: row[primary] } });
+			const again = await repository["get"](row[primary], { optional: true });
 			expect(again.ok && again.data === null, "the deleted row is still readable");
 		}],
 		create && ["refuses a write past maxAffected and writes nothing", async () => {
@@ -1465,20 +1515,14 @@ function testExecutor(executor, options) {
 			expect(created.ok, `create failed: ${JSON.stringify(created.error)}`);
 			const id = created.data[primary];
 			try {
-				const refused = await repository["deleteMany"]({
-					where: { [primary]: id },
-					maxAffected: 0
-				});
-				expect(!refused.ok, "deleteMany past maxAffected must fail");
+				const refused = await repository["delete"]({ where: { [primary]: id } }, { maxAffected: 0 });
+				expect(!refused.ok, "a delete past maxAffected must fail");
 				const kind = refused.error?.kind;
 				expect(kind === "max_affected", `expected kind "max_affected", got "${String(kind)}"`);
-				const kept = await repository["findFirst"]({ where: { [primary]: id } });
-				expect(kept.ok && kept.data !== null, "a refused deleteMany must not delete the row");
-				const allowed = await repository["deleteMany"]({
-					where: { [primary]: id },
-					maxAffected: 1
-				});
-				expect(allowed.ok, `deleteMany within maxAffected failed: ${JSON.stringify(allowed.error)}`);
+				const kept = await repository["get"](id, { optional: true });
+				expect(kept.ok && kept.data !== null, "a refused delete must not delete the row");
+				const allowed = await repository["delete"]({ where: { [primary]: id } }, { maxAffected: 1 });
+				expect(allowed.ok, `a delete within maxAffected failed: ${JSON.stringify(allowed.error)}`);
 			} finally {
 				await repository["delete"](id);
 			}
@@ -1599,7 +1643,7 @@ function testEventSink(sink, options = {}) {
 }
 //#endregion
 //#region src/testing/kits/payment-provider.ts
-const kindOf$2 = (result) => result.ok ? "ok" : result.error.kind;
+const kindOf$3 = (result) => result.ok ? "ok" : result.error.kind;
 const half = (value) => ({
 	amount: value.amount / 2n,
 	currency: value.currency
@@ -1639,12 +1683,12 @@ function testPaymentProvider(provider, options = {}) {
 				},
 				reference: reference()
 			});
-			expect(kindOf$2(zero) === "invalid_input", `zero gave ${kindOf$2(zero)}`);
+			expect(kindOf$3(zero) === "invalid_input", `zero gave ${kindOf$3(zero)}`);
 			const plain = await provider.createPayment({
 				amount: 1e3,
 				reference: reference()
 			});
-			expect(kindOf$2(plain) === "invalid_input", `a number gave ${kindOf$2(plain)}`);
+			expect(kindOf$3(plain) === "invalid_input", `a number gave ${kindOf$3(plain)}`);
 		}],
 		["creates a payment with its amount, reference and provider", async () => {
 			const ref = reference();
@@ -1672,9 +1716,9 @@ function testPaymentProvider(provider, options = {}) {
 		["returns not_found for an unknown payment", async () => {
 			const id = `conformance_missing_${crypto.randomUUID()}`;
 			const captured = await provider.capture(id);
-			expect(kindOf$2(captured) === "not_found", `capture gave ${kindOf$2(captured)}`);
+			expect(kindOf$3(captured) === "not_found", `capture gave ${kindOf$3(captured)}`);
 			const refunded = await provider.refund(id);
-			expect(kindOf$2(refunded) === "not_found", `refund gave ${kindOf$2(refunded)}`);
+			expect(kindOf$3(refunded) === "not_found", `refund gave ${kindOf$3(refunded)}`);
 		}],
 		provider.get !== void 0 && ["reads a payment back", async () => {
 			const created = await provider.createPayment({
@@ -1700,7 +1744,7 @@ function testPaymentProvider(provider, options = {}) {
 			expect(refund.amount.amount === part.amount, `refunded ${String(refund.amount.amount)}`);
 			expect(refund.status === "succeeded" || refund.status === "pending", `refund status is ${refund.status}`);
 			const tooMuch = await provider.refund(payment.id, { amount });
-			expect(kindOf$2(tooMuch) === "invalid_input", `refunding more than is left gave ${kindOf$2(tooMuch)}`);
+			expect(kindOf$3(tooMuch) === "invalid_input", `refunding more than is left gave ${kindOf$3(tooMuch)}`);
 		}],
 		provider.cancel !== void 0 && ["cancels a payment that was not captured", async () => {
 			const created = await provider.createPayment({
@@ -1724,13 +1768,13 @@ function testPaymentProvider(provider, options = {}) {
 				expect(event.paymentId === payment.id, `an event names payment ${event.paymentId}`);
 			}
 			const refused = await provider.parseWebhook(tampered);
-			expect(kindOf$2(refused) === "unauthorized", `a tampered delivery gave ${kindOf$2(refused)}`);
+			expect(kindOf$3(refused) === "unauthorized", `a tampered delivery gave ${kindOf$3(refused)}`);
 		}]
 	]);
 }
 //#endregion
 //#region src/testing/kits/tax-provider.ts
-const kindOf$1 = (result) => result.ok ? "ok" : result.error.kind;
+const kindOf$2 = (result) => result.ok ? "ok" : result.error.kind;
 const sum = (values) => values.reduce((total, value) => total + value.amount, 0n);
 /**
 * Runs the `TaxProvider` contract against `provider`: the API version, refused
@@ -1782,12 +1826,12 @@ function testTaxProvider(provider, options) {
 				id: "a",
 				amount: money(100n, other)
 			}] }));
-			expect(kindOf$1(mixed) === "invalid_input", `mixed currencies gave ${kindOf$1(mixed)}`);
+			expect(kindOf$2(mixed) === "invalid_input", `mixed currencies gave ${kindOf$2(mixed)}`);
 			const nowhere = await provider.quote(cart({ address: {
 				...address,
 				country: ""
 			} }));
-			expect(kindOf$1(nowhere) === "invalid_input", `no country gave ${kindOf$1(nowhere)}`);
+			expect(kindOf$2(nowhere) === "invalid_input", `no country gave ${kindOf$2(nowhere)}`);
 		}],
 		["quotes one line per cart line, in order, with a total that adds up", async () => {
 			const quote = await provider.quote(cart()).orThrow();
@@ -1853,7 +1897,7 @@ function testTaxProvider(provider, options) {
 					amount: money(sold.taxable.amount + 1n, currency)
 				}]
 			});
-			expect(kindOf$1(tooMuch) === "invalid_input", `reversing more than was sold gave ${kindOf$1(tooMuch)}`);
+			expect(kindOf$2(tooMuch) === "invalid_input", `reversing more than was sold gave ${kindOf$2(tooMuch)}`);
 			const unknown = await provider.reverse({
 				transaction: sale,
 				reference: reference(),
@@ -1862,7 +1906,135 @@ function testTaxProvider(provider, options) {
 					lineId: "conformance-unknown"
 				}]
 			});
-			expect(kindOf$1(unknown) === "invalid_input", `an unknown line gave ${kindOf$1(unknown)}`);
+			expect(kindOf$2(unknown) === "invalid_input", `an unknown line gave ${kindOf$2(unknown)}`);
+		}]
+	]);
+}
+//#endregion
+//#region src/testing/kits/shipping-provider.ts
+const kindOf$1 = (result) => result.ok ? "ok" : result.error.kind;
+const formats = LABEL_FORMATS;
+const statuses = TRACKING_STATUSES;
+function eventsValid(events, where, ordered) {
+	for (const [index, event] of events.entries()) {
+		expect(event.id.length > 0, `${where}: event ${index} has no id`);
+		expect(statuses.includes(event.status), `${where}: event ${event.id} has status "${event.status}"`);
+		const previous = events[index - 1];
+		expect(!ordered || previous === void 0 || previous.occurredAt.epochNanoseconds <= event.occurredAt.epochNanoseconds, `${where}: events are not oldest first`);
+	}
+}
+/**
+* Runs the `ShippingProvider` contract against `carrier`: the API version,
+* refused requests, rates, a label with idempotent retries, tracking, voiding
+* the label and, with `webhook`, signed and forged tracking webhooks. Run it
+* against a carrier's test account: it buys one label and voids it.
+*/
+function testShippingProvider(carrier, options) {
+	const request = {
+		from: options.from,
+		to: options.to,
+		parcels: [{
+			weightGrams: 1200,
+			lengthMm: 300,
+			widthMm: 200,
+			heightMm: 100
+		}],
+		...options.currency === void 0 ? {} : { currency: options.currency }
+	};
+	const reference = `conformance-${crypto.randomUUID()}`;
+	const key = `conformance-${crypto.randomUUID()}`;
+	let label;
+	const bought = async () => {
+		label ??= await carrier.createLabel({
+			...request,
+			service: options.service,
+			reference
+		}, { idempotencyKey: key }).orThrow();
+		return label;
+	};
+	return conform(`ShippingProvider "${carrier.name}"`, [
+		["has apiVersion 1 and a name", () => {
+			const version = carrier.apiVersion;
+			expect(version === 1, `apiVersion is ${String(version)}`);
+			expect(carrier.name.length > 0, "name is empty");
+		}],
+		["refuses a request without packages or with a bad country", async () => {
+			const empty = await carrier.rates({
+				...request,
+				parcels: []
+			});
+			expect(kindOf$1(empty) === "invalid_input", `no packages gave ${kindOf$1(empty)}`);
+			const nowhere = await carrier.rates({
+				...request,
+				to: {
+					...request.to,
+					country: ""
+				}
+			});
+			expect(kindOf$1(nowhere) === "invalid_input", `no country gave ${kindOf$1(nowhere)}`);
+		}],
+		["quotes the service in the asked currency", async () => {
+			const rates = await carrier.rates(request).orThrow();
+			expect(rates.some((rate) => rate.service === options.service), `no rate for the "${options.service}" service`);
+			for (const rate of rates) {
+				expect(rate.carrier === carrier.name, `rate carrier is "${rate.carrier}"`);
+				expect(isMoney(rate.amount) && rate.amount.amount >= 0n, `the ${rate.service} rate is not a Money of zero or more`);
+				expect(options.currency === void 0 || rate.amount.currency === options.currency, `the ${rate.service} rate is in ${rate.amount.currency}`);
+			}
+		}],
+		["refuses an unknown service", async () => {
+			const unknown = await carrier.createLabel({
+				...request,
+				service: `conformance-${crypto.randomUUID()}`,
+				reference
+			});
+			expect(kindOf$1(unknown) === "invalid_input", `an unknown service gave ${kindOf$1(unknown)}`);
+		}],
+		["buys a label with a tracking number, a cost and a known format", async () => {
+			const found = await bought();
+			expect(found.labelId.length > 0, "labelId is empty");
+			expect(found.trackingNumber.length > 0, "trackingNumber is empty");
+			expect(isMoney(found.cost), "cost is not a Money");
+			expect(formats.includes(found.format), `format is "${found.format}"`);
+			for (const url of [found.labelUrl, found.trackingUrl]) expect(url === void 0 || url.startsWith("https://"), `${String(url)} is not an https URL`);
+		}],
+		["returns the same label for the same idempotency key", async () => {
+			const first = await bought();
+			expect((await carrier.createLabel({
+				...request,
+				service: options.service,
+				reference
+			}, { idempotencyKey: key }).orThrow()).labelId === first.labelId, "a retry with the same key bought another label");
+		}],
+		["tracks the label, oldest event first", async () => {
+			const found = await bought();
+			eventsValid(await carrier.track(found.trackingNumber).orThrow(), "track", true);
+		}],
+		["answers not_found for an unknown tracking number", async () => {
+			const unknown = await carrier.track(`conformance-${crypto.randomUUID()}`);
+			expect(kindOf$1(unknown) === "not_found", `an unknown tracking number gave ${kindOf$1(unknown)}`);
+		}],
+		["voids the label", async () => {
+			const found = await bought();
+			expect((await carrier.cancel({
+				labelId: found.labelId,
+				trackingNumber: found.trackingNumber
+			}).orThrow()).cancelled, "cancel did not report cancelled");
+		}],
+		["reads signed tracking webhooks and refuses forged ones", async () => {
+			const { webhook } = options;
+			if (webhook === void 0 || carrier.parseWebhook === void 0) {
+				expect(webhook === void 0 && carrier.parseWebhook === void 0, webhook === void 0 ? "the carrier has parseWebhook; pass webhook to test it" : "webhook was passed but the carrier has no parseWebhook");
+				return;
+			}
+			const updates = await carrier.parseWebhook(await webhook.valid()).orThrow();
+			expect(updates.length > 0, "a valid webhook gave no updates");
+			for (const update of updates) {
+				expect(update.trackingNumber.length > 0, "an update has no tracking number");
+				eventsValid(update.events, update.trackingNumber, false);
+			}
+			const forged = await carrier.parseWebhook(await webhook.forged());
+			expect(kindOf$1(forged) === "unauthorized", `a forged webhook gave ${kindOf$1(forged)}`);
 		}]
 	]);
 }
@@ -1914,10 +2086,9 @@ function testIncomingDestination(destination, options) {
 //#region src/testing/kits/plugin.ts
 /**
 * Proves a `Plugin` targets API v1, installs cleanly on its own and next to the
-* first-party plugins in either order, adds repository methods without
-* replacing base ones, keeps `context`, `transformQuery` and `beforeMutation`
-* pure and deterministic, and keeps executors' results intact when it wraps
-* them.
+* block extensions in either order, adds repository methods without replacing
+* base ones, keeps `context`, `transformQuery` and `beforeMutation` pure and
+* deterministic, and keeps executors' results intact when it wraps them.
 */
 function testPlugin(plugin, options) {
 	const { betterSupabase } = options;
@@ -1944,12 +2115,12 @@ function testPlugin(plugin, options) {
 			const enforce = plugin.enforce;
 			expect(enforce === void 0 || enforce === "first" || enforce === "pre" || enforce === "post", `enforce is ${String(enforce)}; use "first", "pre", "post" or leave it out`);
 		}],
-		["installs next to the first-party plugins in either order", () => {
+		["installs next to the block extensions in either order", () => {
 			const others = [
-				timestamps(),
-				softDelete(),
-				tenant(),
-				actor()
+				updatedAtExtension(),
+				trashExtension(),
+				membershipsExtension(),
+				createdByExtension()
 			].filter((other) => other.name !== plugin.name);
 			let before = betterSupabase;
 			for (const other of others) before = before.use(other);
@@ -1976,7 +2147,7 @@ function testPlugin(plugin, options) {
 			}
 		}],
 		plugin.transformQuery && ["transformQuery is pure and deterministic", async () => {
-			const op = await captureOp(betterSupabase, (db) => db[table]["findMany"]({ limit: 1 }));
+			const op = await captureOp(betterSupabase, (db) => db[table]["list"]({ limit: 1 }));
 			const first = plugin.transformQuery(frozenCopy(op), hook(op));
 			const second = plugin.transformQuery(frozenCopy(op), hook(op));
 			expect(typeof first === "object" && first !== null && first.kind === op.kind, "must return an operation of the same kind");
@@ -2006,7 +2177,7 @@ function testPlugin(plugin, options) {
 			expect(same(result.data, row), "afterMutation changed the returned row");
 		}],
 		plugin.wrapExecutor && ["wrapExecutor keeps results intact", async () => {
-			const op = await captureOp(betterSupabase, (db) => db[table]["findMany"]({ limit: 1 }));
+			const op = await captureOp(betterSupabase, (db) => db[table]["list"]({ limit: 1 }));
 			const data = {
 				rows: [{ marker: "conformance" }],
 				count: 1
@@ -2037,7 +2208,7 @@ function testPlugin(plugin, options) {
 	]);
 }
 //#endregion
-//#region src/testing/kits/queue-backend.ts
+//#region src/testing/kits/queue-provider.ts
 function claimedJob(queue, row) {
 	const instant = temporal().Instant.fromEpochMilliseconds(0);
 	return {
@@ -2053,18 +2224,18 @@ function claimedJob(queue, row) {
 	};
 }
 /**
-* Proves a `QueueBackend` round-trips payloads, hides claimed messages for
+* Proves a `QueueProvider` round-trips payloads, hides claimed messages for
 * their lease, counts attempts, retries and dead-letters on `fail`, and (when
 * it has `leases`) rejects a stale attempt and extends a lease. It writes to
 * `options.queue` on the backend's real store.
 */
-function testQueueBackend(backend, options) {
+function testQueueProvider(backend, options) {
 	const { queue } = options;
 	const claimOne = async () => {
 		const [row] = await backend.read(queue, 30, 1);
 		return row && claimedJob(queue, row);
 	};
-	return conform(`QueueBackend "${backend.name}"`, [
+	return conform(`QueueProvider "${backend.name}"`, [
 		hasName(backend),
 		["has apiVersion 1", () => {
 			const version = backend.apiVersion;
@@ -2387,7 +2558,7 @@ function testAdapter(name, options) {
 				return { pinned: true };
 			});
 			expect(replica, "ctx.replica is unset: pass `server` to the adapter");
-			expect(response.headers.getSetCookie().some((cookie) => cookie.startsWith(`bs-primary-until=`)), `a write must send bs-primary-until; apply ctx.apply() or ctx.cookies()`);
+			expect(response.headers.getSetCookie().some((cookie) => cookie.startsWith(`bsb-primary-until=`)), `a write must send bsb-primary-until; apply ctx.apply() or ctx.cookies()`);
 		}],
 		["hands pending event sends to waitUntil", async () => {
 			const { promise: send, resolve } = Promise.withResolvers();
@@ -3007,7 +3178,7 @@ function sampleModel() {
 		} },
 		channels: [{
 			id: "customers",
-			address: "bs:t:public.customers",
+			address: "bsb:t:public.customers",
 			protocol: "ws",
 			messages: ["customerChanged"],
 			operations: [{
@@ -3181,7 +3352,24 @@ function modelFromMeta(meta) {
 			schema: "public",
 			name,
 			values
-		}))
+		})),
+		functions: Object.entries(meta.functions).flatMap(([key, fn]) => (fn.overloads ?? [fn]).map((signature) => ({
+			key,
+			schema: fn.schema,
+			args: signature.args.map((arg) => {
+				const values = meta.enums[arg.type];
+				return {
+					name: arg.name,
+					tsType: values === void 0 ? "unknown" : values.map((value) => JSON.stringify(value)).join(" | "),
+					optional: arg.optional === true,
+					values
+				};
+			}),
+			returns: "unknown",
+			returnsSet: signature.returnsSet,
+			volatility: signature.volatility
+		}))),
+		blocks: []
 	};
 }
 const EMPTY_INTROSPECTION = {
@@ -3363,6 +3551,87 @@ function testEveDocumentBackend(backend, options = {}) {
 		expect((await backend.read({ key }))?.content === "two", "a refused write changed the document");
 	}]]);
 }
+const FAKE_RECORDING = {
+	file: {
+		id: "recording",
+		filename: "call.webm",
+		mediaType: "audio/webm"
+	},
+	url: "https://example.com/call.webm",
+	read: () => Promise.resolve(/* @__PURE__ */ new Uint8Array())
+};
+/**
+* Proves a `Transcriber` for the engagements block names its model, returns
+* speaker turns in order with `startMs` at most `endMs` and text on each, and
+* rejects once its signal is aborted. Pass a real recording in `input` to call
+* the real provider.
+*/
+function testTranscriber(transcriber, options = {}) {
+	const input = options.input ?? FAKE_RECORDING;
+	return conform(`Transcriber "${transcriber.model}"`, [
+		hasApiVersion(transcriber),
+		["names its model", () => {
+			expect(typeof transcriber.model === "string" && transcriber.model !== "", "model must be a non-empty string");
+		}],
+		["returns ordered speaker turns", async () => {
+			const { segments } = await transcriber.transcribe(input);
+			let last = 0;
+			for (const segment of segments) {
+				expect(typeof segment.text === "string", "every segment needs its text");
+				expect(Number.isFinite(segment.startMs) && Number.isFinite(segment.endMs) && segment.startMs <= segment.endMs, `segment ${segment.startMs}-${segment.endMs} must start before it ends`);
+				expect(segment.startMs >= last, "segments must be ordered by startMs");
+				last = segment.startMs;
+			}
+		}],
+		["rejects once aborted", async () => {
+			expect(await rejects(() => transcriber.transcribe(input, { signal: AbortSignal.abort() })), "transcribe must reject when its signal is aborted");
+		}]
+	]);
+}
+const FAKE_CALL = {
+	engagement: {
+		id: "engagement",
+		kind: "call",
+		title: "Intro call"
+	},
+	transcript: [{
+		recordingId: "recording",
+		position: 1,
+		speaker: "Speaker 1",
+		startMs: 0,
+		endMs: 4e3,
+		text: "Can you send the proposal by Friday?"
+	}, {
+		recordingId: "recording",
+		position: 2,
+		speaker: "Speaker 2",
+		startMs: 4e3,
+		endMs: 7e3,
+		text: "Yes, I will send it on Thursday."
+	}]
+};
+/**
+* Proves a `NoteTaker` for the engagements block names its model, returns a
+* non-empty summary with well-formed action items, and rejects once its signal
+* is aborted. It calls the real model.
+*/
+function testNoteTaker(noteTaker, options = {}) {
+	const input = options.input ?? FAKE_CALL;
+	return conform(`NoteTaker "${noteTaker.model}"`, [
+		hasApiVersion(noteTaker),
+		["names its model", () => {
+			expect(typeof noteTaker.model === "string" && noteTaker.model !== "", "model must be a non-empty string");
+		}],
+		["writes a summary and action items", async () => {
+			const notes = await noteTaker.summarize(input);
+			expect(typeof notes.summary === "string" && notes.summary.trim() !== "", "summary must be a non-empty string");
+			expect((notes.actionItems ?? []).every((item) => typeof item.text === "string" && item.text !== ""), "every action item needs its text");
+		}],
+		["rejects once aborted", async () => {
+			expect(await rejects(() => noteTaker.summarize(input, { signal: AbortSignal.abort() })), "summarize must reject when its signal is aborted");
+		}]
+	]);
+}
 //#endregion
 //#region src/testing/notification-channel.ts
 const STATUSES = /* @__PURE__ */ new Set(["sent", "skipped"]);
@@ -3424,6 +3693,45 @@ function testNotificationChannel(channel, options = {}) {
 	]);
 }
 //#endregion
+//#region src/testing/record-binding.ts
+const callable = (value) => typeof value === "function";
+/**
+* Runs the `defineRecordBinding` contract against `binding`: the API version, a
+* read permission, the event patterns, a `load` that settles, and a `count`
+* keyed by `subjectKey` with a whole number per record. Throws a
+* `ConformanceError` listing every failed check.
+*/
+function testRecordBinding(name, binding, options) {
+	const subjects = options.subjects ?? [options.subject];
+	const load = binding.load;
+	const count = binding.count;
+	return conform(`Record binding "${name}"`, [
+		["has apiVersion 1", () => {
+			const version = binding.apiVersion;
+			expect(version === 1, "apiVersion must be 1");
+		}],
+		["names a read permission", () => {
+			expect(typeof binding.permissions.read === "string" && binding.permissions.read.length > 0, "permissions.read must be a non-empty action name");
+		}],
+		["lists event types", () => {
+			expect(binding.events.every((event) => typeof event === "string" && event.length > 0), "events must be non-empty strings");
+		}],
+		["loads a record", async () => {
+			expect(callable(binding.load), "load must be a function");
+			expect((await load(options.client, options.subject, void 0)).ok, "load must succeed for a record the client holds");
+		}],
+		count !== void 0 && ["counts records by subject key", async () => {
+			const result = await count(options.client, subjects);
+			expect(result.ok, "count must succeed");
+			const wanted = new Set(subjects.map((subject) => subjectKey(subject)));
+			for (const [key, value] of Object.entries(result.data)) {
+				expect(wanted.has(key), `count returned "${key}", not a type:id key asked for`);
+				expect(Number.isInteger(value) && value >= 0, `count for "${key}" must be a whole number`);
+			}
+		}]
+	]);
+}
+//#endregion
 //#region src/testing/webhooks.ts
 const SECRET = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
 function signInput(body, timestamp) {
@@ -4223,4 +4531,4 @@ const actCases = {
 	]
 };
 //#endregion
-export { ConformanceError, LOCAL_JWT_SECRET, PROBE_INITIAL, actCases, asUser, createTestSigner, defineSeed, defineTenantSeed, expectDbBudget, expectInstant, expectTenantIsolation, isSeed, isTenantSeed, liteStack, localAuth, localSigningKey, scopedSeed, seedTenantOnCreate, signLocalJwt, signTestJwt, signTestJwtWithKey, staticAuthorizer, supabaseClaimFixtures, supabaseInvalidClaimFixtures, testAdapter, testAiTaskRunner, testAuthResolver, testAuthorizationHooks, testAuthorizationProvider, testAuthorizer, testBlockTransportMiddleware, testBuilderStarter, testCacheAdapter, testChatState, testControllerBinding, testCredentialProvider, testDeliveryTransport, testDocumentFormat, testEmbedder, testEveDocumentBackend, testEventSink, testExecutor, testGenerator, testGraphCompiler, testIncomingDestination, testNotificationChannel, testPaymentProvider, testPlugin, testQueueBackend, testStreamStore, testSupportSessionStore, testTaxProvider, testWebhookSecretStore, testWebhookSigner, testWebhookTransport, withClaims, withRollback };
+export { ConformanceError, LOCAL_JWT_SECRET, PROBE_INITIAL, actCases, asUser, createTestSigner, defineFactory, defineSeed, defineTenantSeed, expectDbBudget, expectInstant, expectTenantIsolation, factoryPath, factoryTime, isSeed, isTenantSeed, liteStack, localAuth, localSigningKey, scopedSeed, seedTenantOnCreate, signLocalJwt, signTestJwt, signTestJwtWithKey, staticAuthorizer, supabaseClaimFixtures, supabaseInvalidClaimFixtures, testAdapter, testAiTaskRunner, testAuthResolver, testAuthorizationHooks, testAuthorizationProvider, testAuthorizer, testBlockTransportMiddleware, testBuilderStarter, testCacheAdapter, testChatState, testControllerBinding, testCredentialProvider, testDeliveryTransport, testDocumentFormat, testEmbedder, testEveDocumentBackend, testEventSink, testExecutor, testGenerator, testGraphCompiler, testIncomingDestination, testNoteTaker, testNotificationChannel, testPaymentProvider, testPlugin, testQueueProvider, testRecordBinding, testShippingProvider, testStreamStore, testSupportSessionStore, testTaxProvider, testTranscriber, testWebhookSecretStore, testWebhookSigner, testWebhookTransport, withClaims, withRollback };