better-supabase 0.13.0 → 0.14.0

package/dist/model-messages-D-jVOIOK.js

@@ -0,0 +1,206 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as meta } from "./messages-DNzIVvgN.js";
+//#region src/ai-sdk/model-messages.ts
+const FETCHABLE_URL = /^(?:https?|data):/u;
+function fileUrl(data) {
+	if (data instanceof URL) return data.href;
+	if (typeof data === "string") return FETCHABLE_URL.test(data) ? data : void 0;
+	if (isRecord(data) && data["type"] === "url") return fileUrl(data["url"]);
+}
+function outputOf(output) {
+	switch (output.type) {
+		case "text":
+		case "json":
+		case "content": return {
+			output: output.value,
+			isError: false
+		};
+		case "error-text":
+		case "error-json": return {
+			output: output.value,
+			isError: true
+		};
+		case "execution-denied": {
+			const reason = output.reason ?? "The tool call was denied.";
+			return {
+				output: reason,
+				isError: true,
+				denied: reason
+			};
+		}
+		default: return output;
+	}
+}
+/** Collects one turn's parts, keeping one approval part per tool call. */
+var TurnParts = class {
+	parts = [];
+	#approvalAt = /* @__PURE__ */ new Map();
+	#callOf = /* @__PURE__ */ new Map();
+	constructor(approvals) {
+		for (const approval of approvals) this.#callOf.set(approval.approvalId, approval.toolCallId);
+	}
+	approval(part) {
+		this.#callOf.set(part.approvalId, part.toolCallId);
+		const at = this.#approvalAt.get(part.toolCallId);
+		if (at === void 0) {
+			this.#approvalAt.set(part.toolCallId, this.parts.length);
+			this.parts.push(part);
+		} else this.parts[at] = part;
+	}
+	callOf(approvalId) {
+		return this.#callOf.get(approvalId);
+	}
+	result(toolCallId, toolName, output) {
+		const result = outputOf(output);
+		if (result.denied !== void 0) {
+			const at = this.#approvalAt.get(toolCallId);
+			const current = at === void 0 ? void 0 : this.parts[at];
+			this.approval({
+				type: "tool-approval",
+				toolCallId,
+				approvalId: current?.type === "tool-approval" ? current.approvalId : `approval-${toolCallId}`,
+				state: "denied",
+				reason: result.denied
+			});
+		}
+		this.parts.push({
+			type: "tool-result",
+			toolCallId,
+			toolName,
+			output: result.output,
+			...result.isError ? { isError: true } : {}
+		});
+	}
+};
+function assistantParts(message, turn) {
+	if (typeof message.content === "string") {
+		if (message.content !== "") turn.parts.push({
+			type: "text",
+			text: message.content,
+			state: "done"
+		});
+		return;
+	}
+	for (const part of message.content) switch (part.type) {
+		case "text":
+		case "reasoning":
+			turn.parts.push({
+				type: part.type,
+				text: part.text,
+				state: "done"
+			});
+			break;
+		case "file": {
+			const url = fileUrl(part.data);
+			if (url !== void 0) turn.parts.push({
+				type: "file",
+				mediaType: part.mediaType,
+				url,
+				...part.filename === void 0 ? {} : { filename: part.filename }
+			});
+			break;
+		}
+		case "reasoning-file": {
+			const url = fileUrl(part.data);
+			if (url !== void 0) turn.parts.push({
+				type: "data",
+				name: "ui.reasoning-file",
+				data: {
+					mediaType: part.mediaType,
+					url
+				}
+			});
+			break;
+		}
+		case "custom":
+			turn.parts.push({
+				type: "data",
+				name: "ui.custom",
+				data: { kind: part.kind }
+			});
+			break;
+		case "tool-call":
+			turn.parts.push({
+				type: "tool-call",
+				toolCallId: part.toolCallId,
+				toolName: part.toolName,
+				input: part.input ?? {},
+				...part.providerExecuted === void 0 ? {} : { providerExecuted: part.providerExecuted }
+			});
+			break;
+		case "tool-result":
+			turn.result(part.toolCallId, part.toolName, part.output);
+			break;
+		case "tool-approval-request":
+			turn.approval({
+				type: "tool-approval",
+				toolCallId: part.toolCallId,
+				approvalId: part.approvalId,
+				state: "requested"
+			});
+			break;
+		default: return part;
+	}
+}
+function toolMessageParts(message, turn) {
+	for (const part of message.content) switch (part.type) {
+		case "tool-result":
+			turn.result(part.toolCallId, part.toolName, part.output);
+			break;
+		case "tool-approval-response": {
+			const toolCallId = turn.callOf(part.approvalId);
+			if (toolCallId !== void 0) turn.approval({
+				type: "tool-approval",
+				toolCallId,
+				approvalId: part.approvalId,
+				state: part.approved ? "approved" : "denied",
+				...part.reason === void 0 ? {} : { reason: part.reason }
+			});
+			break;
+		}
+		default: return part;
+	}
+}
+/**
+* One answer in the canonical form, from the model messages an agent added in a
+* turn (`result.messages` after the history). Each assistant message starts a
+* step whose id is `<id>:<n>`, so saving the answer again after another step
+* updates the same message.
+*/
+function fromModelMessages(id, messages, options = {}) {
+	const approvals = options.approvals ?? [];
+	const turn = new TurnParts(approvals);
+	let step = 0;
+	for (const message of messages) if (message.role === "assistant") {
+		turn.parts.push({
+			type: "step",
+			boundary: "start",
+			stepId: `${id}:${step}`
+		});
+		step += 1;
+		assistantParts(message, turn);
+	} else if (message.role === "tool") toolMessageParts(message, turn);
+	for (const approval of approvals) turn.approval({
+		type: "tool-approval",
+		toolCallId: approval.toolCallId,
+		approvalId: approval.approvalId,
+		state: approval.state,
+		...approval.reason === void 0 ? {} : { reason: approval.reason }
+	});
+	for (const source of options.sources ?? []) turn.parts.push({
+		type: "source",
+		sourceType: source.sourceType,
+		id: source.id,
+		...source.url === void 0 ? {} : { url: source.url },
+		...source.title === void 0 ? {} : { title: source.title },
+		...source.mediaType === void 0 ? {} : { mediaType: source.mediaType },
+		...meta(source.providerMetadata)
+	});
+	return {
+		id,
+		role: "assistant",
+		parts: turn.parts
+	};
+}
+//#endregion
+export { fromModelMessages as t };

