better-supabase 0.13.0 → 0.14.0

package/dist/testing/index.js

@@ -1,29 +1,31 @@
-import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { n as dbError } from "../errors-D7u24ZJH.js";
+import { t as DbException } from "../db-exception-Lngc1W49.js";
+import { n as dbError } from "../errors-03ysrOt4.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 temporal } from "../temporal-required-B8qQHYbI.js";
+import { a as ok } from "../result-B3m7xtRY.js";
+import { t as BetterSupabase } from "../define-DQznpZYl.js";
 import { t as isList } from "../guards-6F2bCtQR.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-Dn0cC3bM.js";
+import { a as isScopeName, c as templateFunctions, l as templatePlaceholders, n as TEMPLATE_PLACEHOLDERS, s as scopeProblems, u as templateProblems } from "../access-sql-CPoq9F86.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 { t as onBlockEvent } from "../block-event-listener-Bu6G0TFH.js";
+import { V as rawError } from "../block-helpers-CiKtrb6g.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 { a as tenantCredentialRef } from "../provider-EJ0-5GwJ.js";
+import { t as postgresExecutor } from "../executor-BDAGTc_O.js";
+import { i as requestOf, n as checkPermission, r as defineAuthorizer } from "../authorizer-DPTeL-7h.js";
 import { n as parseDbStats } from "../timing-C5NzaEgy.js";
+import { r as subjectKey } from "../block-subjects-Dzq5Xn_0.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 { c as isMoney, d as money, l as isRate } from "../money-BZl985O-.js";
+import { t as SHIPPING_LINE } from "../tax-DmOMjrYc.js";
+import { t as buildApiModel } from "../build-DCfpwg78.js";
 import { timestamps } from "../plugins/timestamps/index.js";
 import { softDelete } from "../plugins/soft-delete/index.js";
 import { tenant } from "../plugins/tenant/index.js";
@@ -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
@@ -1599,7 +1652,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 +1692,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 +1725,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 +1753,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 +1777,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 +1835,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 +1906,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 +1915,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/shipment-carrier.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 `ShipmentCarrier` 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 testShipmentCarrier(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(`ShipmentCarrier "${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)}`);
 		}]
 	]);
 }
@@ -3181,7 +3362,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 +3561,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 +3703,45 @@ function testNotificationChannel(channel, options = {}) {
 	]);
 }
 //#endregion
+//#region src/testing/section.ts
+const callable = (value) => typeof value === "function";
+/**
+* Runs the `defineSection` contract against `section`: 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 testSection(name, section, options) {
+	const subjects = options.subjects ?? [options.subject];
+	const load = section.load;
+	const count = section.count;
+	return conform(`Section "${name}"`, [
+		["has apiVersion 1", () => {
+			const version = section.apiVersion;
+			expect(version === 1, "apiVersion must be 1");
+		}],
+		["names a read permission", () => {
+			expect(typeof section.permissions.read === "string" && section.permissions.read.length > 0, "permissions.read must be a non-empty action name");
+		}],
+		["lists event types", () => {
+			expect(section.events.every((event) => typeof event === "string" && event.length > 0), "events must be non-empty strings");
+		}],
+		["loads a record", async () => {
+			expect(callable(section.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 +4541,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, testQueueBackend, testSection, testShipmentCarrier, testStreamStore, testSupportSessionStore, testTaxProvider, testTranscriber, testWebhookSecretStore, testWebhookSigner, testWebhookTransport, withClaims, withRollback };

package/dist/timeline-0_hTBH0-.js

@@ -0,0 +1,52 @@
+import { d as findSection, f as loadSections } from "./feature-BBLdbGu7.js";
+//#region src/records/timeline.ts
+/** The section names of `blocks` whose sections map rows to timeline entries. */
+function timelineSections(blocks) {
+	const names = /* @__PURE__ */ new Set();
+	for (const block of Object.values(blocks)) for (const [name, section] of Object.entries(block.sections ?? {})) if (section.timeline !== void 0) names.add(name);
+	return [...names];
+}
+function newestFirst(a, b) {
+	const order = b.at.epochNanoseconds - a.at.epochNanoseconds;
+	return order === 0n ? a.section.localeCompare(b.section) || a.id.localeCompare(b.id) : order > 0n ? 1 : -1;
+}
+/**
+* A record's history across its sections, newest first: comments, files and
+* versions, each section loaded once through `loadSections` and mapped by its
+* `timeline`. A section that fails or that `can` hides adds nothing and is
+* listed in `skipped`; it never throws.
+*
+* ```ts
+* const { entries } = await loadTimeline(
+*   { blocks: blockSet.blocks, clients: blocks },
+*   { type: "customer", id },
+*   { limit: 50 },
+* );
+* ```
+*/
+async function loadTimeline(source, subject, options = {}) {
+	const names = options.sections ?? timelineSections(source.blocks);
+	const loaded = await loadSections(source, subject, names, options);
+	const entries = [];
+	const skipped = {};
+	for (const name of names) {
+		const result = loaded[name];
+		const timeline = findSection(source.blocks, name)?.section.timeline;
+		if (result === void 0) continue;
+		if (result.kind !== "ok") {
+			skipped[name] = result;
+			continue;
+		}
+		for (const item of timeline?.(result.data) ?? []) entries.push({
+			...item,
+			section: name
+		});
+	}
+	entries.sort(newestFirst);
+	return {
+		entries: options.limit === void 0 ? entries : entries.slice(0, options.limit),
+		skipped
+	};
+}
+//#endregion
+export { timelineSections as n, loadTimeline as t };