better-supabase 0.14.0 → 0.15.1

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

@@ -1,11 +1,11 @@
 /// <reference lib="esnext.temporal" />
-import { f as Result } from "../../result-C6jDfedy.js";
-import { Ct as Events, X as OrganizationDomainEventData, Z as OrganizationEventData, at as SsoProviderEventData, nt as ScimEventData } from "../../events-DbLjvxDX.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 { c as BlockOf } from "../../define-block-COpcS6aT.js";
-import { l as ApiKeys } from "../../api-keys-CboAenU8.js";
-import { _ as dohResolver, a as SamlProviderInput, c as SsoAdmin, d as SsoDomain, f as SsoOptions, g as createSsoAdmin, h as createSso, i as SamlMetadata, l as SsoAdminOptions, m as TxtResolver, n as DomainRecord, o as Sso, p as SsoProvider, r as OrganizationDomain, s as SsoActor, t as DohResolverOptions, u as SsoAuthAdmin } from "../../sso-B744gHeS.js";
+import { f as Result } from "../../result-DZeA5KS6.js";
+import { Ct as Events, X as OrganizationDomainEventData, Z as OrganizationEventData, at as SsoProviderEventData, nt as ScimEventData } from "../../events-vcqenSYU.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { c as BlockOf } from "../../define-block-DvvcM54N.js";
+import { l as ApiKeys } from "../../api-keys-D5k63K6y.js";
+import { _ as dohResolver, a as SamlProviderInput, c as SsoAdmin, d as SsoDomain, f as SsoOptions, g as createSsoAdmin, h as createSso, i as SamlMetadata, l as SsoAdminOptions, m as TxtResolver, n as DomainRecord, o as Sso, p as SsoProvider, r as OrganizationDomain, s as SsoActor, t as DohResolverOptions, u as SsoAuthAdmin } from "../../sso-B0Txid2-.js";
 //#region src/blocks/sso/scim-filter.d.ts
 type CompareOp = "eq" | "ne" | "co" | "sw" | "ew" | "gt" | "ge" | "lt" | "le";
 type ScimFilter = {

package/dist/blocks/sso/index.js

@@ -1,10 +1,10 @@
-import { a as ok } from "../../result-B3m7xtRY.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { a as ok } from "../../result-ntFBW2p2.js";
 import { t as ssoSqlOptions } from "../../options-CK5WiFwG.js";
-import { B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, R as toInstant, U as sqlTransport, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CiKtrb6g.js";
+import { B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, R as toInstant, U as sqlTransport, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { n as createSsoAdmin, r as dohResolver, t as createSso } from "../../sso-Bt9HocgW.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { n as createSsoAdmin, r as dohResolver, t as createSso } from "../../sso-d2S4x_f9.js";
 //#region src/blocks/sso/scim-filter.ts
 /** SCIM filters (RFC 7644 §3.4.2.2): parsing and evaluation over resource JSON. */
 /** A filter the service provider can't parse or apply: 400 `invalidFilter`. */

package/dist/blocks/state-machine/index.d.ts

@@ -1,11 +1,11 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "../../result-C6jDfedy.js";
-import { dt as SubjectRef } from "../../executor-CPyrQdjh.js";
-import { Ct as Events, et as SaasSubjectEventData } from "../../events-DbLjvxDX.js";
+import { t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { Ct as Events, et as SaasSubjectEventData } from "../../events-vcqenSYU.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { i as CursorPageOptions, n as BlockOptions } from "../../block-helpers-BaugZlJV.js";
-import { n as BlockHooks } from "../../block-hooks-CmjPKqQ_.js";
-import { c as BlockOf } from "../../define-block-COpcS6aT.js";
+import { i as CursorPageOptions, n as BlockOptions } from "../../block-helpers-CRpAHrp_.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { c as BlockOf } from "../../define-block-DvvcM54N.js";
 //#region src/blocks/state-machine/state-machine.d.ts
 interface StateMachineOptions<S extends string = string> extends BlockOptions {
   /** `withBlockHooks` hooks around the client's methods. */
@@ -16,7 +16,7 @@ interface StateMachineOptions<S extends string = string> extends BlockOptions {
 /** Where a record is in its machine, from `state()`. */
 interface StatusState {
   readonly organizationId: string;
-  readonly subject: SubjectRef;
+  readonly subject: RecordRef;
   readonly status: string;
   /** The machine's `order`, empty when it sets none. */
   readonly order: readonly string[];
@@ -64,34 +64,34 @@ interface StateMachine<S extends string = string> {
    * they may update it, and the trigger rejects a change the machine does not
    * allow. `not_found` for a record they can't see.
    */
-  transition(subject: SubjectRef<S>, to: string, reason?: string): AsyncResult<boolean>;
+  transition(subject: RecordRef<S>, to: string, reason?: string): AsyncResult<boolean>;
   /**
    * Pauses the record (`lifecycle: true`): transitions fail with `STATE_PAUSED`
    * until `until` passes, or until `resume()` without one.
    */
-  pause(subject: SubjectRef<S>, options?: {
+  pause(subject: RecordRef<S>, options?: {
     readonly until?: Temporal.Instant;
     readonly reason?: string;
   }): AsyncResult<boolean>;
   /** Ends a pause; `false` when the record wasn't paused. */
-  resume(subject: SubjectRef<S>): AsyncResult<boolean>;
+  resume(subject: RecordRef<S>): AsyncResult<boolean>;
   /**
    * Turns a flag the machine lists in `flags` on or off; `false` when it
    * already was.
    */
-  setFlag(subject: SubjectRef<S>, flag: string, enabled: boolean): AsyncResult<boolean>;
+  setFlag(subject: RecordRef<S>, flag: string, enabled: boolean): AsyncResult<boolean>;
   /** The record's status, progress, flags, pause and pinned version. */
-  state(subject: SubjectRef<S>): AsyncResult<StatusState>;
+  state(subject: RecordRef<S>): AsyncResult<StatusState>;
   /**
    * Status changes, newest first; page with the last `createdAt` as `cursor`.
    * Default 50, at most 500.
    */
-  history(subject: SubjectRef<S>, page?: CursorPageOptions<Temporal.Instant>): AsyncResult<readonly StatusChange[]>;
+  history(subject: RecordRef<S>, page?: CursorPageOptions<Temporal.Instant>): AsyncResult<readonly StatusChange[]>;
   /**
    * The stages timeline in display order; empty for a machine without `stages:
    * true`.
    */
-  stages(subject: SubjectRef<S>): AsyncResult<readonly StatusStage[]>;
+  stages(subject: RecordRef<S>): AsyncResult<readonly StatusStage[]>;
 }
 /** The `state-machine` SQL module as typed calls. */
 export declare function createStateMachine<S extends string = string>(options: StateMachineOptions<S>): StateMachine<S>;

package/dist/blocks/state-machine/index.js

@@ -1,9 +1,9 @@
 import { t as stateMachineSqlOptions } from "../../options-B0FcEKtH.js";
-import { A as requiredInstant, C as optionalText, D as recordOf, F as stringsOf, I as textOf, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall, w as pageOf } from "../../block-helpers-CiKtrb6g.js";
-import { r as withBlockHooks } from "../../block-hooks-BymdcD0V.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, F as stringsOf, I as textOf, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall, w as pageOf } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { i as subjectRefOf } from "../../block-subjects-Dzq5Xn_0.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { i as subjectRefOf } from "../../block-subjects-BhDKK_j7.js";
 //#region src/blocks/state-machine/state-machine.ts
 const optionalNumber = (value) => value === null || value === void 0 ? void 0 : Number(value);
 function stateOf(value) {

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

@@ -1,11 +1,45 @@
-import { dt as SubjectRef } from "../../executor-CPyrQdjh.js";
-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 { t as subjectKey } from "../../block-subjects-FHwLlIHU.js";
-import { c as Subjects, d as MY_WORK_KINDS, f as MyWorkKind, l as SubjectsOptions, n as MyWorkItem, o as ResolvedSubject, r as MyWorkOptions, s as SUBJECT_TITLES_LIMIT, t as MY_WORK_LIMIT, u as createSubjects } from "../../subjects-DXFmanh5.js";
-import { a as batchSubjects, i as SubjectsSnapshot, n as SubjectsController, o as createSubjectsController, r as SubjectsControllerOptions, t as SubjectsActions } from "../../client-Do5hykMK.js";
+import { b as DbError } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { c as BlockOf } from "../../define-block-DvvcM54N.js";
+import { n as Controller, t as AuthPort } from "../../controller-DyPPMFSw.js";
+import { t as subjectKey } from "../../block-subjects-CphkQPxp.js";
+import { c as Subjects, d as MY_WORK_KINDS, f as MyWorkKind, l as SubjectsOptions, n as MyWorkItem, o as ResolvedSubject, r as MyWorkOptions, s as SUBJECT_TITLES_LIMIT, t as MY_WORK_LIMIT, u as createSubjects } from "../../subjects-BpIEN1MS.js";
 //#region src/blocks/subjects/manifest.d.ts
 /** The `subjects` block's manifest (ADR 0029). */
 export declare const subjectsBlock: BlockOf<"subjects", typeof createSubjects>;
 //#endregion
-export { type BlockTransport, MY_WORK_KINDS, MY_WORK_LIMIT, type MyWorkItem, type MyWorkKind, type MyWorkOptions, type ResolvedSubject, SUBJECT_TITLES_LIMIT, type SubjectRef, type Subjects, type SubjectsActions, type SubjectsController, type SubjectsControllerOptions, type SubjectsOptions, type SubjectsSnapshot, batchSubjects, createSubjects, createSubjectsController, dbTransport, rpcTransport, sqlTransport, subjectKey };
+//#region src/blocks/subjects/client.d.ts
+/**
+ * Joins the `resolve(refs)` calls made in the same tick into one, so a list
+ * where each row shows a subject link costs one round trip. Each caller gets
+ * back only the subjects it asked for.
+ */
+export declare function batchSubjects(source: Subjects): Subjects;
+interface SubjectsControllerOptions {
+  /** `createSubjects()`, ideally through `batchSubjects`. */
+  readonly client: Pick<Subjects, "resolve">;
+  readonly auth: AuthPort;
+  /** The subjects to resolve; nothing loads while empty. */
+  readonly refs: readonly RecordRef[];
+}
+interface SubjectsSnapshot {
+  /**
+   * The resolved subjects keyed by `subjectKey` (`type:id`); `undefined` until
+   * the first load. A subject the caller can't read is missing.
+   */
+  readonly subjects: Readonly<Record<string, ResolvedSubject>> | undefined;
+  readonly error: DbError | undefined;
+}
+interface SubjectsActions {
+  /** Resolves the subjects again, such as after a rename. */
+  readonly refresh: () => Promise<void>;
+}
+type SubjectsController = Controller<SubjectsSnapshot, SubjectsActions>;
+/**
+ * Titles and paths of `refs`, loaded for the signed-in user and again when
+ * another user signs in.
+ */
+export declare function createSubjectsController(options: SubjectsControllerOptions): SubjectsController;
+//#endregion
+export { type BlockTransport, MY_WORK_KINDS, MY_WORK_LIMIT, type MyWorkItem, type MyWorkKind, type MyWorkOptions, type RecordRef, type ResolvedSubject, SUBJECT_TITLES_LIMIT, type Subjects, type SubjectsActions, type SubjectsController, type SubjectsControllerOptions, type SubjectsOptions, type SubjectsSnapshot, createSubjects, dbTransport, rpcTransport, sqlTransport, subjectKey };

package/dist/blocks/subjects/index.js

@@ -1,9 +1,111 @@
-import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CiKtrb6g.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { a as ok, t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { B as dbTransport, C as optionalText, H as rpcTransport, S as optionalInstant, U as sqlTransport, m as instantArg, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
 import { t as MY_WORK_KINDS } from "../../my-work-kinds-BU3SlA-6.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { r as subjectKey } from "../../block-subjects-Dzq5Xn_0.js";
-import { n as SUBJECT_TITLES_LIMIT, r as createSubjects, t as MY_WORK_LIMIT } from "../../subjects-DevU_atb.js";
-import { n as createSubjectsController, t as batchSubjects } from "../../client-CVToJ4uI.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { r as subjectKey } from "../../block-subjects-BhDKK_j7.js";
+//#region src/blocks/subjects/subjects.ts
+/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
+const SUBJECT_TITLES_LIMIT = 500;
+/** The most items one `my_work` call returns. */
+const MY_WORK_LIMIT = 200;
+function resolvedOf(value) {
+	if (!isRecord(value)) return;
+	const type = optionalText(value["type"]);
+	const id = optionalText(value["id"]);
+	if (type === void 0 || id === void 0) return;
+	const title = optionalText(value["title"]);
+	const url = optionalText(value["url"]);
+	return {
+		type,
+		id,
+		...title === void 0 ? {} : { title },
+		...url === void 0 ? {} : { url }
+	};
+}
+function numbersOf(value) {
+	return isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([key, each]) => typeof each === "number" ? [[key, each]] : [])) : {};
+}
+function flagsOf(value) {
+	return isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([key, each]) => typeof each === "boolean" ? [[key, each]] : [])) : {};
+}
+function summaryOf(value) {
+	const resolved = resolvedOf(value);
+	return resolved === void 0 || !isRecord(value) ? void 0 : {
+		...resolved,
+		counts: numbersOf(value["counts"]),
+		unread: flagsOf(value["unread"])
+	};
+}
+function workOf(value) {
+	if (!isRecord(value)) return;
+	const kind = MY_WORK_KINDS.find((each) => each === value["kind"]);
+	const subject = resolvedOf(value["subject"]);
+	const ref = optionalText(value["ref"]);
+	if (kind === void 0 || subject === void 0 || ref === void 0) return;
+	const title = optionalText(value["title"]);
+	const url = optionalText(value["url"]);
+	const at = optionalInstant(value["at"]);
+	return {
+		kind,
+		subject: {
+			type: subject.type,
+			id: subject.id
+		},
+		ref,
+		...title === void 0 ? {} : { title },
+		...url === void 0 ? {} : { url },
+		...at === void 0 ? {} : { at }
+	};
+}
+const workList = (value) => (Array.isArray(value) ? value : []).flatMap((row) => {
+	const item = workOf(row);
+	return item === void 0 ? [] : [item];
+});
+const resolvedList = (value) => (Array.isArray(value) ? value : []).flatMap((row) => {
+	const resolved = resolvedOf(row);
+	return resolved === void 0 ? [] : [resolved];
+});
+/**
+* The `subjects` module's `subject_titles` as a typed call, for lists and
+* mentions that show a link to each subject.
+*/
+function createSubjects(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({
+		resolve: (refs) => AsyncResult.from(async () => {
+			const unique = [...new Map(refs.map((ref) => [subjectKey(ref), ref])).values()];
+			const chunks = [];
+			for (let start = 0; start < unique.length; start += 500) chunks.push(unique.slice(start, start + 500));
+			const results = await Promise.all(chunks.map((chunk) => call("subject_titles", { refs: chunk.map(({ type, id }) => ({
+				type,
+				id
+			})) }, resolvedList)));
+			const found = {};
+			for (const result of results) {
+				if (!result.ok) return result;
+				for (const subject of result.data) found[subjectKey(subject)] = subject;
+			}
+			return ok(found);
+		}),
+		summary: (subject, sections, summaryOptions = {}) => call("record_summary", {
+			subject_type: subject.type,
+			subject_id: subject.id,
+			sections: [...sections],
+			seen_at: instantArg(summaryOptions.seenAt) ?? null
+		}, summaryOf),
+		myWork: (workOptions = {}) => call("my_work", {
+			tenant: workOptions.tenant ?? null,
+			page_size: workOptions.pageSize ?? 50
+		}, workList)
+	}, options.hooks, {
+		block: "subjects",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
 //#region src/blocks/subjects/manifest.ts
 /** The `subjects` block's manifest (ADR 0029). */
 const subjectsBlock = defineBlock({
@@ -18,4 +120,84 @@ const subjectsBlock = defineBlock({
 	]
 });
 //#endregion
+//#region src/blocks/subjects/client.ts
+/**
+* Joins the `resolve(refs)` calls made in the same tick into one, so a list
+* where each row shows a subject link costs one round trip. Each caller gets
+* back only the subjects it asked for.
+*/
+function batchSubjects(source) {
+	let pending;
+	const flush = (batch) => {
+		pending = void 0;
+		source.resolve([...batch.refs.values()]).then((result) => {
+			for (const waiter of batch.waiters) waiter(result);
+		});
+	};
+	return {
+		summary: (subject, sections, options) => source.summary(subject, sections, options),
+		myWork: (options) => source.myWork(options),
+		resolve: (refs) => AsyncResult.from(() => new Promise((resolve) => {
+			if (pending === void 0) {
+				const created = {
+					refs: /* @__PURE__ */ new Map(),
+					waiters: []
+				};
+				pending = created;
+				queueMicrotask(() => {
+					flush(created);
+				});
+			}
+			const keys = refs.map((ref) => subjectKey(ref));
+			for (const [index, ref] of refs.entries()) pending.refs.set(keys[index], ref);
+			pending.waiters.push((result) => {
+				if (!result.ok) {
+					resolve(result);
+					return;
+				}
+				const mine = {};
+				for (const key of keys) {
+					const found = result.data[key];
+					if (found !== void 0) mine[key] = found;
+				}
+				resolve(ok(mine));
+			});
+		}))
+	};
+}
+/**
+* Titles and paths of `refs`, loaded for the signed-in user and again when
+* another user signs in.
+*/
+function createSubjectsController(options) {
+	const { client, refs } = options;
+	return defineController({
+		subjects: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			if (refs.length === 0) {
+				state.set({
+					subjects: {},
+					error: void 0
+				});
+				return;
+			}
+			const run = state.run();
+			const result = await client.resolve(refs);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				subjects: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: { refresh },
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
 export { MY_WORK_KINDS, MY_WORK_LIMIT, SUBJECT_TITLES_LIMIT, batchSubjects, createSubjects, createSubjectsController, dbTransport, rpcTransport, sqlTransport, subjectKey, subjectsBlock };

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

@@ -1,12 +1,98 @@
-import { $ as SaasEventData, Ct as Events, et as SaasSubjectEventData } from "../../events-DbLjvxDX.js";
-import { Gt as SectionWrite, Lt as Section, c as BlockOf, rn as EntitySchema } from "../../define-block-COpcS6aT.js";
-import { a as TagInputSnapshot, c as Tags, i as TagInputControllerOptions, l as TagsOptions, n as TagInputActions, o as createTagInputController, r as TagInputController, s as Tag, t as TagChange, u as createTags } from "../../client-CLIBcMzL.js";
-//#region src/blocks/tags/section.d.ts
+import { b as DbError, f as Result, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "../../standard-DBV730sF.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-BE7pInWZ.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { $ as SaasEventData, Ct as Events, et as SaasSubjectEventData } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { n as BlockOptions } from "../../block-helpers-CRpAHrp_.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { Sn as EntitySchema, c as BlockOf, ln as RecordBindingWrite, rn as RecordBinding } from "../../define-block-DvvcM54N.js";
+import { n as Controller, t as AuthPort } from "../../controller-DyPPMFSw.js";
+import { t as RankNeighbors } from "../../rank-result-Bwe7igy-.js";
+//#region src/blocks/tags/tags.d.ts
+interface TagsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the tag's extra columns
+   * (`blocks.tags.options.extraColumns`), keyed by database name. It types and
+   * parses them on reads, and validates them on `create` and `update`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Tags<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A tag. `F` types the extra columns the `fields` schema describes. */
+interface Tag<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly name: string;
+  readonly slug: string;
+  /** Its rank key among the tenant's tags of the same kind, when it has one. */
+  readonly rank?: string;
+  /** Set on the tags `list` returns. */
+  readonly kind?: string;
+  readonly color?: string;
+  readonly description?: string;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+/** The input of `tags.create`. */
+interface CreateTagInput<F extends object = Record<never, never>> {
+  /** The record type the tag is for, such as `deal`. */
+  readonly kind: string;
+  readonly name: string;
+  readonly color?: string;
+  readonly description?: string;
+  /** The extra columns, validated by the `fields` schema. */
+  readonly fields?: Partial<F>;
+}
+/** The patch `tags.update` takes. */
+interface UpdateTagInput<F extends object = Record<never, never>> {
+  readonly name?: string;
+  /** The extra columns to set; the others keep their values. */
+  readonly fields?: Partial<F>;
+}
+/** The filter `tags.list` takes. */
+interface ListTagsParams {
+  /** Only the tags of this kind. */
+  readonly kind?: string;
+  /** Only the tags on this record; the caller must be able to read it. */
+  readonly on?: RecordRef;
+}
+/**
+ * `F` is the extra fields `options.fields` describes. Every method that takes
+ * no tag id acts in the block's `tenant`.
+ */
+interface Tags<F extends object = Record<never, never>> {
+  /** Creates a tag in the tenant. */
+  create(input: CreateTagInput<F>): AsyncResult<Tag<F>>;
+  /** Renames a tag and sets the extra columns `fields` names. */
+  update(id: string, patch: UpdateTagInput<F>): AsyncResult<boolean>;
+  /**
+   * Moves a tag between the tags with rank keys `previous` and `next`. Resolves
+   * to its new key.
+   */
+  reorder(id: string, neighbors: RankNeighbors): AsyncResult<string>;
+  delete(id: string): AsyncResult<boolean>;
+  /** Puts a tag on `record`. */
+  attach(record: RecordRef, tagId: string): AsyncResult<boolean>;
+  /** Takes a tag off `record`. */
+  detach(record: RecordRef, tagId: string): AsyncResult<boolean>;
+  /**
+   * The tenant's tags in rank order: every kind, the tags of `kind`, or the
+   * tags on the record `on` names.
+   */
+  list(params?: ListTagsParams): AsyncResult<readonly Tag<F>[]>;
+}
+/** The `tags` SQL module as typed calls. */
+export declare function createTags<S extends StandardSchemaV1 | undefined = undefined>(options: TagsOptions<S>): Tags<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/tags/record-binding.d.ts
 /** What tagging or untagging a record takes. */
 interface TagRefInput {
   readonly tagId: string;
 }
-/** The input schema of the tags section's `apply` and `remove`. */
+/** The input schema of the tags binding's `apply` and `remove`. */
 export declare const tagRefInput: EntitySchema<TagRefInput>;
 /** A pending tag or untag, for `useOptimistic`. */
 type TagsOptimisticAction = {
@@ -21,15 +107,64 @@ type TagsOptimisticAction = {
  * `untag` takes it out.
  */
 export declare function tagsOptimistic(state: readonly Tag[], action: TagsOptimisticAction): readonly Tag[];
-/** The writes of the tags section. */
+/** The writes of the tags binding. */
 type TagsWrites = {
   /** Puts a tag on the record. */
-  readonly apply: SectionWrite<Tags, TagRefInput, boolean>;
+  readonly apply: RecordBindingWrite<Tags, TagRefInput, boolean>;
   /** Takes a tag off the record. */
-  readonly remove: SectionWrite<Tags, TagRefInput, boolean>;
+  readonly remove: RecordBindingWrite<Tags, TagRefInput, boolean>;
 };
 /** The tags on a record. */
-export declare const tagsSection: Section<Tags, readonly Tag[], never, TagsOptimisticAction, TagsWrites>;
+export declare const tagsBinding: RecordBinding<Tags, readonly Tag[], never, TagsOptimisticAction, TagsWrites>;
+//#endregion
+//#region src/blocks/tags/client.d.ts
+/** A tag change on the subject that committed, for `onChanged`. */
+type TagChange = {
+  readonly kind: "added";
+  readonly tag: Tag;
+  readonly created: boolean;
+} | {
+  readonly kind: "removed";
+  readonly tag: Tag;
+};
+interface TagInputControllerOptions {
+  readonly client: Pick<Tags, "attach" | "create" | "detach" | "list">;
+  readonly auth: AuthPort;
+  /** The subject whose tags to show; the input waits without one. */
+  readonly subject: RecordRef | null;
+  /** The kind of tags the input offers and creates, such as `customer`. */
+  readonly kind: string;
+  /** Runs after a tag was added or removed. A throw is kept in `error`. */
+  readonly onChanged?: (change: TagChange) => void | Promise<void>;
+}
+interface TagInputSnapshot {
+  /** The subject's tags, in rank order; `undefined` until the first load. */
+  readonly tags: readonly Tag[] | undefined;
+  /** Every tag of the kind, for suggestions; `undefined` until the first load. */
+  readonly available: readonly Tag[] | undefined;
+  /** The tag ids, or the names of tags being created, with a write in flight. */
+  readonly pending: readonly string[];
+  readonly error: DbError | undefined;
+}
+interface TagInputActions {
+  /** Adds an existing tag, shown at once and taken back when it fails. */
+  readonly add: (tagId: string) => Promise<Result<Tag>>;
+  /** Removes a tag, hidden at once and put back when it fails. */
+  readonly remove: (tagId: string) => Promise<Result<boolean>>;
+  /**
+   * Adds the tag called `name`: an existing one of the kind with the same name
+   * (ignoring case), or a new one, which needs `tags.manage`.
+   */
+  readonly create: (name: string) => Promise<Result<Tag>>;
+  readonly refresh: () => Promise<void>;
+}
+type TagInputController = Controller<TagInputSnapshot, TagInputActions>;
+/**
+ * One subject's tags for a tag input: the tags on it, every tag of the kind for
+ * suggestions, and `add`, `remove` and `create`, which show the change at
+ * once.
+ */
+export declare function createTagInputController(options: TagInputControllerOptions): TagInputController;
 //#endregion
 //#region src/blocks/tags/events.d.ts
 /** The events of the `tags` block: type to data. */
@@ -45,8 +180,6 @@ export declare const tagsEvents: Events<TagsEvents>;
 //#endregion
 //#region src/blocks/tags/manifest.d.ts
 /** The `tags` block's manifest (ADR 0029). */
-export declare const tagsBlock: BlockOf<"tags", typeof createTags, TagsEvents, Record<never, never>, never, {
-  readonly tags: typeof tagsSection;
-}>;
+export declare const tagsBlock: BlockOf<"tags", typeof createTags, TagsEvents, Record<never, never>, never, typeof tagsBinding>;
 //#endregion
-export { type Tag, type TagChange, type TagInputActions, type TagInputController, type TagInputControllerOptions, type TagInputSnapshot, type TagRefInput, type Tags, type TagsEvents, type TagsOptimisticAction, type TagsOptions, type TagsWrites, createTagInputController, createTags };
+export type { CreateTagInput, ListTagsParams, Tag, TagChange, TagInputActions, TagInputController, TagInputControllerOptions, TagInputSnapshot, TagRefInput, Tags, TagsEvents, TagsOptimisticAction, TagsOptions, TagsWrites, UpdateTagInput };