better-supabase 0.13.0 → 0.14.0

package/dist/block-names-Dbv_2wmE.js

@@ -0,0 +1,66 @@
+import { i as entityNames, o as tenantNames, r as composeNames } from "./entity-naming-DLDhHTbK.js";
+import { t as defineTransportMiddleware } from "./block-hooks-BymdcD0V.js";
+//#region src/core/block-names.ts
+const TENANT_COLUMNS = ["organization_id", "active_organization_id"];
+const OPAQUE_KEYS = /* @__PURE__ */ new Set(["fields", "metadata"]);
+const KEY_VALUES = /* @__PURE__ */ new Set(["field"]);
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function renameEntry(key, value, rename) {
+	if (OPAQUE_KEYS.has(key)) return value;
+	if (KEY_VALUES.has(key) && typeof value === "string") return rename(value);
+	return renameKeys(value, rename);
+}
+/**
+* `value` with every key of every plain object in it passed through `rename`,
+* and the column a `field` names, leaving the values under `fields` and
+* `metadata` alone.
+*/
+function renameKeys(value, rename) {
+	if (Array.isArray(value)) return value.map((each) => renameKeys(each, rename));
+	if (!isPlainObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, each]) => [rename(key), renameEntry(key, each, rename)]));
+}
+/** The arguments with the keys nested inside them renamed; parameter names stay. */
+function renameArgs(args, entities) {
+	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, renameEntry(key, value, (each) => entities.rename(each))]));
+}
+/**
+* Transport middleware that calls each block function by the name the SQL wrote
+* it under and translates the payload keys: `create_organization` becomes
+* `create_workspace` with `tenant: "workspace"`, `list_work_items` becomes
+* `list_tasks` with `work_item` renamed to `task`, then `functions` renames
+* single functions. Keys inside the arguments (`projectId`) go out renamed, and
+* the keys of the result come back by their default names, so the block's
+* client reads what it always has. Wrap a block's transport with it when the
+* config sets `blocks.<name>.entities` or `blocks.<name>.functions`;
+* `defineBlocks` does it from `blocks.generated.ts`.
+*/
+function blockNames(naming) {
+	const tenant = tenantNames(naming.tenant);
+	const entities = entityNames(naming.entities);
+	const names = composeNames(tenant, entities);
+	const functions = naming.functions ?? {};
+	const rename = (fn) => {
+		const renamed = names.rename(fn);
+		return functions[fn] ?? functions[renamed] ?? renamed;
+	};
+	const columns = new Map(TENANT_COLUMNS.map((column) => [tenant.rename(column), column]));
+	const restore = (key) => columns.get(key) ?? entities.reverse(key);
+	return defineTransportMiddleware({
+		name: "block-names",
+		call: async (request, next) => {
+			const result = await next({
+				...request,
+				fn: rename(request.fn),
+				...entities.renamed ? { args: renameArgs(request.args, entities) } : {}
+			});
+			return names.renamed ? renameKeys(result, restore) : result;
+		}
+	});
+}
+//#endregion
+export { renameKeys as n, blockNames as t };

package/dist/block-subjects-Dzq5Xn_0.js

@@ -0,0 +1,55 @@
+import { a as ok, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { I as textOf } from "./block-helpers-CiKtrb6g.js";
+//#region src/core/block-subjects.ts
+/** A row's subject columns as a `SubjectRef`. */
+function subjectRefOf(type, id) {
+	return {
+		type: textOf(type),
+		id: textOf(id)
+	};
+}
+/** A row's subject columns as a `SubjectRef`, or `undefined` when unset. */
+function optionalSubjectRefOf(type, id) {
+	return typeof type === "string" && type !== "" && (typeof id === "string" || typeof id === "number") ? {
+		type,
+		id: String(id)
+	} : void 0;
+}
+/**
+* The ids of `subjects` grouped by type, in first-seen order and without
+* repeats, for functions that take one subject type and many ids.
+*/
+function subjectIdsByType(subjects) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const subject of subjects) {
+		const ids = grouped.get(subject.type) ?? [];
+		if (!ids.includes(subject.id)) ids.push(subject.id);
+		grouped.set(subject.type, ids);
+	}
+	return grouped;
+}
+/** The map key of a subject in a batch result: `type:id`. */
+function subjectKey(subject) {
+	return `${subject.type}:${subject.id}`;
+}
+/**
+* One call per subject type over `subjects`, the results merged into one record
+* keyed by `subjectKey` (`type:id`). The first error wins.
+*/
+function bySubjectType(subjects, call) {
+	return AsyncResult.from(async () => {
+		const merged = {};
+		const groups = [...subjectIdsByType(subjects)];
+		const results = await Promise.all(groups.map(async ([type, ids]) => [type, await call(type, ids)]));
+		for (const [type, result] of results) {
+			if (!result.ok) return result;
+			for (const [id, value] of Object.entries(result.data)) merged[subjectKey({
+				type,
+				id
+			})] = value;
+		}
+		return ok(merged);
+	});
+}
+//#endregion
+export { subjectRefOf as i, optionalSubjectRefOf as n, subjectKey as r, bySubjectType as t };

