better-supabase 0.14.0 → 0.15.0

package/dist/block-fields-3w4MZr8U.d.ts

@@ -1,58 +0,0 @@
-import { f as Result, t as AsyncResult } from "./result-C6jDfedy.js";
-import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
-//#region src/core/block-fields.d.ts
-/** The fields a `fields` schema adds, or none when the block has no schema. */
-type FieldsOf<S> = S extends StandardSchemaV1<unknown, infer O> ? O extends object ? O : never : Record<never, never>;
-/** The extra columns of a row, keyed by database name, typed by `F`. */
-type ExtraFields<F extends object = Record<never, never>> = Readonly<Record<string, unknown>> & F;
-/** A row whose extra columns a block read under `fields`. */
-interface WithExtraFields {
-  readonly fields: Readonly<Record<string, unknown>>;
-}
-/**
- * Parses and validates the extra fields an app adds to a block's table, with
- * any Standard Schema (zod, valibot, arktype) for an object.
- */
-interface BlockFields<T extends object> {
-  /**
-   * Parses a row the block read: the schema's output replaces the fields it
-   * covers, and the other fields stay as read. A row the schema rejects is a
-   * `validation` error.
-   */
-  read<R extends object>(row: R): Promise<Result<R & T>>;
-  /**
-   * Validates the fields a write sets. Issues about fields the write leaves out
-   * are ignored, so partial updates pass; the database applies its defaults and
-   * `not null` checks. A rejected write is a `validation` error, and nothing is
-   * sent to the database.
-   */
-  write<A extends object>(attrs: A): Promise<Result<A>>;
-  /**
-   * Parses the `fields` of a row the block read: the extra columns its SQL
-   * returns under `fields`, keyed by database name.
-   */
-  readonly row: <R extends WithExtraFields>(row: R) => AsyncResult<R & {
-    readonly fields: ExtraFields<T>;
-  }>;
-  /** `row` for each row, stopping at the first rejected one. */
-  readonly rows: <R extends WithExtraFields>(rows: readonly R[]) => AsyncResult<(R & {
-    readonly fields: ExtraFields<T>;
-  })[]>;
-  /**
-   * Validates the extra fields a write sets, as the jsonb argument the SQL
-   * function takes; `undefined` without any, so the argument is left out.
-   */
-  readonly args: (fields: object | undefined) => AsyncResult<Readonly<Record<string, unknown>> | undefined>;
-}
-/**
- * The extra columns a block row carries, by column name, typed by its `fields`
- * schema.
- */
-type RowFields<F extends object> = Readonly<Record<string, unknown>> & F;
-/**
- * The `fields` helper block creators use. Without a schema, reads and writes
- * pass through unchanged.
- */
-declare function blockFields<T extends object = Record<never, never>>(schema: StandardSchemaV1 | undefined, label: string): BlockFields<T>;
-//#endregion
-export { WithExtraFields as a, RowFields as i, ExtraFields as n, blockFields as o, FieldsOf as r, BlockFields as t };

package/dist/block-fields-DBSJSeaO.js