package/dist/money-codec-jMP0PQLZ.js

@@ -0,0 +1,41 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { a as bigintOf, x as optionalBigintOf } from "./block-helpers-CiKtrb6g.js";
+import { d as money, s as isCurrency } from "./money-BZl985O-.js";
+//#region src/blocks/money-codec.ts
+/**
+* `Money` from an amount block functions send as text and its currency. Throws
+* for a number (precision is already lost), a missing amount or a code ISO 4217
+* doesn't list.
+*/
+const moneyOf = (amount, currency, field = "amount") => money(bigintOf(amount, field), String(currency));
+/** `moneyOf`, or `undefined` when the amount is null. */
+function optionalMoneyOf(amount, currency, field = "amount") {
+	const found = optionalBigintOf(amount, field);
+	return found === void 0 ? void 0 : money(found, String(currency));
+}
+/** A `Money` as a function argument: minor units as text. */
+const amountText = (value) => value.amount.toString();
+/** An optional `Money` as a function argument, `null` when absent. */
+const optionalAmountText = (value) => value === void 0 || value === null ? null : amountText(value);
+/**
+* The `invalid_request` error for amounts that don't share `currency`, or
+* `undefined` when they all do. Amounts that are `undefined` are skipped.
+*/
+function currencyMismatch(currency, amounts) {
+	const present = amounts.filter((item) => item !== void 0);
+	const expected = currency ?? present[0]?.currency;
+	const other = present.find((item) => item.currency !== expected);
+	return other === void 0 || expected === void 0 ? void 0 : dbError("invalid_request", `Can't combine ${expected} and ${other.currency}: amounts must share one currency`, { hint: "CURRENCY_MISMATCH" });
+}
+/** The `invalid_request` error for a currency ISO 4217 doesn't list. */
+const unknownCurrency = (currency) => dbError("invalid_request", `${currency} is not an ISO 4217 currency code`, { hint: "CURRENCY_INVALID" });
+/**
+* Why amounts can't be written in `currency`, or `undefined` when they can: the
+* currency is unknown, or an amount is in another one.
+*/
+function amountsError(currency, amounts) {
+	if (currency !== void 0 && !isCurrency(currency)) return unknownCurrency(currency);
+	return currencyMismatch(currency, amounts);
+}
+//#endregion
+export { optionalAmountText as a, moneyOf as i, amountsError as n, optionalMoneyOf as o, currencyMismatch as r, unknownCurrency as s, amountText as t };