package/dist/block-subjects-FHwLlIHU.d.ts

@@ -0,0 +1,6 @@
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+//#region src/core/block-subjects.d.ts
+/** The map key of a subject in a batch result: `type:id`. */
+declare function subjectKey(subject: SubjectRef): string;
+//#endregion
+export { subjectKey as t };

package/dist/block-tenant-C1sNV8_4.js

@@ -0,0 +1,14 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { t as AsyncResult } from "./result-B3m7xtRY.js";
+import { t as currentTenant } from "./tenant-source-bqWpSr86.js";
+//#region src/core/block-tenant.ts
+/**
+* Reads the tenant for one call: `invalid_request` with the hint
+* `TENANT_REQUIRED` when there is none.
+*/
+function requireTenant(source) {
+	const tenant = currentTenant(source);
+	return tenant === void 0 ? AsyncResult.err(dbError("invalid_request", "No tenant is active: pass `tenant` to the block, or call it from a request that has one", { hint: "TENANT_REQUIRED" })) : AsyncResult.ok(tenant);
+}
+//#endregion
+export { requireTenant as t };

package/dist/block-transport-d53POsem.d.ts

@@ -0,0 +1,69 @@
+import { r as Executor } from "./executor-CPyrQdjh.js";
+import { n as SqlClient } from "./executor-CsTaO3AT.js";
+//#region src/core/block-transport.d.ts
+/**
+ * Calls a block function as the current user and resolves with its result.
+ * Rejects with the raw database error (a `pg` error or a PostgREST error
+ * object), which the block maps to a `DbError`.
+ */
+interface BlockTransport {
+  call(schema: string, fn: string, args: Readonly<Record<string, unknown>>): Promise<unknown>;
+}
+/**
+ * Calls the functions over Postgres, as the user `client` runs as:
+ * `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
+ */
+declare function sqlTransport(client: SqlClient): BlockTransport;
+interface RpcResponse {
+  readonly data: unknown;
+  readonly error: unknown;
+}
+/**
+ * The part of a supabase-js client `rpcTransport` uses. The parameters are
+ * `never` so a typed `SupabaseClient<Database>` fits too: its `schema` and
+ * `rpc` only take the names its `Database` declares, which never include the
+ * block functions of a schema the types leave out.
+ */
+interface RpcClient {
+  schema(name: never): {
+    rpc(fn: never, args: never): PromiseLike<RpcResponse>;
+  };
+}
+/** Options for `rpcTransport`. */
+interface RpcTransportOptions {
+  /**
+   * The exposed schema that holds the block's entry points, such as `api` from
+   * `blocks.<module>.api`. Every call goes there instead of the module schema,
+   * which stays out of `[api] schemas` (doctor BS312).
+   */
+  readonly schema?: string;
+}
+/**
+ * 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.
+ */
+declare function rpcTransport(client: RpcClient, options?: RpcTransportOptions): BlockTransport;
+/** Options for `dbTransport`. */
+interface DbTransportOptions {
+  /**
+   * The schema every call goes to instead of the module schema, such as the API
+   * schema from `blocks.<module>.api`. Over PostgREST it has to be exposed;
+   * over Postgres any schema the caller may use works.
+   */
+  readonly schema?: string;
+}
+/** The part of a `Db` that `dbTransport` uses. */
+interface DbTransportSource {
+  readonly $executor: Executor;
+}
+/**
+ * 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.
+ */
+declare function dbTransport(db: DbTransportSource, options?: DbTransportOptions): BlockTransport;
+//#endregion
+export { dbTransport as a, RpcClient as i, DbTransportOptions as n, rpcTransport as o, DbTransportSource as r, sqlTransport as s, BlockTransport as t };

