better-supabase 0.11.0 → 0.13.0

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

@@ -0,0 +1,43 @@
+import { T as ErrorMapper, t as AsyncResult } from "./result-mijqfoJN.js";
+import { t as BlockTransport } from "./block-transport-DBPhgF3W.js";
+//#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 {
+  /**
+   * `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 { CursorPageOptions as i, BlockOptions as n, BlockTemporalOptions as r, BlockCall as t };

package/dist/block-hooks-BadAniNI.d.ts

@@ -0,0 +1,117 @@
+import { T as ErrorMapper, b as DbError, f as Result, t as AsyncResult } from "./result-mijqfoJN.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as BlockTransport } from "./block-transport-DBPhgF3W.js";
+import { t as BlockCall } from "./block-helpers-DyA5BAW4.js";
+//#region src/core/block-hooks.d.ts
+/** A block method: anything that returns an `AsyncResult`. */
+type BlockMethod = (...args: never[]) => AsyncResult<unknown>;
+/** The names of a block client's methods that return an `AsyncResult`. */
+type BlockMethodName<C> = { [K in keyof C]: C[K] extends BlockMethod ? K : never; }[keyof C] & string;
+type ArgsOf<F> = F extends ((...args: infer A) => AsyncResult<unknown>) ? A : never;
+type DataOf<F> = F extends ((...args: never[]) => AsyncResult<infer T>) ? T : never;
+/** Which call a hook runs for. */
+interface BlockHookInfo {
+  /** The block, as `createBlocks` names it, or the name `withBlockHooks` got. */
+  readonly block: string;
+  readonly method: string;
+}
+/**
+ * Hooks for one block method. `before` runs first: return nothing to keep the
+ * arguments, a new argument list to replace them, or a `DbError` to refuse the
+ * call, which then returns that error without reaching the database. `after`
+ * observes a copy of the result and can't change it; when it throws, the logger
+ * gets the error and the caller still gets the result.
+ */
+interface BlockMethodHooks<A extends readonly unknown[], T> {
+  readonly before?: (args: A, info: BlockHookInfo) => Readonly<A> | DbError | void | Promise<Readonly<A> | DbError | void>;
+  readonly after?: (result: Result<T>, args: A, info: BlockHookInfo) => void | Promise<void>;
+}
+/** Hooks keyed by the block client's method names. */
+type BlockHooks<C> = { readonly [K in BlockMethodName<C>]?: BlockMethodHooks<ArgsOf<C[K]>, DataOf<C[K]>>; };
+interface WithBlockHooksOptions {
+  /** The block's name in `BlockHookInfo` and log messages. Default `block`. */
+  readonly block?: string;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/**
+ * Runs `hooks` around a block client's methods. Use it to add a rule the block
+ * doesn't know (refuse `invite` above a seat limit), rewrite arguments (fill a
+ * default), or observe results (metrics, an audit line). Methods without hooks
+ * are unchanged.
+ *
+ * ```ts
+ * const orgs = withBlockHooks(createOrganizations(options), {
+ *   invite: {
+ *     before: ([input]) =>
+ *       input.role === "owner"
+ *         ? dbError("forbidden", "Owners are added by support")
+ *         : undefined,
+ *   },
+ * });
+ * ```
+ */
+declare function withBlockHooks<C extends object>(client: C, hooks: BlockHooks<C> | undefined, options?: WithBlockHooksOptions): C;
+/** What `extendBlock` hands the builder besides the base client. */
+interface ExtendBlockTools {
+  /**
+   * Calls a SQL function in the block's schema over its transport and maps a
+   * rejection to a `DbError`, as the block's own methods do. Needs the
+   * `transport` option.
+   */
+  readonly call: BlockCall;
+}
+interface ExtendBlockOptions {
+  /** The transport `call` uses: the one the block was created with. */
+  readonly transport?: BlockTransport;
+  /** The schema `call` targets. Default `better_supabase`. */
+  readonly schema?: string;
+  /** Error mappers `call` runs before the built-in ones. */
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * Adds methods to a block client. The builder gets the base client, so a new
+ * method can compose existing ones, and `call` for SQL functions the app adds
+ * to the block's schema. Redefining a base method throws: wrap it with
+ * `withBlockHooks` instead.
+ *
+ * ```ts
+ * const orgs = extendBlock(
+ *   createOrganizations(options),
+ *   (base, { call }) => ({
+ *     archive: (id: string) =>
+ *       call("archive_organization", { id }, () => undefined),
+ *   }),
+ *   { transport: options.transport },
+ * );
+ * ```
+ */
+declare function extendBlock<C extends object, X extends object>(client: C, build: (base: C, tools: ExtendBlockTools) => X, options?: ExtendBlockOptions): C & X;
+/** One transport call, as middleware sees it. */
+interface BlockTransportRequest {
+  readonly schema: string;
+  readonly fn: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+/**
+ * Runs around every call a transport makes: tracing, a statement timeout, an
+ * extra argument every function takes. Pass a changed request to `next` to
+ * rewrite it. Reject with the error `next` rejected with so the block still
+ * maps it to a `DbError`.
+ */
+interface BlockTransportMiddleware {
+  readonly apiVersion: 1;
+  readonly name: string;
+  call(request: BlockTransportRequest, next: (request: BlockTransportRequest) => Promise<unknown>): Promise<unknown>;
+}
+/** Fills in `apiVersion: 1`. */
+declare function defineTransportMiddleware(middleware: Omit<BlockTransportMiddleware, "apiVersion"> & {
+  readonly apiVersion?: 1;
+}): BlockTransportMiddleware;
+/**
+ * A transport that runs `middleware` around `transport`, the first one
+ * outermost. Throws when a middleware targets an API other than 1.
+ */
+declare function wrapTransport(transport: BlockTransport, ...middleware: readonly BlockTransportMiddleware[]): BlockTransport;
+//#endregion
+export { BlockTransportMiddleware as a, ExtendBlockTools as c, extendBlock as d, withBlockHooks as f, BlockMethodName as i, WithBlockHooksOptions as l, BlockHooks as n, BlockTransportRequest as o, wrapTransport as p, BlockMethodHooks as r, ExtendBlockOptions as s, BlockHookInfo as t, defineTransportMiddleware as u };

package/dist/block-hooks-C1r-R2r0.js

@@ -0,0 +1,130 @@
+import { n as dbError, o as isDbError } from "./errors-D7u24ZJH.js";
+import { r as err, t as AsyncResult } from "./result-DIT_qp4G.js";
+import { t as consoleLogger } from "./logger-glM28NVN.js";
+import { o as blockCall } from "./block-helpers-DwE32_gT.js";
+//#region src/core/block-hooks.ts
+const isPlainObject = (value) => {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+/**
+* A copy of plain objects and arrays; class instances (Temporal values) are
+* immutable and stay shared.
+*/
+function copyOf(value) {
+	if (Array.isArray(value)) return value.map(copyOf);
+	if (typeof value === "object" && value !== null && isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyOf(entry)]));
+	return value;
+}
+/**
+* A new client with the same methods: a spread for object literals, a child
+* object otherwise.
+*/
+function cloneClient(client) {
+	if (isPlainObject(client)) return { ...client };
+	return Object.create(client);
+}
+/** The client's method named `name`, or undefined when it has none. */
+function methodOf(client, name) {
+	const value = client[name];
+	if (typeof value !== "function") return;
+	return value;
+}
+/**
+* Runs `hooks` around a block client's methods. Use it to add a rule the block
+* doesn't know (refuse `invite` above a seat limit), rewrite arguments (fill a
+* default), or observe results (metrics, an audit line). Methods without hooks
+* are unchanged.
+*
+* ```ts
+* const orgs = withBlockHooks(createOrganizations(options), {
+*   invite: {
+*     before: ([input]) =>
+*       input.role === "owner"
+*         ? dbError("forbidden", "Owners are added by support")
+*         : undefined,
+*   },
+* });
+* ```
+*/
+function withBlockHooks(client, hooks, options = {}) {
+	if (hooks === void 0) return client;
+	const block = options.block ?? "block";
+	const logger = options.logger ?? consoleLogger;
+	const wrapped = cloneClient(client);
+	for (const [method, hook] of Object.entries(hooks)) {
+		if (hook === void 0) continue;
+		const original = methodOf(client, method);
+		if (original === void 0) throw new TypeError(`better-supabase: ${block} has no method "${method}" to hook`);
+		const { before, after } = hook;
+		const info = {
+			block,
+			method
+		};
+		wrapped[method] = (...args) => AsyncResult.from(async () => {
+			let current = args;
+			if (before) {
+				const outcome = await before(current, info);
+				if (isDbError(outcome)) return err(outcome);
+				if (Array.isArray(outcome)) current = outcome;
+			}
+			const result = await original.apply(client, current);
+			if (after) try {
+				await after(copyOf(result), current, info);
+			} catch (cause) {
+				logger.error(`${block}.${method} after hook threw`, { cause });
+			}
+			return result;
+		});
+	}
+	return wrapped;
+}
+/**
+* Adds methods to a block client. The builder gets the base client, so a new
+* method can compose existing ones, and `call` for SQL functions the app adds
+* to the block's schema. Redefining a base method throws: wrap it with
+* `withBlockHooks` instead.
+*
+* ```ts
+* const orgs = extendBlock(
+*   createOrganizations(options),
+*   (base, { call }) => ({
+*     archive: (id: string) =>
+*       call("archive_organization", { id }, () => undefined),
+*   }),
+*   { transport: options.transport },
+* );
+* ```
+*/
+function extendBlock(client, build, options = {}) {
+	const { transport } = options;
+	const additions = build(client, { call: transport ? blockCall(transport, options.schema ?? "better_supabase", options.mappers ?? []) : () => AsyncResult.err(dbError("unsupported", "extendBlock needs the transport option to call SQL functions")) });
+	const taken = Object.keys(additions).filter((key) => key in client);
+	if (taken.length > 0) throw new TypeError(`better-supabase: extendBlock can't redefine ${taken.map((key) => `"${key}"`).join(", ")}; wrap a base method with withBlockHooks instead`);
+	return Object.assign(cloneClient(client), additions);
+}
+/** Fills in `apiVersion: 1`. */
+function defineTransportMiddleware(middleware) {
+	return {
+		...middleware,
+		apiVersion: 1
+	};
+}
+/**
+* A transport that runs `middleware` around `transport`, the first one
+* outermost. Throws when a middleware targets an API other than 1.
+*/
+function wrapTransport(transport, ...middleware) {
+	for (const entry of middleware) {
+		const version = entry.apiVersion;
+		if (version !== 1) throw new TypeError(`better-supabase: transport middleware "${entry.name}" targets API ${String(version)}; this better-supabase supports 1`);
+	}
+	const run = middleware.reduceRight((next, entry) => (request) => entry.call(request, next), (request) => transport.call(request.schema, request.fn, request.args));
+	return { call: (schema, fn, args) => run({
+		schema,
+		fn,
+		args
+	}) };
+}
+//#endregion
+export { wrapTransport as i, extendBlock as n, withBlockHooks as r, defineTransportMiddleware as t };

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

@@ -0,0 +1,69 @@
+import { r as Executor } from "./executor-C29668fO.js";
+import { n as SqlClient } from "./executor-DXfgDsKd.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/block-transport-Ds0C2mUf.js

@@ -0,0 +1,84 @@
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { i as sqlIdent } from "./template-DXsGm_R0.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
+export { sqlTransport as i, rawError as n, rpcTransport as r, dbTransport as t };

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

@@ -1,23 +1,26 @@
 /// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "../../result-BREt7qOh.js";
-import { f as AccessRequestEventData, wt as Events } from "../../events-P3raDX2E.js";
+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 { n as Logger } from "../../logger-DWVYUmwi.js";
-import { t as StandardSchemaV1 } from "../../standard-BcUQuUgu.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-CjcQM1yA.js";
-import { n as BlockHooks } from "../../block-hooks-DcPJHztl.js";
-import { r as FieldsOf } from "../../block-fields-DnaDbgZS.js";
-import { s as BlockOf } from "../../define-block-CPyJ95rq.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";
 //#region src/blocks/access-requests/access-requests.d.ts
 interface AccessRequestsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
   readonly transport: BlockTransport;
-  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
   readonly schema?: string;
   /**
    * A Standard Schema for the request columns the app adds
-   * (`blocks.access-requests.options.extraColumns`), keyed by column name.
-   * It types and parses them on every read, and validates them on
-   * `request`, which returns a `validation` error for a bad value.
+   * (`blocks.access-requests.options.extraColumns`), keyed by column name. It
+   * types and parses them on every read, and validates them on `request`, which
+   * returns a `validation` error for a bad value.
    */
   readonly fields?: S;
   /** `withBlockHooks` hooks around the client's methods. */
@@ -27,8 +30,8 @@ interface AccessRequestsOptions<S extends StandardSchemaV1 | undefined = undefin
   readonly mappers?: readonly ErrorMapper[];
 }
 /**
- * `pending`, `rejected`, `cancelled` and `expired` follow the approval
- * request; `granted` and `ended` follow the role itself.
+ * `pending`, `rejected`, `cancelled` and `expired` follow the approval request;
+ * `granted` and `ended` follow the role itself.
  */
 type AccessRequestStatus = "pending" | "granted" | "rejected" | "cancelled" | "expired" | "ended";
 interface AccessRequest {
@@ -88,7 +91,10 @@ type AccessRequestsEvents = {
   readonly "access.request_approved": AccessRequestEventData;
   readonly "access.ended": AccessRequestEventData;
 };
-/** The `access-requests` block's event types, for its manifest and `onBlockEvent`. */
+/**
+ * The `access-requests` block's event types, for its manifest and
+ * `onBlockEvent`.
+ */
 export declare const accessRequestsEvents: Events<AccessRequestsEvents>;
 //#endregion
 //#region src/blocks/access-requests/manifest.d.ts

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

@@ -1,11 +1,11 @@
-import { t as temporal } from "../../temporal-required-nfZ87U-0.js";
-import { t as AsyncResult } from "../../result-DIeYscA3.js";
+import { t as temporal } from "../../temporal-required-Dt4mcPsi.js";
+import { t as AsyncResult } from "../../result-DIT_qp4G.js";
 import { t as accessRequestsSqlOptions } from "../../options-Ctac2R0Q.js";
-import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-J7ZepTq2.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-DkVZNDrj.js";
-import { r as withBlockHooks } from "../../block-hooks-C22vuIUd.js";
-import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "../../block-fields-Bv1hV855.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";
 //#region src/blocks/access-requests/access-requests.ts
 const STATUSES = [
@@ -77,7 +77,10 @@ function createAccessRequests(options) {
 }
 //#endregion
 //#region src/blocks/access-requests/events.ts
-/** The `access-requests` block's event types, for its manifest and `onBlockEvent`. */
+/**
+* The `access-requests` block's event types, for its manifest and
+* `onBlockEvent`.
+*/
 const accessRequestsEvents = defineEvents({
 	"access.requested": event(),
 	"access.request_approved": event(),

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

@@ -1,7 +1,7 @@
-import { p as AgentEventData, wt as Events } from "../../events-P3raDX2E.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
-import { a as AgentSkill, c as AgentsOptions, i as AgentKnowledgeScope, l as NewAgent, n as AgentFields, o as AgentVisibility, r as AgentFilter, s as Agents, t as Agent, u as createAgents } from "../../agents-CbUIrH-w.js";
-import { s as BlockOf } from "../../define-block-CPyJ95rq.js";
+import { p as AgentEventData, wt as Events } from "../../events-DhGgwqQA.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
+import { a as AgentSkill, c as AgentsOptions, i as AgentKnowledgeScope, l as NewAgent, n as AgentFields, o as AgentVisibility, r as AgentFilter, s as Agents, t as Agent, u as createAgents } from "../../agents-CuxuXVWv.js";
+import { s as BlockOf } from "../../define-block-MyM4lH42.js";
 //#region src/blocks/agents/events.d.ts
 /** The events of the `agents` block: type to data. */
 type AgentsEvents = {

package/dist/blocks/agents/index.js

@@ -1,11 +1,11 @@
-import { t as AsyncResult } from "../../result-DIeYscA3.js";
+import { t as AsyncResult } from "../../result-DIT_qp4G.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
 import { t as agentsSqlOptions } from "../../options-BxcFLL1G.js";
-import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-J7ZepTq2.js";
-import { C as optionalText, D as recordOf, F as stringsOf, I as textOf, S as optionalInstant, _ as notFoundError, h as instantOf, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-DkVZNDrj.js";
-import { r as withBlockHooks } from "../../block-hooks-C22vuIUd.js";
-import { c as withFields, i as extraOf, n as blockFields, t as allWithFields } from "../../block-fields-Bv1hV855.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 { C as optionalText, D as recordOf, F as stringsOf, I as textOf, S as optionalInstant, _ as notFoundError, h as instantOf, 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, i as extraOf, n as blockFields, t as allWithFields } from "../../block-fields-Cwd4c8m-.js";
 import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
 //#region src/blocks/agents/agents.ts
 const VISIBILITIES = /* @__PURE__ */ new Set([

package/dist/blocks/ai-cache/index.d.ts

@@ -1,6 +1,6 @@
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
-import { a as AiCacheSetOptions, i as AiCacheOptions, n as AiCacheEntry, o as cacheKey, r as AiCacheKind, s as createAiCache, t as AiCache } from "../../ai-cache-BdeJKlrV.js";
-import { s as BlockOf } from "../../define-block-CPyJ95rq.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
+import { a as AiCacheSetOptions, i as AiCacheOptions, n as AiCacheEntry, o as cacheKey, r as AiCacheKind, s as createAiCache, t as AiCache } from "../../ai-cache-BXMXRhkx.js";
+import { s as BlockOf } from "../../define-block-MyM4lH42.js";
 //#region src/blocks/ai-cache/manifest.d.ts
 /** The `ai-cache` block's manifest (ADR 0029). */
 export declare const aiCacheBlock: BlockOf<"ai-cache", typeof createAiCache>;

package/dist/blocks/ai-cache/index.js

@@ -1,7 +1,7 @@
 import { t as aiCacheSqlOptions } from "../../options-BlOPivzq.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-J7ZepTq2.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-Ds0C2mUf.js";
 import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { n as createAiCache, t as cacheKey } from "../../ai-cache-CLninP-F.js";
+import { n as createAiCache, t as cacheKey } from "../../ai-cache-Byy5q6EZ.js";
 //#region src/blocks/ai-cache/manifest.ts
 /** The `ai-cache` block's manifest (ADR 0029). */
 const aiCacheBlock = defineBlock({

package/dist/blocks/ai-chat/index.d.ts

@@ -1,12 +1,15 @@
-import { g as AiToolEventData, m as AiChatEventData, wt as Events } from "../../events-P3raDX2E.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
-import { a as AiMessagePart, c as AiReasoningPart, d as AiTextPart, f as AiToolApprovalPart, g as isAiMessage, h as aiMessageSchema, i as AiMessage, l as AiSourcePart, m as AiToolResultPart, n as AiDataPart, o as AiMessagePartType, p as AiToolCallPart, r as AiFilePart, s as AiMessageRole, t as AI_MESSAGE_SCHEMA_ID, u as AiStepPart } from "../../message-B0fNJgq8.js";
-import { $ as AiRunStep, A as AiStoredMessageStatus, B as AiSandbox, C as AiProject, D as AiSaveResult, E as AiRunStatus, F as AiUserMessageTrigger, G as AiHarnessSession, H as AiSandboxStopper, I as SharedAiChat, J as AiHarnessStatus, K as AiHarnessSessionPatch, L as aiChatListTopic, M as AiToolApproval, N as AiToolApprovalRequest, O as AiShareLink, P as AiToolPolicy, Q as AiRunState, R as aiChatTopic, S as AiPendingInputRequest, T as AiRunRelease, U as AiSandboxes, V as AiSandboxStatus, W as NewAiSandbox, X as AiRun, Y as AiPendingApproval, Z as AiRunQuery, _ as AiModerationAction, a as AiChatInput, b as AiModerationStage, c as AiChatPatch, d as AiChatShare, et as AiRunStepInput, f as AiChatVisibility, g as AiModelInput, h as AiModel, i as AiChat, j as AiStreamClaim, k as AiStoredMessage, l as AiChatQuery, m as AiMessageSibling, n as AiApprovalDecision, nt as AiRuns, o as AiChatOptions, p as AiFeedback, q as AiHarnessSessions, r as AiAssistantMessageOptions, rt as createHarnessSessions, s as AiChatPage, t as AiAppendResult, tt as AiRunStepStatus, u as AiChatRecord, v as AiModerationEvent, w as AiProjectInput, x as AiPendingInput, y as AiModerationInput, z as createAiChat } from "../../ai-chat-D-2MH1sU.js";
-import { s as BlockOf } from "../../define-block-CPyJ95rq.js";
-import { _ as createAiChatTreeController, a as AiChatsActions, b as createAiShareController, c as AiChatsSnapshot, d as AiModelsControllerOptions, f as AiModelsSnapshot, g as AiShareSnapshot, h as AiShareControllerOptions, i as AiChatTreeSnapshot, l as AiModelsActions, m as AiShareController, n as AiChatTreeController, o as AiChatsController, p as AiShareActions, r as AiChatTreeControllerOptions, s as AiChatsControllerOptions, t as AiChatTreeActions, u as AiModelsController, v as createAiChatsController, y as createAiModelsController } from "../../client-CNh-pjkT.js";
+import { g as AiToolEventData, m as AiChatEventData, wt as Events } from "../../events-DhGgwqQA.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
+import { a as AiMessagePart, c as AiReasoningPart, d as AiTextPart, f as AiToolApprovalPart, g as isAiMessage, h as aiMessageSchema, i as AiMessage, l as AiSourcePart, m as AiToolResultPart, n as AiDataPart, o as AiMessagePartType, p as AiToolCallPart, r as AiFilePart, s as AiMessageRole, t as AI_MESSAGE_SCHEMA_ID, u as AiStepPart } from "../../message-Bg4TKA12.js";
+import { $ as AiRunStep, A as AiStoredMessageStatus, B as AiSandbox, C as AiProject, D as AiSaveResult, E as AiRunStatus, F as AiUserMessageTrigger, G as AiHarnessSession, H as AiSandboxStopper, I as SharedAiChat, J as AiHarnessStatus, K as AiHarnessSessionPatch, L as aiChatListTopic, M as AiToolApproval, N as AiToolApprovalRequest, O as AiShareLink, P as AiToolPolicy, Q as AiRunState, R as aiChatTopic, S as AiPendingInputRequest, T as AiRunRelease, U as AiSandboxes, V as AiSandboxStatus, W as NewAiSandbox, X as AiRun, Y as AiPendingApproval, Z as AiRunQuery, _ as AiModerationAction, a as AiChatInput, b as AiModerationStage, c as AiChatPatch, d as AiChatShare, et as AiRunStepInput, f as AiChatVisibility, g as AiModelInput, h as AiModel, i as AiChat, j as AiStreamClaim, k as AiStoredMessage, l as AiChatQuery, m as AiMessageSibling, n as AiApprovalDecision, nt as AiRuns, o as AiChatOptions, p as AiFeedback, q as AiHarnessSessions, r as AiAssistantMessageOptions, rt as createHarnessSessions, s as AiChatPage, t as AiAppendResult, tt as AiRunStepStatus, u as AiChatRecord, v as AiModerationEvent, w as AiProjectInput, x as AiPendingInput, y as AiModerationInput, z as createAiChat } from "../../ai-chat-B00sIOjY.js";
+import { s as BlockOf } from "../../define-block-MyM4lH42.js";
+import { _ as createAiChatTreeController, a as AiChatsActions, b as createAiShareController, c as AiChatsSnapshot, d as AiModelsControllerOptions, f as AiModelsSnapshot, g as AiShareSnapshot, h as AiShareControllerOptions, i as AiChatTreeSnapshot, l as AiModelsActions, m as AiShareController, n as AiChatTreeController, o as AiChatsController, p as AiShareActions, r as AiChatTreeControllerOptions, s as AiChatsControllerOptions, t as AiChatTreeActions, u as AiModelsController, v as createAiChatsController, y as createAiModelsController } from "../../client-DoXBX3vS.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/core/contracts/ai-message.d.ts
-/** The `type` of each part in the canonical AI message (version 1); the SQL module and the message code both read it. */
+/**
+ * The `type` of each part in the canonical AI message (version 1); the SQL
+ * module and the message code both read it.
+ */
 type AiMessagePartTypeName = "text" | "reasoning" | "file" | "tool-call" | "tool-result" | "tool-approval" | "source" | "data" | "step";
 export declare const AI_MESSAGE_PART_TYPES: readonly AiMessagePartTypeName[];
 //#endregion

package/dist/blocks/ai-chat/index.js

@@ -1,10 +1,10 @@
 import { t as aiChatSqlOptions } from "../../options-qU8vgxhO.js";
 import { t as AI_MESSAGE_PART_TYPES } from "../../ai-message-DfaP8sis.js";
-import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-J7ZepTq2.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 { n as defineBlock } from "../../define-block-B6Gjs57G.js";
 import { a as AI_MESSAGE_SCHEMA_ID, i as validateMessage, n as pathToHistory, o as aiMessageSchema, r as repairDanglingToolCalls, s as isAiMessage, t as INTERRUPTED_TOOL_OUTPUT } from "../../history-GH1HJWQV.js";
-import { a as aiChatListTopic, c as createHarnessSessions, i as createAiShareController, n as createAiChatsController, o as aiChatTopic, r as createAiModelsController, s as createAiChat, t as createAiChatTreeController } from "../../client-CFKONrrU.js";
+import { a as aiChatListTopic, c as createHarnessSessions, i as createAiShareController, n as createAiChatsController, o as aiChatTopic, r as createAiModelsController, s as createAiChat, t as createAiChatTreeController } from "../../client-0qFNkNhT.js";
 //#region src/blocks/ai-chat/events.ts
 /** The `ai-chat` block's event types, for its manifest and `onBlockEvent`. */
 const aiChatEvents = defineEvents({