package/dist/my-work-kinds-BU3SlA-6.js

@@ -0,0 +1,11 @@
+//#region src/blocks/subjects/my-work-kinds.ts
+/** The kinds `my_work` returns, in the order the docs list them. */
+const MY_WORK_KINDS = [
+	"assigned",
+	"approval",
+	"reminder",
+	"mention",
+	"sla"
+];
+//#endregion
+export { MY_WORK_KINDS as t };

package/dist/nestjs/index.d.ts

@@ -1,6 +1,6 @@
-import { n as RouteGuardOptions } from "../refusal-BEyNVFy7.js";
+import { n as RouteGuardOptions } from "../refusal-efy5bZMd.js";
 import { t as Validated } from "../shared-CRRfQAKG.js";
-import { l as ToNodeOptions } from "../index-CcpGT2GI.js";
+import { l as ToNodeOptions } from "../index-BgSuw4CC.js";
 import { AnyEntry } from "@supabase/middleware";
 import { IncomingMessage, ServerResponse } from "node:http";
 //#region src/nestjs/index.d.ts

package/dist/nestjs/index.js

@@ -1,4 +1,4 @@
-import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../refusal-Ce2p81VW.js";
+import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../refusal-DXydjgsS.js";
 import { t as beforeRoute } from "../before-route-B23K2zYU.js";
 import { t as applyWebHeaders } from "../node-headers-C71zNQHe.js";
 import { n as toWebRequest, t as sendWebResponse } from "../http-BjjojWg3.js";

package/dist/next/index.d.ts

@@ -1,22 +1,28 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
-import { r as AuthState } from "../resolve-D57oDWNr.js";
+import { b as DbError, f as Result } from "../result-C6jDfedy.js";
+import { M as AnyFunctions, N as AnyModels, dt as SubjectRef } from "../executor-CPyrQdjh.js";
+import { r as AuthState } from "../resolve-CzUKTIMq.js";
 import { s as PermissionRef, t as AnyAuthorizer } from "../authorizer-DFP3gHv8.js";
-import { I as ReadSet, J as QuerySpec, Lt as DbStats, Ut as CacheAdapter, t as BetterSupabase } from "../define-D0LSXmUP.js";
+import { I as ReadSet, J as QuerySpec, Lt as DbStats, Ut as CacheAdapter, t as BetterSupabase } from "../define-Dw7pRO4h.js";
 import { n as Impersonator } from "../impersonation-YTa9dZUv.js";