package/dist/blocks/access/index.d.ts

@@ -0,0 +1,9 @@
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
+import { c as BlockOf } from "../../define-block-COpcS6aT.js";
+import { B as PermissionFlags, H as can, U as permissionFlags, V as PermissionSet, W as permissionMatches } from "../../index-DbXWcrOI.js";
+import { a as PermissionsSnapshot, c as Access, d as createAccess, i as PermissionsControllerOptions, l as AccessCallOptions, n as PermissionsActions, o as batchPermissions, r as PermissionsController, s as createPermissionsController, t as PermissionSource, u as AccessOptions } from "../../client-LngH55pZ.js";
+//#region src/blocks/access/manifest.d.ts
+/** The `access` block's manifest (ADR 0029). */
+export declare const accessBlock: BlockOf<"access", typeof createAccess>;
+//#endregion
+export { type Access, type AccessCallOptions, type AccessOptions, type BlockTransport, type PermissionFlags, type PermissionSet, type PermissionSource, type PermissionsActions, type PermissionsController, type PermissionsControllerOptions, type PermissionsSnapshot, batchPermissions, can, createAccess, createPermissionsController, dbTransport, permissionFlags, permissionMatches, rpcTransport, sqlTransport };

package/dist/blocks/access/index.js

@@ -0,0 +1,18 @@
+import { t as accessSqlOptions } from "../../options-a-28mlYT.js";
+import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CiKtrb6g.js";
+import { n as permissionFlags, r as permissionMatches, t as can } from "../../permissions-BetA_Fo_.js";
+import { n as defineBlock } from "../../define-block-Dze77QTw.js";
+import { t as createAccess } from "../../access-z7NwWtqx.js";
+import { n as createPermissionsController, t as batchPermissions } from "../../client-BtRx0-kn.js";
+//#region src/blocks/access/manifest.ts
+/** The `access` block's manifest (ADR 0029). */
+const accessBlock = defineBlock({
+	name: "access",
+	sql: ["access"],
+	options: { access: accessSqlOptions },
+	create: createAccess,
+	category: "identity",
+	recipes: ["can"]
+});
+//#endregion
+export { accessBlock, batchPermissions, can, createAccess, createPermissionsController, dbTransport, permissionFlags, permissionMatches, rpcTransport, sqlTransport };

package/dist/blocks/access/react/index.d.ts

@@ -0,0 +1,52 @@
+import { V as PermissionSet } from "../../../index-DbXWcrOI.js";
+import { a as PermissionsSnapshot, n as PermissionsActions } from "../../../client-LngH55pZ.js";
+import { ReactNode } from "react";
+//#region src/blocks/access/react/index.d.ts
+export interface UsePermissionsOptions {
+  /** The organization to check in. Default the client's tenant. */
+  readonly tenant?: string;
+}
+export interface PermissionsState<K extends string = string> extends PermissionsSnapshot, PermissionsActions {
+  /** Whether the caller holds `key`; false while loading. */
+  readonly can: (key: K) => boolean;
+}
+/**
+ * Which of `keys` the caller holds in the client's tenant, through the access
+ * contract. The hooks rendered in the same tick share one `my_permissions`
+ * call. UX only: RLS checks every key again.
+ *
+ * ```tsx
+ * const { can } = usePermissions([permissions.invoices.write]);
+ * ```
+ */
+export declare function usePermissions<const K extends string>(keys: readonly K[], options?: UsePermissionsOptions): PermissionsState<K>;
+/**
+ * Whether the caller holds `key` in the client's tenant: `undefined` while it
+ * loads, then true or false.
+ *
+ * ```tsx
+ * const canEdit = usePermission(permissions.invoices.write);
+ * ```
+ */
+export declare function usePermission<const K extends string>(key: K, options?: UsePermissionsOptions): boolean | undefined;
+export interface CanProps<K extends string = string> {
+  /** The permission key, such as `permissions.invoices.write`. */
+  readonly permission: K;
+  /** The organization to check in. Default the client's tenant. */
+  readonly tenant?: string;
+  /** Shown while loading and when the caller lacks the key. Default nothing. */
+  readonly fallback?: ReactNode;
+  readonly children?: ReactNode;
+}
+/**
+ * Renders `children` when the caller holds `permission`, else `fallback`.
+ *
+ * ```tsx
+ * <Can permission={permissions.invoices.write}>
+ *   <Button>Edit</Button>
+ * </Can>;
+ * ```
+ */
+export declare function Can<const K extends string>(props: CanProps<K>): ReactNode;
+//#endregion
+export type { PermissionSet };