@@ -1,139 +0,0 @@
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { a as ok, r as err, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { t as toIssues } from "./standard-DtkpFGkS.js";
-//#region src/core/block-fields.ts
-/** Parses the `fields` of one row with `fields.read`. */
-function readFields(fields, row) {
-	return AsyncResult.from(() => fields.read(row.fields)).map((parsed) => ({
-		...row,
-		fields: parsed
-	}));
-}
-/** Parses the `fields` of each row; the first rejected row fails the read. */
-function readAllFields(fields, rows) {
-	return AsyncResult.from(async () => {
-		const out = [];
-		for (const row of rows) {
-			const parsed = await fields.read(row.fields);
-			if (!parsed.ok) return parsed;
-			out.push({
-				...row,
-				fields: parsed.data
-			});
-		}
-		return ok(out);
-	});
-}
-/**
-* Validates the `fields` a write sets with `fields.write`, then builds the
-* call. A write without fields skips the check and passes none.
-*/
-function writeFields(fields, values, then) {
-	if (values === void 0) return then(void 0);
-	return AsyncResult.from(() => fields.write({ ...values })).andThen(then);
-}
-/** The `fields` object of a row a block function returned, or none. */
-function rowFields(value) {
-	return isRecord(value) ? value : {};
-}
-async function run(schema, value) {
-	return schema["~standard"].validate(value);
-}
-const invalid = (label, issues) => err(dbError("validation", `Invalid ${label}`, { issues }));
-/**
-* The `fields` helper block creators use. Without a schema, reads and writes
-* pass through unchanged.
-*/
-function blockFields(schema, label) {
-	const fields = {
-		async read(row) {
-			if (schema === void 0) return ok(row);
-			const outcome = await run(schema, row);
-			if (outcome.issues) return invalid(label, toIssues(outcome.issues));
-			if (!isRecord(outcome.value)) return invalid(label, [{ message: "fields must parse to an object" }]);
-			return ok({
-				...row,
-				...outcome.value
-			});
-		},
-		async write(attrs) {
-			if (schema === void 0) return ok(attrs);
-			const outcome = await run(schema, attrs);
-			if (!outcome.issues) {
-				if (!isRecord(outcome.value)) return ok(attrs);
-				const parsed = outcome.value;
-				const picked = Object.fromEntries(Object.keys(attrs).filter((key) => key in parsed).map((key) => [key, parsed[key]]));
-				return ok({
-					...attrs,
-					...picked
-				});
-			}
-			const given = new Set(Object.keys(attrs));
-			const relevant = toIssues(outcome.issues).filter((issue) => {
-				const [first] = issue.path ?? [];
-				return first === void 0 || given.has(String(first));
-			});
-			if (relevant.length === 0) return ok(attrs);
-			return invalid(label, relevant);
-		},
-		row: (row) => AsyncResult.from(() => fields.read(row.fields)).map((parsed) => ({
-			...row,
-			fields: parsed
-		})),
-		rows: (rows) => AsyncResult.from(async () => {
-			const out = [];
-			for (const row of rows) {
-				const parsed = await fields.row(row);
-				if (!parsed.ok) return parsed;
-				out.push(parsed.data);
-			}
-			return ok(out);
-		}),
-		args: (extra) => AsyncResult.from(async () => {
-			if (extra === void 0 || Object.keys(extra).length === 0) return ok(void 0);
-			const checked = await fields.write({ ...extra });
-			return checked.ok ? ok(checked.data) : checked;
-		})
-	};
-	return fields;
-}
-/** The keys of a write the block doesn't type itself: its extra fields. */
-const extraOf = (input, known) => Object.fromEntries(Object.entries(input).filter(([key]) => !known.has(key)));
-/** The extra columns a block read returns under its `fields` key. */
-const extraFieldsOf = (value) => isRecord(value) && isRecord(value["fields"]) ? value["fields"] : {};
-/**
-* Parses the extra columns of `raw` (a row a block function returned) and adds
-* them to `row`, the block's typed row. The row's own keys win, so an extra
-* column never replaces one the block types.
-*/
-async function withFields(fields, raw, row) {
-	const parsed = await fields.read(extraFieldsOf(raw));
-	if (!parsed.ok) return parsed;
-	return ok({
-		...parsed.data,
-		...row
-	});
-}
-/** `withFields` over a list of pairs: the raw row and the typed row. */
-async function allWithFields(fields, rows) {
-	const out = [];
-	for (const [raw, row] of rows) {
-		const parsed = await withFields(fields, raw, row);
-		if (!parsed.ok) return parsed;
-		out.push(parsed.data);
-	}
-	return ok(out);
-}
-/**
-* Validates the extra fields of a write: `{ fields }` to spread into the call's
-* arguments, or `{}` when the write sets none, so a module without extra
-* columns is called as before.
-*/
-async function extraFieldsArg(fields, extra) {
-	if (Object.keys(extra).length === 0) return ok({});
-	const valid = await fields.write(extra);
-	return valid.ok ? ok({ fields: valid.data }) : valid;
-}
-//#endregion
-export { readAllFields as a, withFields as c, extraOf as i, writeFields as l, blockFields as n, readFields as o, extraFieldsArg as r, rowFields as s, allWithFields as t };

package/dist/block-helpers-BaugZlJV.d.ts

@@ -1,62 +0,0 @@
-import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
-import { t as BlockTransport } from "./block-transport-d53POsem.js";
-//#region src/core/tenant-source.d.ts
-/**
- * Where a block reads the active tenant: an organization id, or a function that
- * returns the current one, such as `() => db.$context.tenant` on the server or
- * the session's tenant claim in the browser.
- */
-type BlockTenant = string | (() => string | null | undefined);
-//#endregion
-//#region src/core/block-tenant.d.ts
-/** The `tenant` option of the blocks whose methods work in one tenant. */
-interface BlockTenantOptions {
-  /**
-   * The organization the calls act in. `createBlocks` and `createBlockClient`
-   * pass the request's tenant; a call without one fails with
-   * `TENANT_REQUIRED`.
-   */
-  readonly tenant?: BlockTenant;
-}
-//#endregion
-//#region src/core/block-helpers.d.ts
-/** The `temporal` option every block creator takes. */
-interface BlockTemporalOptions {
-  /**
-   * The Temporal namespace for runtimes without a global one, such as `import {
-   * Temporal } from "temporal-polyfill"`. Blocks use it instead of
-   * `globalThis.Temporal`, which stays untouched; like `defineSupabase(schema,
-   * { temporal })`, it applies to the whole process.
-   */
-  readonly temporal?: typeof Temporal;
-}
-/** The options every block creator shares. */
-interface BlockOptions extends BlockTemporalOptions, BlockTenantOptions {
-  /**
-   * `sqlTransport(ctx.postgres)` for members, or `rpcTransport` over an API
-   * schema.
-   */
-  readonly transport: BlockTransport;
-  /**
-   * The transport for service-only calls (jobs, purges). Defaults to
-   * `transport`.
-   */
-  readonly service?: BlockTransport;
-  /** The module's schema, or its API schema. Default `better_supabase`. */
-  readonly schema?: string;
-  /** Error mappers that run before the built-in ones. */
-  readonly mappers?: readonly ErrorMapper[];
-}
-/** Calls one block function and maps a rejection to a `DbError`. */
-type BlockCall = <T>(fn: string, args: Readonly<Record<string, unknown>>, then: (value: unknown) => T | Promise<T>) => AsyncResult<T>;
-/**
- * One page of a list. `cursor` is the previous page's `next` cursor or last
- * item, in the shape each list documents.
- */
-interface CursorPageOptions<Cursor> {
-  /** The most items to return. Each list documents its default and maximum. */
-  readonly limit?: number;
-  readonly cursor?: Cursor;
-}
-//#endregion
-export { BlockTenantOptions as a, CursorPageOptions as i, BlockOptions as n, BlockTenant as o, BlockTemporalOptions as r, BlockCall as t };

package/dist/block-helpers-CiKtrb6g.js

@@ -1,353 +0,0 @@
-import { t as DbException } from "./db-exception-Lngc1W49.js";
-import { c as mapDbError, n as dbError, r as dbErrorOf } from "./errors-03ysrOt4.js";
-import { l as provideTemporal } from "./temporal-DLZlWbOi.js";
-import { t as temporal } from "./temporal-required-B8qQHYbI.js";
-import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { i as sqlIdent } from "./template-BWP7IXZg.js";
-import { t as fromPgError } from "./pg-error-B5QLDcbG.js";
-//#region src/core/block-transport.ts
-/**
-* Calls the functions over Postgres, as the user `client` runs as:
-* `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
-*/
-function sqlTransport(client) {
-	return { async call(schema, fn, args) {
-		const entries = Object.entries(args).filter(([, value]) => value !== void 0);
-		const params = entries.map(([, value]) => value !== null && typeof value === "object" && (!Array.isArray(value) || value.some((entry) => entry !== null && typeof entry === "object")) ? JSON.stringify(value) : value);
-		const list = entries.map(([name], index) => `${sqlIdent(name)} => $${String(index + 1)}`).join(", ");
-		const [row] = await client.queryRaw(`select ${sqlIdent(schema)}.${sqlIdent(fn)}(${list}) as value`, params);
-		return row?.value ?? null;
-	} };
-}
-/**
-* Calls the functions over the Data API with the user's session. Pass `schema`
-* with the API schema that `blocks.<module>.api` writes wrappers into; without
-* it the calls go to the module schema, which then has to be exposed.
-*/
-function rpcTransport(client, options = {}) {
-	const untyped = client;
-	return { async call(schema, fn, args) {
-		const defined = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0));
-		const { data, error } = await untyped.schema(options.schema ?? schema).rpc(fn, defined);
-		if (error) {
-			const message = typeof error === "object" && "message" in error ? String(error.message) : String(error);
-			throw Object.assign(new Error(message), error);
-		}
-		return data;
-	} };
-}
-/**
-* Calls the functions through a `Db`'s executor, so a block runs wherever the
-* `Db` does: over PostgREST for `ctx.db` in a normal request, and over direct
-* Postgres as the target in a support session or for an API key. Rejects with
-* the raw database error, like the other transports, so the block's error
-* mappers see the same codes and hints.
-*/
-function dbTransport(db, options = {}) {
-	return { async call(schema, fn, args) {
-		const executor = db.$executor;
-		if (!executor.rpc) throw new TypeError(`dbTransport needs an executor with rpc(); the ${executor.name} executor has none`);
-		let raw;
-		const capture = (error) => {
-			raw = error;
-		};
-		const defined = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0));
-		const result = await executor.rpc(fn, defined, {
-			schema: options.schema ?? schema,
-			errorMappers: [capture]
-		});
-		if (result.ok) return result.data;
-		if (raw === void 0) throw new DbException(result.error);
-		throw Object.assign(new Error(raw.message ?? result.error.message), raw);
-	} };
-}
-/** The Postgres or PostgREST error a transport rejected with, if it is one. */
-function rawError(cause) {
-	if (!isRecord(cause)) return;
-	const field = (key) => {
-		const value = cause[key];
-		return typeof value === "string" ? value : void 0;
-	};
-	if (field("code") === void 0) return;
-	const raw = {};
-	for (const key of [
-		"message",
-		"code",
-		"details",
-		"hint",
-		"constraint"
-	]) {
-		const value = field(key);
-		if (value !== void 0) raw[key] = value;
-	}
-	const detail = field("detail");
-	if (raw["details"] === void 0 && detail !== void 0) raw["details"] = detail;
-	return raw;
-}
-//#endregion
-//#region src/core/block-helpers.ts
-/** Provides `options.temporal`, when set, for the block's time values. */
-function applyTemporal(options) {
-	if (options?.temporal !== void 0) provideTemporal(options.temporal);
-}
-/** The block schema when the options name none. */
-const DEFAULT_BLOCK_SCHEMA = "better_supabase";
-/**
-* A thrown error as a `DbError`: a database error goes through the app's
-* mappers first, and a `DbError` a transport already built stays as it is.
-*/
-function toBlockError(cause, mappers = []) {
-	const known = dbErrorOf(cause);
-	if (known) return known;
-	const raw = rawError(cause);
-	return raw ? mapDbError(raw, mappers) : toDbError(cause);
-}
-/**
-* A `BlockCall` over `transport`, in `schema`, with the app's error mappers
-* first.
-*/
-function blockCall(transport, schema = DEFAULT_BLOCK_SCHEMA, mappers = []) {
-	return (fn, args, then) => AsyncResult.from(async () => {
-		let value;
-		try {
-			value = await transport.call(schema, fn, args);
-		} catch (cause) {
-			return err(toBlockError(cause, mappers));
-		}
-		return ok(await then(value));
-	});
-}
-/**
-* A budget of `ms` milliseconds from now, or none for `undefined`. `now` is
-* injectable for tests.
-*/
-function budget(ms, now = Date.now) {
-	const deadline = ms === void 0 ? Number.POSITIVE_INFINITY : now() + ms;
-	return {
-		deadline,
-		expired: () => now() >= deadline,
-		remaining: () => deadline - now()
-	};
-}
-/**
-* Calls `extend` at half the lease (at least every second) until the returned
-* function is called, so work that outlasts its lease keeps it.
-*/
-function leaseHeartbeat(leaseSeconds, extend) {
-	const timer = setInterval(extend, Math.max(1e3, leaseSeconds * 1e3 / 2));
-	return () => {
-		clearInterval(timer);
-	};
-}
-const textOf = (value) => typeof value === "string" ? value : String(value);
-const optionalText = (value) => value === null || value === void 0 ? void 0 : textOf(value);
-/** A function result that must be an object. */
-function recordOf(value, fn) {
-	if (!isRecord(value)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
-	return value;
-}
-/** A function result that must be an array of objects. */
-function recordsOf(value, fn) {
-	if (value === null || value === void 0) return [];
-	if (!Array.isArray(value) || !value.every(isRecord)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
-	return value;
-}
-const stringsOf = (value) => Array.isArray(value) ? value.map(textOf) : [];
-/** `value` when it is one of `values`, otherwise `fallback`. */
-function oneOf(value, values, fallback) {
-	return values.find((item) => item === value) ?? fallback;
-}
-/** `value` when it is one of `values`; throws for anything else. */
-function enumOrThrow(value, values, what) {
-	const found = values.find((item) => item === value);
-	if (found === void 0) throw new TypeError(`unknown ${what} "${String(value)}"`);
-	return found;
-}
-/** A jsonb object column, or an empty object for anything else. */
-const recordOrEmpty = (value) => isRecord(value) ? value : {};
-/** A `credential_ref` column, or `undefined` when it names no provider. */
-function credentialRefOf(value) {
-	if (!isRecord(value) || typeof value["provider"] !== "string") return;
-	return {
-		...value,
-		provider: value["provider"]
-	};
-}
-/** The `not_found` error a block returns for a row the caller can't see. */
-const notFoundError = (message, hint) => dbError("not_found", message, hint === void 0 ? {} : { hint });
-/** A `timestamptz` from jsonb or `pg`, or `undefined` for null. */
-const optionalInstant = (value) => value === null || value === void 0 ? void 0 : value instanceof Date || typeof value === "string" ? toInstant(value) : void 0;
-/** Text from jsonb, or `null` when it is missing or not text. */
-const nullableText = (value) => optionalText(value) ?? null;
-/** A `timestamptz` from jsonb or `pg`, or `null` when it is missing. */
-const nullableInstant = (value) => optionalInstant(value) ?? null;
-/** A `timestamptz` that must be there; throws when it is null or missing. */
-function requiredInstant(value, field) {
-	const instant = optionalInstant(value);
-	if (instant === void 0) throw new TypeError(`${field} is missing`);
-	return instant;
-}
-/** A `timestamptz` from jsonb or `pg`; throws for null or text that isn't one. */
-const instantOf = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
-const INTEGER = /^-?\d+$/;
-/**
-* An optional `int8` from jsonb or `pg`, or `undefined` for null. Block
-* functions send `int8` as text because a JSON number loses precision past
-* 2^53, so a number here is refused instead of read rounded.
-*/
-function optionalBigintOf(value, field) {
-	if (value === null || value === void 0) return;
-	if (typeof value === "bigint") return value;
-	if (typeof value === "string" && INTEGER.test(value)) return BigInt(value);
-	throw new TypeError(`${field} must be an integer sent as text, got ${typeof value === "string" ? JSON.stringify(value) : typeof value}`);
-}
-/** An `int8` that must be there; see `optionalBigintOf`. */
-function bigintOf(value, field) {
-	const found = optionalBigintOf(value, field);
-	if (found === void 0) throw new TypeError(`${field} is missing`);
-	return found;
-}
-/** An optional `timestamptz` as text for a function argument. */
-const instantArg = (value) => value === void 0 ? void 0 : value === null ? null : value.toString();
-/** SHA-256 of `value` as lowercase hex, with WebCrypto. */
-async function sha256Hex(value) {
-	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
-	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-/** `bytes` random bytes as base64url, for secrets and codes. */
-function randomToken(bytes = 24) {
-	const data = crypto.getRandomValues(new Uint8Array(bytes));
-	let binary = "";
-	for (const byte of data) binary += String.fromCodePoint(byte);
-	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/[=]+$/, "");
-}
-function asDbError(cause) {
-	const raw = fromPgError(cause);
-	return raw ? mapDbError(raw) : toDbError(cause);
-}
-function run(fn) {
-	return AsyncResult.from(async () => {
-		try {
-			return ok(await fn());
-		} catch (cause) {
-			return err(asDbError(cause));
-		}
-	});
-}
-/**
-* The request body as text, or `undefined` once it is longer than `limit`
-* bytes. A larger `Content-Length` is refused before reading; otherwise reading
-* stops at the limit, so a body without one can't fill memory.
-*/
-async function readBodyCapped(request, limit) {
-	const length = Number(request.headers.get("content-length") ?? NaN);
-	if (Number.isFinite(length) && length > limit) return;
-	if (!request.body) return "";
-	const reader = request.body.getReader();
-	const chunks = [];
-	let size = 0;
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		size += value.byteLength;
-		if (size > limit) {
-			reader.cancel().catch(() => void 0);
-			return;
-		}
-		chunks.push(value);
-	}
-	const bytes = new Uint8Array(size);
-	let offset = 0;
-	for (const chunk of chunks) {
-		bytes.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return new TextDecoder().decode(bytes);
-}
-function seconds(value) {
-	return typeof value === "number" ? `${String(value)} seconds` : value;
-}
-function workerId() {
-	return `worker-${crypto.randomUUID().slice(0, 8)}`;
-}
-/**
-* Runs `fn` over `items` with at most `limit` calls in flight. After the first
-* rejection no new item starts; the ones running finish, then it rethrows.
-*/
-async function eachLimit(items, limit, fn) {
-	let next = 0;
-	let failure;
-	const lane = async () => {
-		while (failure === void 0 && next < items.length) {
-			const index = next;
-			next += 1;
-			try {
-				await fn(items[index], index);
-			} catch (cause) {
-				failure ??= { cause };
-			}
-		}
-	};
-	await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, lane));
-	if (failure) throw failure.cause;
-}
-const sleep = (ms, signal) => new Promise((resolve) => {
-	if (signal?.aborted) {
-		resolve();
-		return;
-	}
-	const timer = setTimeout(done, ms);
-	function done() {
-		clearTimeout(timer);
-		signal?.removeEventListener("abort", done);
-		resolve();
-	}
-	signal?.addEventListener("abort", done, { once: true });
-});
-/**
-* Pgmq and the inbox return `timestamptz` as text over RPC and as `Date` from
-* `pg`.
-*/
-const toInstant = (value) => value instanceof Date ? temporal().Instant.fromEpochMilliseconds(value.getTime()) : temporal().Instant.from(value);
-function errorText(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
-	return String(error);
-}
-function injectableOf(what, value) {
-	if (value === void 0) return;
-	const version = value.apiVersion;
-	if (version !== void 0 && version !== 1) throw new TypeError(`${what} targets API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release built for API 1.`);
-	return value;
-}
-/** Reads `limit` and `cursor` from a list's options. */
-function pageOf(options = {}) {
-	return {
-		limit: options.limit,
-		cursor: options.cursor
-	};
-}
-/**
-* The per-event results of a batched block function (`audit_event_many`,
-* `publish_webhook_events`, `send_notifications`), in the order of the events:
-* `{ [key]: value }` becomes `ok(then(value))` and `{ error }` a `DbError`
-* through the app's mappers. An event the reply leaves out is `unexpected`.
-*/
-function batchResultsOf(value, count, key, then, mappers = []) {
-	const rows = Array.isArray(value) ? value : [];
-	return Array.from({ length: count }, (_, index) => {
-		const row = rows[index];
-		if (isRecord(row) && isRecord(row["error"])) return err(toBlockError(row["error"], mappers));
-		if (isRecord(row) && key in row) return ok(then(row[key]));
-		return err(dbError("unexpected", `The batch reply has no result for event ${index}`));
-	});
-}
-/** `items` in consecutive chunks of at most `size`. */
-function chunksOf(items, size) {
-	const chunks = [];
-	for (let start = 0; start < items.length; start += size) chunks.push(items.slice(start, start + size));
-	return chunks;
-}
-//#endregion
-export { requiredInstant as A, dbTransport as B, optionalText as C, recordOf as D, readBodyCapped as E, stringsOf as F, rpcTransport as H, textOf as I, toBlockError as L, seconds as M, sha256Hex as N, recordOrEmpty as O, sleep as P, toInstant as R, optionalInstant as S, randomToken as T, sqlTransport as U, rawError as V, notFoundError as _, bigintOf as a, oneOf as b, chunksOf as c, enumOrThrow as d, errorText as f, leaseHeartbeat as g, instantOf as h, batchResultsOf as i, run as j, recordsOf as k, credentialRefOf as l, instantArg as m, applyTemporal as n, blockCall as o, injectableOf as p, asDbError as r, budget as s, DEFAULT_BLOCK_SCHEMA as t, eachLimit as u, nullableInstant as v, pageOf as w, optionalBigintOf as x, nullableText as y, workerId as z };