-import { n as AmrEntry, t as Aal } from "../mfa-Dt8AdWht.js";
-import { t as tenantOf } from "../tenant-l3H2ouv7.js";
-import { n as toSession, t as AuthSession } from "../view-CKzCp8FW.js";
-import { C as SupportSessions, S as SupportPolicy, T as supportSessions, a as ServerContext, c as ServerOptions, l as SharedServer, n as BetterServer, r as ContextOptions, v as ActiveSupport, w as SupportStartRequest, x as SupportOptions } from "../server-types-D_cQ6OxZ.js";
-import { t as AuthOutageHook } from "../session-DNRYXIOU.js";
-import { n as AuthKind, r as GuardOptions } from "../respond-QW-f1yio.js";
-import { a as AuthorizedContext, c as ResourceLoaderContext, i as AuthorizeOptions, l as Unwrapped, n as ActionParsed, r as ActionResult, t as ActionInput } from "../kit-LeQGMzLH.js";
-import { r as LiveCountSeed, t as CountRunner } from "../index-C7-2ZS9f.js";
-import { r as MembershipClaim } from "../entitlements-CMGsO4gL.js";
-import { i as ResourceContext, l as ResourceRouteOptions, o as ResourceHooks, r as ResourceAction, t as ActionArgs } from "../resource-types-NXau9LJE.js";
-import { t as ResourceMap } from "../resources-CZ60Vqwq.js";
-import { t as defineAction } from "../resource-execute-BbjuiXwD.js";
-import { i as tagFor, t as TagOptions } from "../tags-tbiuHHMV.js";
-import { n as supportOf, t as SupportView } from "../support-view-BOJJSZKv.js";
+import { n as AmrEntry, t as Aal } from "../mfa-wrx1rqJT.js";
+import { Ct as BlockClientSource, Vt as SectionOptions } from "../define-block-COpcS6aT.js";
+import { F as SectionNamed, P as SectionName, S as SectionWritesOf, _ as PlainSections, d as FeatureBlocks, h as Plain, m as FeatureWriteOutput, p as FeatureWriteInput, v as RecordCan, x as RecordWriteInput, y as RecordFeature } from "../index-DbXWcrOI.js";
+import { t as tenantOf } from "../tenant-Bg4PDLkG.js";
+import { n as toSession, t as AuthSession } from "../view-2_I-2ukO.js";
+import { C as SupportSessions, S as SupportPolicy, T as supportSessions, a as ServerContext, c as ServerOptions, l as SharedServer, n as BetterServer, r as ContextOptions, v as ActiveSupport, w as SupportStartRequest, x as SupportOptions } from "../server-types-BOs-eFpo.js";
+import { t as AuthOutageHook } from "../session-BgsOPGZs.js";
+import { n as AuthKind, r as GuardOptions } from "../respond-CZYibxUx.js";
+import { a as AuthorizedContext, c as ResourceLoaderContext, i as AuthorizeOptions, l as Unwrapped, n as ActionParsed, r as ActionResult, t as ActionInput } from "../kit-DKfbNTAA.js";
+import { c as ListParseOptions, m as ListSearchParams } from "../list-query-BtluNnYk.js";
+import { r as LiveCountSeed, t as CountRunner } from "../index-eTY4kJzo.js";
+import { r as MembershipClaim } from "../entitlements-DDevu4ZE.js";
+import { i as ResourceContext, l as ResourceRouteOptions, o as ResourceHooks, r as ResourceAction, t as ActionArgs } from "../resource-types-Bzt_bpR5.js";
+import { t as ResourceMap } from "../resources-Du5wcL3f.js";
+import { t as defineAction } from "../resource-execute-bT9ltHVT.js";
+import { i as BlockMethodName, n as BlockDataOf, t as BlockArgsOf } from "../block-method-hsPAGFi5.js";
+import { i as tagFor, t as TagOptions } from "../tags-CLXi2c6O.js";
+import { c as RecordListCells, n as Timeline, o as RecordList, u as RecordListPage } from "../timeline-DUUsPLv5.js";
+import { n as supportOf, t as SupportView } from "../support-view-vwJbRMpV.js";
 import { NextRequest } from "next/server.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/next/collector.d.ts
@@ -147,6 +153,23 @@ interface ActionOptions<S extends StandardSchemaV1 | undefined, C = unknown, P =
    */
   readonly tenant?: (input: ActionParsed<S>) => string | undefined;
 }
+/**
+ * How `blockAction` calls the method: without `args` it passes the validated
+ * input as the only argument, so `args` is required when the method takes
+ * anything else.
+ */
+type BlockActionArgs<S, A, Ctx> = [ActionParsed<S>] extends A ? {
+  readonly args?: (input: ActionParsed<S>, ctx: Ctx) => A;
+} : {
+  readonly args: (input: ActionParsed<S>, ctx: Ctx) => A;
+};
+/** The record and section a `sectionAction` writes to. */
+interface SectionActionTarget<S, Ctx> {
+  /** The section to invalidate after the write, such as `"comments"`. */
+  readonly section: string;
+  /** The record the write is on, from the validated input. */
+  readonly subject: (input: ActionParsed<S>, ctx: Ctx) => SubjectRef;
+}
 interface RouteOptions<C = unknown, P = unknown, R extends boolean = boolean, Ref = unknown, X = ResourceLoaderContext<C, P>> extends GuardOptions, AuthorizeOptions<NextRequest, C, P, R, Ref, X> {
   /**
    * Refresh an expired session cookie in the route and send the new cookies
@@ -247,6 +270,48 @@ interface BetterNext<M extends AnyModels, F extends AnyFunctions, E, C = unknown
    * ```
    */
   action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: ActionOptions<S, C, P, R, Ref, NextResource<M, F, E, C, P, B>>, fn: (input: ActionParsed<S>, ctx: ServerContext<M, F, E, C, P, B> & AuthorizedContext<C, P, R>) => Promise<T> | T): (input: ActionInput<S>) => Promise<ActionResult<Unwrapped<Awaited<T>>>>;
