better-supabase 0.13.0 → 0.15.0

package/dist/blocks/incidents/index.js

@@ -0,0 +1,477 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as temporal } from "../../temporal-required-Dy0GGD8E.js";
+import { t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { t as incidentsSqlOptions } from "../../options-DJ-aYPVN.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as entitySchema } from "../../entity-schema-BDv6w-OQ.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+//#region src/blocks/incidents/incidents.ts
+const SEVERITIES$1 = [
+	"sev1",
+	"sev2",
+	"sev3",
+	"sev4"
+];
+const STATUSES = [
+	"investigating",
+	"identified",
+	"monitoring",
+	"resolved"
+];
+const COMPONENT_STATUSES = [
+	"operational",
+	"maintenance",
+	"degraded",
+	"partial_outage",
+	"major_outage"
+];
+const IMPACTS = [
+	"maintenance",
+	"degraded",
+	"partial_outage",
+	"major_outage"
+];
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+const numberOf = (value) => typeof value === "number" ? value : Number(value ?? 0);
+function componentOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		name: textOf(row["name"]),
+		public: row["public"] === true,
+		status: enumOrThrow(row["status"], COMPONENT_STATUSES, "component status"),
+		position: numberOf(row["position"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("description", optionalText(row["description"])),
+		...optional("group", optionalText(row["group"]))
+	};
+}
+function incidentOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		title: textOf(row["title"]),
+		severity: enumOrThrow(row["severity"], SEVERITIES$1, "incident severity"),
+		status: enumOrThrow(row["status"], STATUSES, "incident status"),
+		public: row["public"] === true,
+		startedAt: requiredInstant(row["startedAt"], "startedAt"),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		impacts: recordsOf(row["impacts"] ?? [], fn).map((impact) => ({
+			componentId: textOf(impact["componentId"]),
+			name: textOf(impact["name"]),
+			impact: enumOrThrow(impact["impact"], IMPACTS, "component impact")
+		})),
+		...optional("description", optionalText(row["description"])),
+		...optional("commanderId", optionalText(row["commanderId"])),
+		...optional("resolvedAt", optionalInstant(row["resolvedAt"])),
+		...optional("createdBy", optionalText(row["createdBy"])),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function updateOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		incidentId: textOf(row["incidentId"]),
+		status: enumOrThrow(row["status"], STATUSES, "incident status"),
+		body: textOf(row["body"]),
+		public: row["public"] === true,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...optional("authorId", optionalText(row["authorId"]))
+	};
+}
+function postmortemOf(value, fn) {
+	const row = recordOf(value, fn);
+	const items = row["actionItems"];
+	return {
+		id: textOf(row["id"]),
+		incidentId: textOf(row["incidentId"]),
+		actionItems: Array.isArray(items) ? items : [],
+		status: enumOrThrow(row["status"], ["draft", "published"], "postmortem status"),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("summary", optionalText(row["summary"])),
+		...optional("impact", optionalText(row["impact"])),
+		...optional("rootCause", optionalText(row["rootCause"])),
+		...optional("resolution", optionalText(row["resolution"])),
+		...optional("publishedAt", optionalInstant(row["publishedAt"])),
+		...optional("authorId", optionalText(row["authorId"]))
+	};
+}
+function detailOf(value, fn) {
+	if (value === null || value === void 0) return;
+	const row = recordOf(value, fn);
+	const postmortem = row["postmortem"];
+	return {
+		...incidentOf(row, fn),
+		updates: recordsOf(row["updates"] ?? [], fn).map((item) => updateOf(item, fn)),
+		...optional("postmortem", isRecord(postmortem) ? postmortemOf(postmortem, fn) : void 0)
+	};
+}
+function pageOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		slug: textOf(row["slug"]),
+		title: textOf(row["title"]),
+		published: row["published"] === true,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("description", optionalText(row["description"]))
+	};
+}
+function publicIncidentOf(row, fn) {
+	const postmortem = row["postmortem"];
+	return {
+		id: textOf(row["id"]),
+		title: textOf(row["title"]),
+		severity: enumOrThrow(row["severity"], SEVERITIES$1, "incident severity"),
+		status: enumOrThrow(row["status"], STATUSES, "incident status"),
+		startedAt: requiredInstant(row["startedAt"], "startedAt"),
+		components: recordsOf(row["components"] ?? [], fn).map((component) => ({
+			id: textOf(component["id"]),
+			name: textOf(component["name"]),
+			impact: enumOrThrow(component["impact"], IMPACTS, "component impact")
+		})),
+		updates: recordsOf(row["updates"] ?? [], fn).map((update) => ({
+			status: enumOrThrow(update["status"], STATUSES, "incident status"),
+			body: textOf(update["body"]),
+			createdAt: requiredInstant(update["createdAt"], "createdAt")
+		})),
+		...optional("resolvedAt", optionalInstant(row["resolvedAt"])),
+		...optional("postmortem", isRecord(postmortem) ? {
+			publishedAt: requiredInstant(postmortem["publishedAt"], "publishedAt"),
+			...optional("summary", optionalText(postmortem["summary"]))
+		} : void 0)
+	};
+}
+function publicComponentOf(row, fn) {
+	return {
+		id: textOf(row["id"]),
+		name: textOf(row["name"]),
+		status: enumOrThrow(row["status"], COMPONENT_STATUSES, "component status"),
+		uptimePercent: numberOf(row["uptimePercent"] ?? 100),
+		uptime: recordsOf(row["uptime"] ?? [], fn).map((day) => ({
+			date: temporal().PlainDate.from(textOf(day["date"])),
+			status: enumOrThrow(day["status"], COMPONENT_STATUSES, "component status"),
+			downMinutes: numberOf(day["downMinutes"])
+		})),
+		...optional("description", optionalText(row["description"])),
+		...optional("group", optionalText(row["group"]))
+	};
+}
+function publicPageOf(value, fn) {
+	if (value === null || value === void 0) return;
+	const row = recordOf(value, fn);
+	return {
+		slug: textOf(row["slug"]),
+		title: textOf(row["title"]),
+		days: numberOf(row["days"]),
+		status: enumOrThrow(row["status"], COMPONENT_STATUSES, "component status"),
+		components: recordsOf(row["components"] ?? [], fn).map((component) => publicComponentOf(component, fn)),
+		incidents: recordsOf(row["incidents"] ?? [], fn).map((incident) => publicIncidentOf(incident, fn)),
+		...optional("description", optionalText(row["description"]))
+	};
+}
+const attrsOf = (input) => ({
+	...optional("title", input.title),
+	...optional("description", input.description),
+	...optional("severity", input.severity),
+	...optional("public", input.public),
+	...optional("commanderId", input.commanderId),
+	...optional("message", input.message),
+	...optional("impacts", input.impacts)
+});
+/** The `incidents` SQL module as typed calls. */
+function createIncidents(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "incident fields");
+	const incident = (fn) => (value) => incidentOf(value, fn);
+	const postmortem = (fn) => (value) => postmortemOf(value, fn);
+	return withBlockHooks({
+		saveComponent: (organizationId, input) => call("save_status_component", {
+			tenant: organizationId,
+			name: input.name,
+			description: input.description ?? null,
+			group_name: input.group ?? null,
+			is_public: input.public ?? true,
+			sort_position: input.position ?? 0,
+			component_id: input.componentId ?? null
+		}, (value) => componentOf(value, "save_status_component")),
+		deleteComponent: (componentId) => call("delete_status_component", { component_id: componentId }, (value) => ({ id: textOf(recordOf(value, "delete_status_component")["id"]) })),
+		components: (organizationId) => call("list_status_components", { tenant: organizationId }, (value) => recordsOf(value, "list_status_components").map((row) => componentOf(row, "list_status_components"))),
+		open: (organizationId, input) => fields.args(input.fields).andThen((checked) => call("open_incident", {
+			tenant: organizationId,
+			attrs: attrsOf(input),
+			...checked === void 0 ? {} : { fields: checked }
+		}, incident("open_incident")).andThen(fields.row)),
+		update: (incidentId, changes) => fields.args(changes.fields).andThen((checked) => call("update_incident", {
+			incident_id: incidentId,
+			attrs: attrsOf(changes),
+			...checked === void 0 ? {} : { fields: checked }
+		}, incident("update_incident")).andThen(fields.row)),
+		postUpdate: (incidentId, input) => call("post_incident_update", {
+			incident_id: incidentId,
+			status: input.status,
+			body: input.body,
+			is_public: input.public ?? null
+		}, (value) => updateOf(value, "post_incident_update")),
+		setImpacts: (incidentId, impacts) => call("set_incident_impacts", {
+			incident_id: incidentId,
+			impacts
+		}, incident("set_incident_impacts")).andThen(fields.row),
+		get: (incidentId) => call("get_incident", { incident_id: incidentId }, (value) => detailOf(value, "get_incident")).andThen((row) => row === void 0 ? AsyncResult.ok(void 0) : fields.row(row)),
+		list: (organizationId, list = {}) => call("list_incidents", {
+			tenant: organizationId,
+			status: list.status ?? null,
+			severity: list.severity ?? null,
+			component_id: list.componentId ?? null,
+			before: list.before === void 0 ? null : instantArg(list.before),
+			page_size: list.pageSize ?? null
+		}, (value) => recordsOf(value, "list_incidents").map((row) => incidentOf(row, "list_incidents"))).andThen(fields.rows),
+		savePostmortem: (incidentId, input) => call("save_postmortem", {
+			incident_id: incidentId,
+			attrs: {
+				...optional("summary", input.summary),
+				...optional("impact", input.impact),
+				...optional("rootCause", input.rootCause),
+				...optional("resolution", input.resolution),
+				...optional("actionItems", input.actionItems)
+			}
+		}, postmortem("save_postmortem")),
+		publishPostmortem: (incidentId) => call("publish_postmortem", { incident_id: incidentId }, postmortem("publish_postmortem")),
+		saveStatusPage: (organizationId, input) => call("save_status_page", {
+			tenant: organizationId,
+			slug: input.slug,
+			title: input.title,
+			description: input.description ?? null,
+			published: input.published ?? false
+		}, (value) => pageOf(value, "save_status_page")),
+		statusPage: (organizationId) => call("get_status_page", { tenant: organizationId }, (value) => value === null || value === void 0 ? void 0 : pageOf(value, "get_status_page")),
+		publicStatusPage: (slug, days) => call("public_status_page", {
+			slug,
+			days: days ?? null
+		}, (value) => publicPageOf(value, "public_status_page"))
+	}, options.hooks, {
+		block: "incidents",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/incidents/events.ts
+/** The `incidents` block's event types, for its manifest and `onBlockEvent`. */
+const incidentsEvents = defineEvents({
+	"incident.opened": event(),
+	"incident.updated": event(),
+	"incident.resolved": event(),
+	"postmortem.published": event(),
+	"status_component.changed": event()
+});
+//#endregion
+//#region src/blocks/incidents/schemas.ts
+const SEVERITIES = [
+	"sev1",
+	"sev2",
+	"sev3",
+	"sev4"
+];
+const fields = {
+	kind: "json",
+	optional: true,
+	description: "The extra columns, keyed by database name."
+};
+/** What `open` takes. */
+const incidentInputSchema = entitySchema({
+	title: "IncidentInput",
+	fields: {
+		title: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		severity: {
+			kind: "enum",
+			values: SEVERITIES,
+			optional: true
+		},
+		public: {
+			kind: "boolean",
+			optional: true
+		},
+		commanderId: {
+			kind: "uuid",
+			optional: true
+		},
+		message: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		impacts: {
+			kind: "json",
+			optional: true,
+			array: true,
+			description: "The affected components: `[{ componentId, impact }]`."
+		},
+		fields
+	}
+});
+/** What `update` takes. */
+const incidentChangesSchema = entitySchema({
+	title: "IncidentChanges",
+	fields: {
+		title: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		severity: {
+			kind: "enum",
+			values: SEVERITIES,
+			optional: true
+		},
+		public: {
+			kind: "boolean",
+			optional: true
+		},
+		commanderId: {
+			kind: "uuid",
+			optional: true
+		},
+		fields
+	}
+});
+/** What `saveComponent` takes. */
+const statusComponentInputSchema = entitySchema({
+	title: "StatusComponentInput",
+	fields: {
+		name: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 2e3
+		},
+		group: {
+			kind: "string",
+			optional: true,
+			maxLength: 200
+		},
+		public: {
+			kind: "boolean",
+			optional: true
+		},
+		position: {
+			kind: "integer",
+			optional: true
+		},
+		componentId: {
+			kind: "uuid",
+			optional: true
+		}
+	}
+});
+/** What `savePostmortem` takes. */
+const postmortemInputSchema = entitySchema({
+	title: "PostmortemInput",
+	fields: {
+		summary: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		impact: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		rootCause: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		resolution: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e4
+		},
+		actionItems: {
+			kind: "json",
+			optional: true,
+			array: true
+		}
+	}
+});
+/** What `saveStatusPage` takes. */
+const statusPageInputSchema = entitySchema({
+	title: "StatusPageInput",
+	fields: {
+		slug: {
+			kind: "string",
+			minLength: 2,
+			maxLength: 63
+		},
+		title: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 2e3
+		},
+		published: {
+			kind: "boolean",
+			optional: true
+		}
+	}
+});
+//#endregion
+//#region src/blocks/incidents/manifest.ts
+/** The `incidents` block's manifest (ADR 0029). */
+const incidentsBlock = defineBlock({
+	name: "incidents",
+	sql: ["incidents"],
+	options: { incidents: incidentsSqlOptions },
+	events: incidentsEvents,
+	schemas: {
+		incident: {
+			input: incidentInputSchema,
+			change: incidentChangesSchema
+		},
+		status_component: { input: statusComponentInputSchema },
+		postmortem: { input: postmortemInputSchema },
+		status_page: { input: statusPageInputSchema }
+	},
+	create: createIncidents,
+	recipes: ["status-page"],
+	category: "developer"
+});
+//#endregion
+export { createIncidents, dbTransport, extendBlock, incidentChangesSchema, incidentInputSchema, incidentsBlock, incidentsEvents, postmortemInputSchema, rpcTransport, sqlTransport, statusComponentInputSchema, statusPageInputSchema, withBlockHooks, wrapTransport };