package/dist/blocks/access/react/index.js

@@ -0,0 +1,73 @@
+"use client";
+import { t as useController } from "../../../react-controller-CKSdtJ10.js";
+import { n as useBlockTenant, t as useBlockEnv } from "../../../react-env-CfA3EdBH.js";
+import { t as can } from "../../../permissions-BetA_Fo_.js";
+import { t as createAccess } from "../../../access-z7NwWtqx.js";
+import { n as createPermissionsController, t as batchPermissions } from "../../../client-BtRx0-kn.js";
+import { t as envBlockOptions } from "../../../block-env-options-2e6IQrSw.js";
+//#region src/blocks/access/react/index.ts
+const sources = /* @__PURE__ */ new WeakMap();
+/** One batched access client per supabase-js client, shared by its hooks. */
+function sourceOf(env) {
+	let source = sources.get(env.supabase);
+	if (source === void 0) {
+		source = batchPermissions(createAccess(envBlockOptions(env, "access")));
+		sources.set(env.supabase, source);
+	}
+	return source;
+}
+/**
+* Which of `keys` the caller holds in the client's tenant, through the access
+* contract. The hooks rendered in the same tick share one `my_permissions`
+* call. UX only: RLS checks every key again.
+*
+* ```tsx
+* const { can } = usePermissions([permissions.invoices.write]);
+* ```
+*/
+function usePermissions(keys, options = {}) {
+	const env = useBlockEnv();
+	const current = useBlockTenant(env);
+	const tenant = options.tenant ?? current;
+	const key = [...new Set(keys)].toSorted().join("\n");
+	const { view } = useController(() => createPermissionsController({
+		client: sourceOf(env),
+		auth: env.auth,
+		keys: key === "" ? [] : key.split("\n"),
+		tenant
+	}), [
+		env,
+		tenant,
+		key
+	]);
+	return {
+		...view,
+		can: (wanted) => can(view.permissions, wanted)
+	};
+}
+/**
+* Whether the caller holds `key` in the client's tenant: `undefined` while it
+* loads, then true or false.
+*
+* ```tsx
+* const canEdit = usePermission(permissions.invoices.write);
+* ```
+*/
+function usePermission(key, options = {}) {
+	const { permissions, can: holds } = usePermissions([key], options);
+	return permissions === void 0 ? void 0 : holds(key);
+}
+/**
+* Renders `children` when the caller holds `permission`, else `fallback`.
+*
+* ```tsx
+* <Can permission={permissions.invoices.write}>
+*   <Button>Edit</Button>
+* </Can>;
+* ```
+*/
+function Can(props) {
+	return usePermission(props.permission, props.tenant === void 0 ? {} : { tenant: props.tenant }) === true ? props.children : props.fallback ?? null;
+}
+//#endregion
+export { Can, usePermission, usePermissions };

package/dist/blocks/access/react/server.d.ts

@@ -0,0 +1,11 @@
+import { V as PermissionSet } from "../../../index-DbXWcrOI.js";
+import { Can as Can$1, CanProps, PermissionsState, UsePermissionsOptions, usePermission as usePermission$1, usePermissions as usePermissions$1 } from "./index.js";
+//#region src/blocks/access/react/server.d.ts
+/** The `react-server` build of `usePermissions`. */
+export declare const usePermissions: typeof usePermissions$1;
+/** The `react-server` build of `usePermission`. */
+export declare const usePermission: typeof usePermission$1;
+/** The `react-server` build of `<Can>`. */
+export declare const Can: typeof Can$1;
+//#endregion
+export type { CanProps, PermissionSet, PermissionsState, UsePermissionsOptions };