+  /**
+   * A server action that calls one block method as the caller, with the same
+   * guard, validation and authorize checks as `action`.
+   *
+   * ```ts
+   * export const issueInvoice = bs.blockAction(
+   *   ({ supabase }) => blocks(supabase).invoices,
+   *   "issue",
+   *   {
+   *     input: v.object({ invoiceId: v.pipe(v.string(), v.uuid()) }),
+   *     permission: permissions.invoices.write,
+   *     args: ({ invoiceId }) => [invoiceId],
+   *   },
+   * );
+   * ```
+   */
+  blockAction<Cl extends object, const K extends string, S extends StandardSchemaV1 | undefined = undefined, R extends boolean = false>(client: (ctx: ServerContext<M, F, E, C, P, B>) => Cl, method: K & BlockMethodName<Cl>, options: ActionOptions<S, C, P, R, Ref, NextResource<M, F, E, C, P, B>> & BlockActionArgs<S, BlockArgsOf<Cl, K & BlockMethodName<Cl>>, ServerContext<M, F, E, C, P, B> & AuthorizedContext<C, P, R>>): (input: ActionInput<S>) => Promise<ActionResult<BlockDataOf<Cl, K & BlockMethodName<Cl>>>>;
+  /**
+   * A `blockAction` on one record's section: after the write succeeds it
+   * invalidates the section's and the record's cache tags in the caller's
+   * tenant (`invalidateSection`).
+   *
+   * ```ts
+   * export const addComment = bs.sectionAction(
+   *   ({ db }) => blockSet.client(db, "comments"),
+   *   "create",
+   *   {
+   *     input: v.object({ customerId: v.string(), body: v.string() }),
+   *     section: "comments",
+   *     subject: ({ customerId }) => ({
+   *       type: "customer",
+   *       id: customerId,
+   *     }),
+   *     args: ({ customerId, body }) => [
+   *       { type: "customer", id: customerId },
+   *       { body },
+   *     ],
+   *   },
+   * );
+   * ```
+   */
+  sectionAction<Cl extends object, const K extends string, S extends StandardSchemaV1 | undefined = undefined, R extends boolean = false>(client: (ctx: ServerContext<M, F, E, C, P, B>) => Cl, method: K & BlockMethodName<Cl>, options: ActionOptions<S, C, P, R, Ref, NextResource<M, F, E, C, P, B>> & BlockActionArgs<S, BlockArgsOf<Cl, K & BlockMethodName<Cl>>, ServerContext<M, F, E, C, P, B> & AuthorizedContext<C, P, R>> & SectionActionTarget<S, ServerContext<M, F, E, C, P, B> & AuthorizedContext<C, P, R>>): (input: ActionInput<S>) => Promise<ActionResult<BlockDataOf<Cl, K & BlockMethodName<Cl>>>>;
   /**
    * For Server Components: the caller's context, or the Next.js interrupt for a
    * refused caller. `unauthorized` calls `unauthorized()`, `forbidden` calls
@@ -358,6 +423,13 @@ interface CachedOptions<T extends string = string> extends ScopeOptions {
 type CachedContext<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = ServerContext<M, F, E, C, P, B> & {
   readonly session: AuthSession<C, P>;
 };
+/**
+ * The second argument of `revalidateTag`: a `cacheLife` profile name or `{
+ * expire }`.
+ */
+type RevalidateProfile = string | {
+  readonly expire?: number;
+};
 interface NextCacheOptions {
   /**
    * How a mutation outside a Server Action (a route handler, a webhook) expires
@@ -419,6 +491,134 @@ export declare function sessionTag(userId: string): string;
  */
 export declare function nextCache(options?: NextCacheOptions): CacheAdapter;
 //#endregion
+//#region src/next/feature.d.ts
+/**
+ * The context `recordServer` reads: the caller's `Db`, and its supabase-js
+ * client, whose `storage` the attachments block deletes files with.
+ */
+interface RecordServerContext {
+  readonly db: BlockClientSource;
+  readonly supabase?: {
+    readonly storage?: unknown;
+  };
+}
+/**
+ * What `recordServer` needs of `bs` (`createNext`): its context and its
+ * actions, typed loosely so any app's `bs` fits.
+ */
+interface RecordServerHost {
+  context(): Promise<RecordServerContext>;
+  action<S extends StandardSchemaV1, T>(options: {
+    readonly input: S;
+    readonly requireTenant: true;
+  }, fn: (input: StandardSchemaV1.InferOutput<S>, ctx: RecordServerContext & {
+    readonly tenant: string;
+  }) => Promise<T>): (input: never) => Promise<ActionResult<unknown>>;
+}
+interface RecordLoadOptions<B extends FeatureBlocks, M extends SectionName<B>> {
+  /** The sections to load. Default: every section of the feature. */
+  readonly sections?: readonly M[];
+  /** Options for each section's `load`, such as `{ versions: { pageSize: 5 } }`. */
+  readonly options?: { readonly [K in M]?: SectionOptions<SectionNamed<B, K>>; };
+}
+/** What a generated loader resolves to, safe to pass to a Client Component. */
+interface RecordView<T extends string, B extends FeatureBlocks, N extends string, M extends N> {
+  readonly subject: SubjectRef<T>;
+  /** Each requested section settled: `ok`, `error` or `hidden`. */
+  readonly sections: PlainSections<B, M>;
+  /** What the caller may do on every section of the feature. */
+  readonly can: RecordCan<B, N>;
+  /**
+   * Set when the caller's permissions failed to load; every flag is then
+   * `false`.
+   */
+  readonly permissionsError?: DbError;
+}
+interface RecordTimelineOptions<N extends string> {
+  /** Default: every section of the feature with a `timeline`. */
+  readonly sections?: readonly N[];
+  /** The most entries to return, newest first. */
+  readonly limit?: number;
+}
+/** One Server Action per write of each section. */
+type RecordServerActions<B extends FeatureBlocks, N extends string> = { readonly [S in N]: { readonly [W in SectionWritesOf<B, S>]: (input: RecordWriteInput<FeatureWriteInput<B, S, W>>) => Promise<ActionResult<Plain<FeatureWriteOutput<B, S, W>>>>; }; };
+interface RecordServer<T extends string, B extends FeatureBlocks, N extends SectionName<B>> {
+  /**
+   * Loads one record's sections and the caller's flags. It reads the request,
+   * so call it outside `"use cache"`: a cached section error would stick.
+   */
+  load<const M extends N = N>(id: string, options?: RecordLoadOptions<B, M>): Promise<RecordView<T, B, N, M>>;
+  /**
+   * One record's history across its sections, newest first, with the sections
+   * the caller can't read skipped. Call it outside `"use cache"`, like `load`.
+   */
+  timeline(id: string, options?: RecordTimelineOptions<N>): Promise<Plain<Timeline>>;
+  /** The Server Actions; re-export them from a `"use server"` file. */
+  readonly actions: RecordServerActions<B, N>;
+  /** The record's cache tag and one per section, scoped to `tenant`. */
+  tags(id: string, tenant?: string | null): readonly string[];
+}
+/**
+ * The server half of a generated feature for Next.js: a loader for Server
+ * Components and one Server Action per section write. Each action builds the
+ * block's client over the caller's `Db` (its tenant), runs the write, and drops
+ * the section's and the record's cache tags (`invalidateSection`).
+ *
+ * ```ts
+ * const customer = recordServer(bs, customerFeature);
+ * const view = await customer.load(id, { sections: ["comments"] });
+ * ```
+ */
+export declare function recordServer<T extends string, B extends FeatureBlocks, N extends SectionName<B>>(bs: RecordServerHost, feature: RecordFeature<T, B> & {
+  readonly sections: readonly N[];
+}): RecordServer<T, B, N>;
+/** What `recordListServer(...).load` resolves to, safe for a Client Component. */
+type RecordListView<B extends FeatureBlocks, N extends string, Q, P extends {
+  readonly items: readonly unknown[];
+}, Cols> = Result<Plain<RecordListPage<Q, P, P["items"][number], RecordListCells<B, Cols>, RecordCan<B, N>>>>;
+interface RecordListServer<B extends FeatureBlocks, N extends string, Q, P extends {
+  readonly items: readonly unknown[];
+}, Cols> {
+  /**
+   * Parses the page's `searchParams` and loads the page with its section
+   * columns, over the caller's `Db`. Call it outside `"use cache"`.
+   */
+  load(input: ListSearchParams | undefined, options?: ListParseOptions): Promise<RecordListView<B, N, Q, P, Cols>>;
+}
+/**
+ * The server half of a `defineRecordList` for Next.js: it builds the feature's
+ * block clients and the caller's permissions, then runs `recordList.load`.
+ *
+ * ```ts
+ * const customers = recordListServer(bs, customerRecordList);
+ * const view = await customers.load(await searchParams);
+ * ```
+ */
+export declare function recordListServer<T extends string, B extends FeatureBlocks, N extends SectionName<B>, Q, P extends {
+  readonly items: readonly unknown[];
+}, Cols>(bs: Pick<RecordServerHost, "context">, recordList: RecordList<T, B, N, Q, P, Cols>): RecordListServer<B, N, Q, P, Cols>;
+//#endregion
+//#region src/next/records.d.ts
+interface RecordTagOptions {
+  /** The tenant the read is scoped to, so other tenants' writes keep it. */
+  readonly tenant?: string | null | undefined;
+}
+/**
+ * The cache tag of a record's header and tab badges (`record_summary`):
+ * `bs:record@<tenant>:<type>:<id>`, or `bs:record:<type>:<id>` without a
+ * tenant.
+ */
+export declare function recordTag(subject: SubjectRef, options?: RecordTagOptions): string;
+/** The cache tag of one section of a record, such as its comments. */
+export declare function sectionTag(subject: SubjectRef, section: string, options?: RecordTagOptions): string;
+/**
+ * Drops the cached section and the record's header, whose counts change with
+ * it: `updateTag` in a Server Action, else `revalidateTag`.
+ */
+export declare function invalidateSection(subject: SubjectRef, section: string, options?: RecordTagOptions & {
+  readonly revalidate?: RevalidateProfile;
+}): void;
+//#endregion
 //#region src/next/support.d.ts
 /** Response header with the URL of the request's totals on `bs.debugRoute()`. */
 export declare const STATS_URL_HEADER = "x-bs-stats";
@@ -445,4 +645,4 @@ export declare function shouldRefresh(request: Request): boolean;
  */
 export declare function requireAal(level: Aal, options?: RequireAalOptions): (auth: AuthState, request: NextRequest) => Response | undefined;
 //#endregion
-export { type Aal, type ActionArgs, type ActionOptions, type ActionResult, type ActiveSupport, type AmrEntry, type AuthKind, type AuthSession, type AuthorizeOptions, type AuthorizedContext, type BetterNext, type CachedContext, type CachedOptions, type DbBudget, type DbStats, type EndedSessionOptions, type GuardOptions, type Impersonator, type LiveCountSeed, type MembershipClaim, type NextCacheOptions, type NextDebugOptions, type NextOptions, type NextResourceHandler, type NextResourceRoutes, type NextResourcesOptions, type ProxyOptions, type RequireAalOptions, type RequireOptions, type ResourceAction, type ResourceContext, type ResourceHooks, type ResourceLoaderContext, type ResourceMap, type ResourceRouteOptions, type RouteOptions, type ScopeOptions, type SessionStaleOptions, type SupportOptions, type SupportPolicy, type SupportSessions, type SupportStartRequest, type SupportStarted, type SupportView, type TagOptions, defineAction, supportOf, supportSessions, tagFor, tenantOf, toSession };
+export { type Aal, type ActionArgs, type ActionOptions, type ActionResult, type ActiveSupport, type AmrEntry, type AuthKind, type AuthSession, type AuthorizeOptions, type AuthorizedContext, type BetterNext, type BlockActionArgs, type CachedContext, type CachedOptions, type DbBudget, type DbStats, type EndedSessionOptions, type GuardOptions, type Impersonator, type LiveCountSeed, type MembershipClaim, type NextCacheOptions, type NextDebugOptions, type NextOptions, type NextResourceHandler, type NextResourceRoutes, type NextResourcesOptions, type ProxyOptions, type RecordListServer, type RecordListView, type RecordLoadOptions, type RecordServer, type RecordServerActions, type RecordServerContext, type RecordServerHost, type RecordTagOptions, type RecordTimelineOptions, type RecordView, type RequireAalOptions, type RequireOptions, type ResourceAction, type ResourceContext, type ResourceHooks, type ResourceLoaderContext, type ResourceMap, type ResourceRouteOptions, type RouteOptions, type ScopeOptions, type SessionStaleOptions, type SupportOptions, type SupportPolicy, type SupportSessions, type SupportStartRequest, type SupportStarted, type SupportView, type TagOptions, defineAction, supportOf, supportSessions, tagFor, tenantOf, toSession };