package/dist/blocks/index.d.ts

@@ -1,16 +1,150 @@
-import { a as WithExtraFields, n as ExtraFields, o as blockFields, r as FieldsOf, t as BlockFields } from "../block-fields-DnXkMney.js";
-import { Ct as EventSpec, Dt as event, Et as defineEvents, Ot as mergeEvents, St as EventMapOf, bt as onBlockEvent, w as BlockEmit, wt as Events, xt as EventMap } from "../events-DhGgwqQA.js";
-import { a as dbTransport, i as RpcClient, n as DbTransportOptions, o as rpcTransport, r as DbTransportSource, s as sqlTransport, t as BlockTransport } from "../block-transport-DBPhgF3W.js";
-import { i as CursorPageOptions, n as BlockOptions } from "../block-helpers-DyA5BAW4.js";
-import { a as BlockTransportMiddleware, c as ExtendBlockTools, d as extendBlock, f as withBlockHooks, i as BlockMethodName, l as WithBlockHooksOptions, n as BlockHooks, o as BlockTransportRequest, p as wrapTransport, r as BlockMethodHooks, s as ExtendBlockOptions, t as BlockHookInfo, u as defineTransportMiddleware } from "../block-hooks-BadAniNI.js";
-import { n as FinalRunState, r as RunState, t as FINAL_RUN_STATES } from "../run-state-CPo-1X2B.js";
-import { a as OptionKind, c as blockOptions, i as OptionInput, l as option, n as NO_OPTIONS, o as OptionSpec, r as OptionBuilders, s as OptionSpecs, t as BlockOptionsSchema, u as optionsJsonSchema } from "../options-CIf3xni7.js";
-import { A as BlockNaming, C as CreateBlocksOptions, D as GeneratedBlocks, E as GeneratedBlock, O as fillTopic, S as BlocksHooks, T as defineBlocks, _ as BlockMap, a as BlockConsumes, b as Blocks, c as BlockOptionSchemas, d as ConsumedPorts, f as ProvidedPorts, g as BlockContext, h as BLOCK_EVENT_SOURCE, i as BlockCategory, j as blockNames, k as generatedOptions, l as BlockProvides, m as defineBlock, n as BLOCK_CATEGORIES, o as BlockDefinition, p as UsingOptions, r as Block, s as BlockOf, t as AnyBlock, u as ClientOf, v as BlockSet, w as createBlocks, x as BlocksEventMap, y as BlockSinks } from "../define-block-MyM4lH42.js";
-import { i as PortName, n as Notifier, r as NotifierInput, t as BlockPorts } from "../ports-BltcWsHf.js";
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "../result-DZeA5KS6.js";
+import { a as WithExtraFields, n as ExtraFields, o as blockFields, r as FieldsOf, t as BlockFields } from "../block-fields-BE7pInWZ.js";
+import { $ as RecordRef } from "../types-DFdg_4yN.js";
+import { Ct as Events, Dt as mergeEvents, Et as event, St as EventSpec, Tt as defineEvents, bt as EventMap, w as BlockEmit, xt as EventMapOf } from "../events-vcqenSYU.js";
+import { z as onBlockEvent } from "../index-CG9rA8H8.js";
+import { a as BlockTenantOptions, i as CursorPageOptions, n as BlockOptions, o as BlockTenant } from "../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, n as DbTransportOptions, o as rpcTransport, r as DbTransportSource, s as sqlTransport, t as BlockTransport } from "../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, c as ExtendBlockTools, d as extendBlock, f as withBlockHooks, i as BlockMethodName, l as WithBlockHooksOptions, n as BlockHooks, o as BlockTransportRequest, p as wrapTransport, r as BlockMethodHooks, s as ExtendBlockOptions, t as BlockHookInfo, u as defineTransportMiddleware } from "../block-hooks-DZN2w69m.js";
+import { n as FinalRunState, r as RunState, t as FINAL_RUN_STATES } from "../run-state-BMCD_1Lt.js";
+import { a as OptionKind, c as blockOptions, i as OptionInput, l as option, n as NO_OPTIONS, o as OptionSpec, r as OptionBuilders, s as OptionSpecs, t as BlockOptionsSchema, u as optionsJsonSchema } from "../options-CsGl5BLH.js";
+import { A as CreateBlocksOptions, An as BlockNaming, C as BlockContext, Cn as EntitySchemaSpec, D as Blocks, Dn as GeneratedBlocks, E as BlockSinks, En as GeneratedBlock, F as BlockPorts, Fn as entityNames, I as Notifier, L as NotifierInput, M as createBlockClient, Mn as EntityNames, N as createBlocks, Nn as EntityNoun, O as BlocksEventMap, On as fillTopic, P as defineBlocks, Pn as EntityRename, R as PortName, S as BlockClientSource, Sn as EntitySchema, T as BlockSet, Tn as entitySchema, _ as BlockProvider, a as BlockConsumes, b as BLOCK_EVENT_SOURCE, bn as BlockSchemas, c as BlockOf, d as ClientOf, f as ConsumedPorts, g as BlockEnvKey, h as defineBlock, i as BlockCategory, j as UniquePort, jn as blockNames, k as BlocksHooks, kn as generatedOptions, l as BlockOptionSchemas, m as UsingOptions, n as BLOCK_CATEGORIES, o as BlockDefinition, p as ProvidedPorts, r as Block, s as BlockInvalidates, t as AnyBlock, tn as AnyRecordBinding, u as BlockProvides, v as BlockWiring, w as BlockMap, wn as EntitySchemas, x as BlockClientOptions, xn as EntityFieldSpecs, y as BlockWorker } from "../define-block-BVcLQ3DF.js";
+import { t as VisibleRange } from "../range-p5V4rBhZ.js";
+import { t as subjectKey } from "../block-subjects-CphkQPxp.js";
+import { t as BlockEnv } from "../block-env-B_uEM2xz.js";
+//#region src/blocks/block-env-options.d.ts
+/** What a hook passes a block creator from the env. */
+interface EnvBlockOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+}
+/**
+ * A block's transport and schema for a hook: the supabase-js client calls the
+ * schema and the function names `gen` wrote for `block` in `blockConfig`, or
+ * the module defaults when the client has no config.
+ */
+export declare function envBlockOptions(env: BlockEnv, block: string): EnvBlockOptions;
+/**
+ * The options `gen` wrote for `block`, such as the reactions `topic`; empty
+ * when the client has no config.
+ */
+export declare function envBlockSettings(env: BlockEnv, block: string): GeneratedBlock["options"];
+//#endregion
+//#region src/blocks/rename-block.d.ts
+/** One renamed noun as `blocks.generated.ts` writes it. */
+interface NounRename {
+  readonly from: {
+    readonly singular: string;
+    readonly plural: string;
+  };
+  readonly to: {
+    readonly singular: string;
+    readonly plural: string;
+  };
+}
+/** The renames a block's generated `names` carries, in order. */
+type NounRenames = readonly NounRename[];
+/** The renames in a block's generated `names`, or none. */
+type RenamesOf<N> = N extends {
+  readonly entities: infer E extends NounRenames;
+} ? E : [];
+type Upper = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type LowerOrDigit = Lowercase<Upper> | Digit;
+type Camel<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Head}${Capitalize<Camel<Tail>>}` : S;
+/**
+ * One form a rename matches: `bounded` forms need a word start before them
+ * (snake and camel), and `camel` is the target when an uppercase letter
+ * follows.
+ */
+interface Form {
+  readonly match: string;
+  readonly snake: string;
+  readonly camel: string;
+  readonly bounded: boolean;
+}
+type FormsOf<From extends string, To extends string> = [{
+  match: From;
+  snake: To;
+  camel: Camel<To>;
+  bounded: true;
+}, {
+  match: Camel<From>;
+  snake: Camel<To>;
+  camel: Camel<To>;
+  bounded: true;
+}, {
+  match: Capitalize<Camel<From>>;
+  snake: Capitalize<Camel<To>>;
+  camel: Capitalize<Camel<To>>;
+  bounded: false;
+}];
+type FormsFor<R extends NounRenames, N extends "plural" | "singular"> = R extends readonly [infer Head extends NounRename, ...infer Tail extends NounRenames] ? [...FormsOf<Head["from"][N], Head["to"][N]>, ...FormsFor<Tail, N>] : [];
+/**
+ * Every form of every rename, plurals first so `work_items` wins over
+ * `work_item`.
+ */
+type FormsOfRenames<R extends NounRenames> = [...FormsFor<R, "plural">, ...FormsFor<R, "singular">];
+type WordBreak = "_" | "-" | "." | ":" | " " | "/";
+type Starts<Before extends string> = Before extends "" ? true : Before extends `${string}${WordBreak}` ? true : false;
+type Marker<I extends number, Case extends "camel" | "snake"> = `\u0001${I}\u0003${Case}\u0002`;
+type CaseAfter<Rest extends string> = Rest extends `${Upper}${string}` ? "camel" : "snake";
+type Matches<F extends Form, Before extends string, Rest extends string> = Rest extends `${LowerOrDigit}${string}` ? false : F["bounded"] extends true ? Starts<Before> : true;
+/** `S` with every bounded occurrence of `F` marked. */
+type MarkForm<S extends string, F extends Form, I extends number, Done extends string = ""> = S extends `${infer A}${F["match"]}${infer B}` ? Matches<F, `${Done}${A}`, B> extends true ? MarkForm<B, F, I, `${Done}${A}${Marker<I, CaseAfter<B>>}`> : MarkForm<B, F, I, `${Done}${A}${F["match"]}`> : `${Done}${S}`;
+type MarkAll<S extends string, Forms extends readonly Form[], I extends readonly unknown[] = []> = Forms extends readonly [infer F extends Form, ...infer Others extends readonly Form[]] ? MarkAll<string extends F["match"] ? S : MarkForm<S, F, I["length"]>, Others, [...I, unknown]> : S;
+type Unmark<S extends string, Forms extends readonly Form[], Done extends string = ""> = S extends `${infer A}\u0001${infer N extends number}\u0003${infer C extends "camel" | "snake"}\u0002${infer B}` ? Unmark<B, Forms, `${Done}${A}${Forms[N] extends Form ? Forms[N][C] : ""}`> : `${Done}${S}`;
+type Rename<S extends string, Forms extends readonly Form[]> = Unmark<MarkAll<S, Forms>, Forms>;
+/**
+ * An identifier with every renamed noun in its new name, in snake, camel and
+ * pascal case: `RenameKey<"projectId", R>` is `initiativeId` when `R` renames
+ * `project` to `initiative`.
+ */
+type RenameKey<K, R extends NounRenames> = K extends string ? Rename<K, FormsOfRenames<R>> : K;
+type Leaf = string | number | boolean | bigint | symbol | null | undefined | Date | Uint8Array | DbError | Temporal.Instant | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.PlainTime | Temporal.ZonedDateTime | Temporal.Duration;
+type Opaque = "fields" | "metadata";
+type MaxDepth = 6;
+type Deeper<D extends readonly unknown[]> = [...D, unknown];
+type RenamedEntry<K, V, R extends NounRenames, D extends readonly unknown[]> = K extends Opaque ? V : K extends "field" ? RenameKey<V, R> : RenamedValue<V, R, D>;
+type RenamedValue<T, R extends NounRenames, D extends readonly unknown[]> = D["length"] extends MaxDepth ? T : T extends Leaf ? T : T extends AsyncResult<infer V> ? AsyncResult<RenamedValue<V, R, Deeper<D>>> : T extends Promise<infer V> ? Promise<RenamedValue<V, R, Deeper<D>>> : T extends ((...args: infer A) => infer Ret) ? (...args: RenamedValue<A, R, Deeper<D>>) => RenamedValue<Ret, R, Deeper<D>> : T extends readonly unknown[] ? { [K in keyof T]: RenamedValue<T[K], R, Deeper<D>>; } : T extends object ? { [K in keyof T as RenameKey<K, R>]: RenamedEntry<K, T[K], R, Deeper<D>>; } : T;
+/**
+ * `T` with every key renamed through `R`, nested up to six levels: rows, inputs
+ * and filters. The values under `fields` and `metadata` keep their keys.
+ * `RenamedType<WorkItem, R>` has `initiativeId` where `WorkItem` has
+ * `projectId`.
+ */
+type RenamedType<T, R extends NounRenames> = R extends readonly [] ? T : RenamedValue<T, R, []>;
+/**
+ * A block client with its method names, argument keys and result keys renamed:
+ * `saveProject` becomes `saveInitiative` and its rows carry `initiativeId`.
+ */
+type RenamedClient<C, R extends NounRenames> = RenamedType<C, R>;
+/** An event map with renamed types and payload keys. */
+type RenamedEvents<M extends EventMap, R extends NounRenames> = R extends readonly [] ? M : { readonly [K in keyof M as RenameKey<K, R>]: RenamedType<M[K], R>; };
+/** A creator's options with hooks keyed by the renamed client's methods. */
+type RenamedOptions<O, Client, R extends NounRenames> = R extends readonly [] ? O : O extends {
+  readonly hooks?: unknown;
+} ? Omit<O, "hooks"> & {
+  readonly hooks?: BlockHooks<RenamedClient<Client, R>>;
+} : O;
+/** A block with its client, events and hooks under the renamed nouns. */
+type RenamedBlock<B, R extends NounRenames> = B extends Block<infer Name, infer O, infer Client, infer M, infer C, infer P, infer S> ? Block<Name, RenamedOptions<O, Client, R>, RenamedClient<Client, R>, RenamedEvents<M, R>, C, P, S> : never;
+/**
+ * `block` under the names `blocks.<name>.entities` gives its entities: method
+ * names (`saveProject` to `saveInitiative`), argument and result keys
+ * (`projectId` to `initiativeId`) and event types (`work_item.created` to
+ * `task.created`), with the same `name`, SQL and ports. Hooks see the renamed
+ * client. Pass the block's `names` from `blocks.generated.ts`, which `gen`
+ * writes as `export const tasksBlock = renameBlock(tasksBlock,
+ * blockConfig["tasks"].names)`; with no renamed entity it returns `block`.
+ */
+export declare function renameBlock<Name extends string, O, Client, M extends EventMap, C extends BlockConsumes, P extends PortName, R extends AnyRecordBinding | undefined, const N extends BlockNaming | undefined>(block: Block<Name, O, Client, M, C, P, R>, names: N): RenamedBlock<Block<Name, O, Client, M, C, P, R>, RenamesOf<N>>;
+//#endregion
 //#region src/blocks/app-table-events.d.ts
 /**
  * The data of an app table event (ADR 0048): `<type>.created`, `.updated` and
- * `.deleted`, written by the trigger `appTables.<table>.events` adds.
+ * `.deleted`, written by the trigger `tables.<table>.events` adds.
  */
 interface AppTableEventData {
   /** The row id. */
@@ -26,4 +160,4 @@ interface AppTableEventData {
   readonly [column: string]: unknown;
 }
 //#endregion
-export { type AnyBlock, type AppTableEventData, BLOCK_CATEGORIES, BLOCK_EVENT_SOURCE, type Block, type BlockCategory, type BlockConsumes, type BlockContext, type BlockDefinition, type BlockEmit, type BlockFields, type BlockHookInfo, type BlockHooks, type BlockMap, type BlockMethodHooks, type BlockMethodName, type BlockNaming, type BlockOf, type BlockOptionSchemas, type BlockOptions, type BlockOptionsSchema, type BlockPorts, type BlockProvides, type BlockSet, type BlockSinks, type BlockTransport, type BlockTransportMiddleware, type BlockTransportRequest, type Blocks, type BlocksEventMap, type BlocksHooks, type ClientOf, type ConsumedPorts, type CreateBlocksOptions, type CursorPageOptions, type DbTransportOptions, type DbTransportSource, type EventMap, type EventMapOf, type EventSpec, type Events, type ExtendBlockOptions, type ExtendBlockTools, type ExtraFields, FINAL_RUN_STATES, type FieldsOf, type FinalRunState, type GeneratedBlock, type GeneratedBlocks, NO_OPTIONS, type Notifier, type NotifierInput, type OptionBuilders, type OptionInput, type OptionKind, type OptionSpec, type OptionSpecs, type PortName, type ProvidedPorts, type RpcClient, type RunState, type UsingOptions, type WithBlockHooksOptions, type WithExtraFields, blockFields, blockNames, blockOptions, createBlocks, dbTransport, defineBlock, defineBlocks, defineEvents, defineTransportMiddleware, event, extendBlock, fillTopic, generatedOptions, mergeEvents, onBlockEvent, option, optionsJsonSchema, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };
+export { type AnyBlock, type AppTableEventData, BLOCK_CATEGORIES, BLOCK_EVENT_SOURCE, type Block, type BlockCategory, type BlockClientOptions, type BlockClientSource, type BlockConsumes, type BlockContext, type BlockDefinition, type BlockEmit, type BlockEnv, type BlockEnvKey, type BlockFields, type BlockHookInfo, type BlockHooks, type BlockInvalidates, type BlockMap, type BlockMethodHooks, type BlockMethodName, type BlockNaming, type BlockOf, type BlockOptionSchemas, type BlockOptions, type BlockOptionsSchema, type BlockPorts, type BlockProvider, type BlockProvides, type BlockSchemas, type BlockSet, type BlockSinks, type BlockTenant, type BlockTenantOptions, type BlockTransport, type BlockTransportMiddleware, type BlockTransportRequest, type BlockWiring, type BlockWorker, type Blocks, type BlocksEventMap, type BlocksHooks, type ClientOf, type ConsumedPorts, type CreateBlocksOptions, type CursorPageOptions, type DbTransportOptions, type DbTransportSource, type EntityFieldSpecs, type EntityNames, type EntityNoun, type EntityRename, type EntitySchema, type EntitySchemaSpec, type EntitySchemas, type EnvBlockOptions, type EventMap, type EventMapOf, type EventSpec, type Events, type ExtendBlockOptions, type ExtendBlockTools, type ExtraFields, FINAL_RUN_STATES, type FieldsOf, type FinalRunState, type GeneratedBlock, type GeneratedBlocks, NO_OPTIONS, type Notifier, type NotifierInput, type NounRename, type NounRenames, type OptionBuilders, type OptionInput, type OptionKind, type OptionSpec, type OptionSpecs, type PortName, type ProvidedPorts, type RecordRef, type RenameKey, type RenamedBlock, type RenamedClient, type RenamedEvents, type RenamedOptions, type RenamedType, type RenamesOf, type RpcClient, type RunState, type UniquePort, type UsingOptions, type VisibleRange, type WithBlockHooksOptions, type WithExtraFields, blockFields, blockNames, blockOptions, createBlockClient, createBlocks, dbTransport, defineBlock, defineBlocks, defineEvents, defineTransportMiddleware, entityNames, entitySchema, event, extendBlock, fillTopic, generatedOptions, mergeEvents, onBlockEvent, option, optionsJsonSchema, rpcTransport, sqlTransport, subjectKey, withBlockHooks, wrapTransport };