package/dist/blocks/access/react/server.js

@@ -0,0 +1,16 @@
+//#region src/blocks/access/react/server.ts
+const clientOnly = (name) => /* @__PURE__ */ new Error(`better-supabase: ${name} runs in Client Components only. In Server Components call \`bs.blocks.client(db, "access").permissions(keys)\` and \`can(set, key)\` from \`better-supabase/blocks/access\` instead.`);
+/** The `react-server` build of `usePermissions`. */
+const usePermissions = () => {
+	throw clientOnly("usePermissions()");
+};
+/** The `react-server` build of `usePermission`. */
+const usePermission = () => {
+	throw clientOnly("usePermission()");
+};
+/** The `react-server` build of `<Can>`. */
+const Can = () => {
+	throw clientOnly("<Can>");
+};
+//#endregion
+export { Can, usePermission, usePermissions };

package/dist/blocks/access/solid/index.d.ts

@@ -0,0 +1,13 @@
+import { a as PermissionsSnapshot, i as PermissionsControllerOptions, n as PermissionsActions } from "../../../client-LngH55pZ.js";
+import { t as BlockOptions } from "../../../block-env-kFcaaJLM.js";
+import { t as SolidController } from "../../../solid-bind-C1jeq4Qm.js";
+//#region src/blocks/access/solid/index.d.ts
+/**
+ * `createPermissionsController` as a Solid primitive: `state()` reads the
+ * snapshot. Call it in a component; the work starts on mount and the controller
+ * is disposed with the owner. `auth` and `ports` default to the client of
+ * `<BetterSupabaseProvider client={bs}>`.
+ */
+export declare function usePermissions<K extends string>(options: BlockOptions<PermissionsControllerOptions<K>>): SolidController<PermissionsSnapshot, PermissionsActions>;
+//#endregion
+export type { BlockOptions, PermissionsActions, PermissionsControllerOptions, PermissionsSnapshot, SolidController };

package/dist/blocks/access/solid/index.js

@@ -0,0 +1,14 @@
+import { t as useBlockController } from "../../../solid-controller-DGuv7V8a.js";
+import { n as createPermissionsController } from "../../../client-BtRx0-kn.js";
+//#region src/blocks/access/solid/index.ts
+/**
+* `createPermissionsController` as a Solid primitive: `state()` reads the
+* snapshot. Call it in a component; the work starts on mount and the controller
+* is disposed with the owner. `auth` and `ports` default to the client of
+* `<BetterSupabaseProvider client={bs}>`.
+*/
+function usePermissions(options) {
+	return useBlockController(createPermissionsController, options);
+}
+//#endregion
+export { usePermissions };

package/dist/blocks/access/svelte/index.d.ts

@@ -0,0 +1,13 @@
+import { a as PermissionsSnapshot, i as PermissionsControllerOptions, n as PermissionsActions } from "../../../client-LngH55pZ.js";
+import { t as BlockOptions } from "../../../block-env-kFcaaJLM.js";
+import { t as SvelteController } from "../../../svelte-bind-Ja6CtQGp.js";
+//#region src/blocks/access/svelte/index.d.ts
+/**
+ * `createPermissionsController` as a Svelte readable store of the snapshot,
+ * with the actions on `.actions`. Call it in a component's script; the work
+ * starts on mount and the controller is disposed with the component. `auth` and
+ * `ports` default to the client of `setBetterSupabase(bs)`.
+ */
+export declare function usePermissions<K extends string>(options: BlockOptions<PermissionsControllerOptions<K>>): SvelteController<PermissionsSnapshot, PermissionsActions>;
+//#endregion
+export type { BlockOptions, PermissionsActions, PermissionsControllerOptions, PermissionsSnapshot, SvelteController };

package/dist/blocks/access/svelte/index.js

@@ -0,0 +1,14 @@
+import { t as useBlockController } from "../../../svelte-controller-oFKC9AYu.js";
+import { n as createPermissionsController } from "../../../client-BtRx0-kn.js";
+//#region src/blocks/access/svelte/index.ts
+/**
+* `createPermissionsController` as a Svelte readable store of the snapshot,
+* with the actions on `.actions`. Call it in a component's script; the work
+* starts on mount and the controller is disposed with the component. `auth` and
+* `ports` default to the client of `setBetterSupabase(bs)`.
+*/
+function usePermissions(options) {
+	return useBlockController(createPermissionsController, options);
+}
+//#endregion
+export { usePermissions };

package/dist/blocks/access/vue/index.d.ts

@@ -0,0 +1,13 @@
+import { a as PermissionsSnapshot, i as PermissionsControllerOptions, n as PermissionsActions } from "../../../client-LngH55pZ.js";
+import { t as BlockOptions } from "../../../block-env-kFcaaJLM.js";
+import { t as VueController } from "../../../vue-bind-TPkbLl4z.js";
+//#region src/blocks/access/vue/index.d.ts
+/**
+ * `createPermissionsController` as a Vue composable: `state` is a shallow ref
+ * of the snapshot. Call it in `setup` or an effect scope; the work starts on
+ * mount and the controller is disposed with the scope. `auth` and `ports`
+ * default to the client of `app.use(betterSupabase(bs))`.
+ */
+export declare function usePermissions<K extends string>(options: BlockOptions<PermissionsControllerOptions<K>>): VueController<PermissionsSnapshot, PermissionsActions>;
+//#endregion
+export type { BlockOptions, PermissionsActions, PermissionsControllerOptions, PermissionsSnapshot, VueController };

package/dist/blocks/access/vue/index.js

@@ -0,0 +1,14 @@
+import { t as useBlockController } from "../../../vue-controller-WtbuT-Ux.js";
+import { n as createPermissionsController } from "../../../client-BtRx0-kn.js";
+//#region src/blocks/access/vue/index.ts
+/**
+* `createPermissionsController` as a Vue composable: `state` is a shallow ref
+* of the snapshot. Call it in `setup` or an effect scope; the work starts on
+* mount and the controller is disposed with the scope. `auth` and `ports`
+* default to the client of `app.use(betterSupabase(bs))`.
+*/
+function usePermissions(options) {
+	return useBlockController(createPermissionsController, options);
+}
+//#endregion
+export { usePermissions };

package/dist/blocks/access-requests/index.d.ts

@@ -1,13 +1,13 @@
 /// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "../../result-mijqfoJN.js";
-import { t as StandardSchemaV1 } from "../../standard-16AIDny5.js";
-import { r as FieldsOf } from "../../block-fields-DnXkMney.js";
-import { f as AccessRequestEventData, wt as Events } from "../../events-DhGgwqQA.js";
+import { T as ErrorMapper, t as AsyncResult } from "../../result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "../../standard-DbQsD2xZ.js";
+import { r as FieldsOf } from "../../block-fields-3w4MZr8U.js";
+import { Ct as Events, f as AccessRequestEventData } from "../../events-DbLjvxDX.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-DyA5BAW4.js";
-import { n as BlockHooks } from "../../block-hooks-BadAniNI.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-BaugZlJV.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
+import { n as BlockHooks } from "../../block-hooks-CmjPKqQ_.js";
+import { c as BlockOf } from "../../define-block-COpcS6aT.js";
 //#region src/blocks/access-requests/access-requests.d.ts
 interface AccessRequestsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
   readonly transport: BlockTransport;

package/dist/blocks/access-requests/index.js

@@ -1,12 +1,11 @@
-import { t as temporal } from "../../temporal-required-Dt4mcPsi.js";
-import { t as AsyncResult } from "../../result-DIT_qp4G.js";
+import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
+import { t as AsyncResult } from "../../result-B3m7xtRY.js";
 import { t as accessRequestsSqlOptions } from "../../options-Ctac2R0Q.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, U as sqlTransport, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "../../block-hooks-BymdcD0V.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-Ds0C2mUf.js";
-import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-DwE32_gT.js";
-import { r as withBlockHooks } from "../../block-hooks-C1r-R2r0.js";
-import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "../../block-fields-Cwd4c8m-.js";
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "../../block-fields-DBSJSeaO.js";
+import { n as defineBlock } from "../../define-block-Dze77QTw.js";
 //#region src/blocks/access-requests/access-requests.ts
 const STATUSES = [
 	"pending",