better-supabase 0.8.0 → 0.10.0

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

@@ -0,0 +1,13 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as SvelteController } from "../../../svelte-controller-DDbju9CW.js";
+import { a as UsageMeterSnapshot, i as UsageMeterControllerOptions, n as UsageMeterActions } from "../../../client-BLKpcAs0.js";
+//#region src/blocks/usage/svelte/index.d.ts
+/**
+ * `createUsageMeterController` as a Svelte readable store of the snapshot, with
+ * the actions on `.actions`. Call it in a component's script; the work starts
+ * on mount and the controller is disposed with the component. `auth` and
+ * `ports` default to the client of `setBetterSupabase(bs)`.
+ */
+export declare function useUsageMeter(options: BlockOptions<UsageMeterControllerOptions>): SvelteController<UsageMeterSnapshot, UsageMeterActions>;
+//#endregion
+export type { BlockOptions, SvelteController, UsageMeterActions, UsageMeterControllerOptions, UsageMeterSnapshot };

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

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

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

@@ -0,0 +1,13 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as VueController } from "../../../vue-controller-D_ohttBZ.js";
+import { a as UsageMeterSnapshot, i as UsageMeterControllerOptions, n as UsageMeterActions } from "../../../client-BLKpcAs0.js";
+//#region src/blocks/usage/vue/index.d.ts
+/**
+ * `createUsageMeterController` as a Vue composable: `state` is a shallow ref of
+ * the snapshot. Call it in `setup` or an effect scope; the work starts on mount
+ * and the controller is disposed with the scope. `auth` and `ports` default to
+ * the client of `app.use(betterSupabase(bs))`.
+ */
+export declare function useUsageMeter(options: BlockOptions<UsageMeterControllerOptions>): VueController<UsageMeterSnapshot, UsageMeterActions>;
+//#endregion
+export type { BlockOptions, UsageMeterActions, UsageMeterControllerOptions, UsageMeterSnapshot, VueController };

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

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

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

@@ -0,0 +1,169 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
+import { A as CollaborationEventData, wt as Events } from "../../events-CtAHxPal.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { n as BlockOptions } from "../../block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+//#region src/blocks/versions/json-patch.d.ts
+/** A JSON value, as a version's content holds it. */
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+  readonly [key: string]: JsonValue;
+};
+/** One RFC 6902 JSON Patch operation. Paths are RFC 6901 JSON Pointers. */
+type JsonPatchOperation = {
+  readonly op: "add";
+  readonly path: string;
+  readonly value: JsonValue;
+} | {
+  readonly op: "remove";
+  readonly path: string;
+} | {
+  readonly op: "replace";
+  readonly path: string;
+  readonly value: JsonValue;
+} | {
+  readonly op: "move";
+  readonly from: string;
+  readonly path: string;
+} | {
+  readonly op: "copy";
+  readonly from: string;
+  readonly path: string;
+} | {
+  readonly op: "test";
+  readonly path: string;
+  readonly value: JsonValue;
+};
+/** Thrown by `applyPatch` for an operation RFC 6902 calls an error. */
+export declare class JsonPatchError extends Error {
+  override readonly name = "JsonPatchError";
+  /** The index of the failing operation in the patch. */
+  readonly index: number;
+  constructor(message: string, index: number);
+}
+/** Deep equality of two JSON values; object key order doesn't matter. */
+export declare function jsonEqual(a: JsonValue, b: JsonValue): boolean;
+/**
+ * Applies an RFC 6902 patch to a copy of `document` and returns the copy.
+ * Throws a `JsonPatchError` for an operation the RFC calls an error; the
+ * input is never changed.
+ */
+export declare function applyPatch(document: JsonValue, patch: readonly JsonPatchOperation[]): JsonValue;
+/**
+ * The RFC 6902 patch that turns `from` into `to`: `add`, `remove` and
+ * `replace` operations, with array elements compared by position.
+ * `applyPatch(from, createPatch(from, to))` equals `to`.
+ */
+export declare function createPatch(from: JsonValue, to: JsonValue): JsonPatchOperation[];
+//#endregion
+//#region src/blocks/versions/versions.d.ts
+interface VersionsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the version's extra columns
+   * (`blocks.versions.options.extraColumns`), keyed by database name. It
+   * types and parses them on `list` and `get`, and validates them on
+   * `snapshot`. `getShared` leaves them out.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Versions<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+type VersionSource = "manual" | "auto" | "restore";
+/** One version of a subject. `content` is there when it was read with `get`. */
+interface Version<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly number: number;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** A named version is kept out of retention. */
+  readonly label?: string;
+  readonly source: VersionSource;
+  /** Written by a state change (`freeze`); it can't be relabeled or deleted. */
+  readonly frozen: boolean;
+  readonly contentHash: string;
+  /** A Storage path, for content kept outside the table. */
+  readonly storagePath?: string;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly content?: JsonValue;
+  /** The extra columns, keyed by database name; empty from `getShared`. */
+  readonly fields: ExtraFields<F>;
+}
+interface SnapshotInput<F extends object = Record<never, never>> {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /**
+   * The content to keep. Leave it out to copy the subject's `columns`
+   * (`blocks.versions.options.subjects.<type>.columns`).
+   */
+  readonly content?: JsonValue;
+  readonly label?: string;
+  readonly storagePath?: string;
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+interface SnapshotResult {
+  readonly id: string;
+  readonly number: number;
+  readonly contentHash: string;
+  /** `true` when the content matched the latest version, which is returned instead. */
+  readonly unchanged: boolean;
+}
+interface RestoreResult extends SnapshotResult {
+  /** The number of the version that was restored. */
+  readonly restoredFrom: number;
+  readonly content: JsonValue;
+}
+interface VersionListOptions {
+  readonly pageSize?: number;
+  /** Versions numbered below this one, for the next page. */
+  readonly before?: number;
+}
+interface Versions<F extends object = Record<never, never>> {
+  snapshot(input: SnapshotInput<F>): AsyncResult<SnapshotResult>;
+  /** Newest first, without content. */
+  list(organizationId: string, subjectType: string, subjectId: string, options?: VersionListOptions): AsyncResult<readonly Version<F>[]>;
+  get(id: string): AsyncResult<Version<F>>;
+  /**
+   * The version a share link is pinned to, with its content, read with the
+   * token alone (anon). `null` for an unknown, revoked or expired token, or
+   * a link without a version. Needs the share-links module.
+   */
+  getShared(token: string): AsyncResult<Version | null>;
+  /** Writes the version back to its subject and records that as a new version. */
+  restore(id: string): AsyncResult<RestoreResult>;
+  /**
+   * Writes only `fields` of the version back; the subject's other columns
+   * keep their current values. Needs a subject type with `columns`.
+   */
+  restoreFields(id: string, fields: readonly string[]): AsyncResult<RestoreResult>;
+  /** Names a version, which keeps it; `null` removes the name. */
+  label(id: string, label: string | null): AsyncResult<boolean>;
+  delete(id: string): AsyncResult<boolean>;
+  /** The RFC 6902 patch from version `fromId` to version `toId`. */
+  diff(fromId: string, toId: string): AsyncResult<JsonPatchOperation[]>;
+}
+export declare function createVersions<S extends StandardSchemaV1 | undefined = undefined>(options: VersionsOptions<S>): Versions<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/versions/events.d.ts
+/** The events of the `versions` block: type to data. */
+type VersionsEvents = {
+  readonly "version.created": CollaborationEventData;
+  readonly "version.restored": CollaborationEventData;
+  readonly "version.deleted": CollaborationEventData;
+};
+/** The `versions` block's event types, for its manifest and `onBlockEvent`. */
+export declare const versionsEvents: Events<VersionsEvents>;
+//#endregion
+//#region src/blocks/versions/manifest.d.ts
+/** The `versions` block's manifest (ADR 0029). */
+export declare const versionsBlock: BlockOf<"versions", typeof createVersions, VersionsEvents>;
+//#endregion
+export { type BlockTransport, type JsonPatchOperation, type JsonValue, type RestoreResult, type SnapshotInput, type SnapshotResult, type Version, type VersionListOptions, type VersionSource, type Versions, type VersionsEvents, type VersionsOptions, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/versions/index.js

@@ -0,0 +1,288 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as versionsSqlOptions } from "../../options-DXqcJyOP.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-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-BfVCR5Fc.js";
+import { r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { n as blockFields } from "../../block-fields-BANwJ9Y_.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+//#region src/blocks/versions/json-patch.ts
+/** Thrown by `applyPatch` for an operation RFC 6902 calls an error. */
+var JsonPatchError = class extends Error {
+	name = "JsonPatchError";
+	/** The index of the failing operation in the patch. */
+	index;
+	constructor(message, index) {
+		super(message);
+		this.index = index;
+	}
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const escape = (token) => token.replaceAll("~", "~0").replaceAll("/", "~1");
+/** The reference tokens of an RFC 6901 pointer. */
+function tokensOf(pointer, index) {
+	if (pointer === "") return [];
+	if (!pointer.startsWith("/")) throw new JsonPatchError(`"${pointer}" is not a JSON Pointer`, index);
+	return pointer.slice(1).split("/").map((token) => {
+		if (/~[^01]|~$/.test(token)) throw new JsonPatchError(`"${pointer}" has an invalid escape`, index);
+		return token.replaceAll("~1", "/").replaceAll("~0", "~");
+	});
+}
+const ARRAY_INDEX = /^(0|[1-9][0-9]*)$/;
+function arrayIndex(array, token, index, adding) {
+	if (adding && token === "-") return array.length;
+	if (!ARRAY_INDEX.test(token)) throw new JsonPatchError(`"${token}" is not an array index`, index);
+	const position = Number(token);
+	if (position > array.length || !adding && position === array.length) throw new JsonPatchError(`index ${token} is out of bounds`, index);
+	return position;
+}
+/** Deep equality of two JSON values; object key order doesn't matter. */
+function jsonEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		const left = a;
+		const right = b;
+		return left.every((item, i) => jsonEqual(item, right[i] ?? null));
+	}
+	if (!isObject(a) || !isObject(b)) return false;
+	const keys = Object.keys(a);
+	if (keys.length !== Object.keys(b).length) return false;
+	return keys.every((key) => Object.hasOwn(b, key) && jsonEqual(a[key] ?? null, b[key] ?? null));
+}
+function clone(value) {
+	return structuredClone(value);
+}
+function get(document, tokens, index) {
+	let current = document;
+	for (const token of tokens) if (Array.isArray(current)) current = current[arrayIndex(current, token, index, false)] ?? null;
+	else if (isObject(current) && Object.hasOwn(current, token)) current = current[token] ?? null;
+	else throw new JsonPatchError(`"/${tokens.join("/")}" does not exist`, index);
+	return current;
+}
+function add(root, tokens, value, index) {
+	const last = tokens.at(-1);
+	if (last === void 0) {
+		root.value = value;
+		return;
+	}
+	const parent = get(root.value, tokens.slice(0, -1), index);
+	if (Array.isArray(parent)) parent.splice(arrayIndex(parent, last, index, true), 0, value);
+	else if (isObject(parent)) parent[last] = value;
+	else throw new JsonPatchError("the target's parent is not a container", index);
+}
+function remove(root, tokens, index) {
+	const last = tokens.at(-1);
+	if (last === void 0) {
+		const value = root.value;
+		root.value = null;
+		return value;
+	}
+	const parent = get(root.value, tokens.slice(0, -1), index);
+	if (Array.isArray(parent)) {
+		const [removed] = parent.splice(arrayIndex(parent, last, index, false), 1);
+		return removed ?? null;
+	}
+	if (isObject(parent) && Object.hasOwn(parent, last)) {
+		const value = parent[last] ?? null;
+		Reflect.deleteProperty(parent, last);
+		return value;
+	}
+	throw new JsonPatchError(`"/${tokens.join("/")}" does not exist`, index);
+}
+/**
+* Applies an RFC 6902 patch to a copy of `document` and returns the copy.
+* Throws a `JsonPatchError` for an operation the RFC calls an error; the
+* input is never changed.
+*/
+function applyPatch(document, patch) {
+	const root = { value: clone(document) };
+	patch.forEach((operation, index) => {
+		const tokens = tokensOf(operation.path, index);
+		switch (operation.op) {
+			case "add":
+				add(root, tokens, clone(operation.value), index);
+				break;
+			case "remove":
+				remove(root, tokens, index);
+				break;
+			case "replace":
+				remove(root, tokens, index);
+				add(root, tokens, clone(operation.value), index);
+				break;
+			case "move": {
+				if (operation.path !== operation.from && operation.path.startsWith(`${operation.from}/`)) throw new JsonPatchError("a value can't be moved into one of its children", index);
+				const value = remove(root, tokensOf(operation.from, index), index);
+				add(root, tokens, value, index);
+				break;
+			}
+			case "copy":
+				add(root, tokens, clone(get(root.value, tokensOf(operation.from, index), index)), index);
+				break;
+			case "test":
+				if (!jsonEqual(get(root.value, tokens, index), operation.value)) throw new JsonPatchError(`test failed at "${operation.path}"`, index);
+				break;
+			default: throw new JsonPatchError(`unknown operation ${JSON.stringify(operation)}`, index);
+		}
+	});
+	return root.value;
+}
+function diff(from, to, path, out) {
+	if (jsonEqual(from, to)) return;
+	if (Array.isArray(from) && Array.isArray(to)) {
+		const left = from;
+		const right = to;
+		const shared = Math.min(left.length, right.length);
+		for (let i = 0; i < shared; i += 1) diff(left[i] ?? null, right[i] ?? null, `${path}/${String(i)}`, out);
+		for (let i = left.length - 1; i >= shared; i -= 1) out.push({
+			op: "remove",
+			path: `${path}/${String(i)}`
+		});
+		for (let i = shared; i < right.length; i += 1) out.push({
+			op: "add",
+			path: `${path}/${String(i)}`,
+			value: right[i] ?? null
+		});
+		return;
+	}
+	if (isObject(from) && isObject(to)) {
+		for (const key of Object.keys(from)) if (!Object.hasOwn(to, key)) out.push({
+			op: "remove",
+			path: `${path}/${escape(key)}`
+		});
+		for (const [key, value] of Object.entries(to)) {
+			const child = `${path}/${escape(key)}`;
+			if (Object.hasOwn(from, key)) diff(from[key] ?? null, value, child, out);
+			else out.push({
+				op: "add",
+				path: child,
+				value
+			});
+		}
+		return;
+	}
+	out.push({
+		op: "replace",
+		path,
+		value: to
+	});
+}
+/**
+* The RFC 6902 patch that turns `from` into `to`: `add`, `remove` and
+* `replace` operations, with array elements compared by position.
+* `applyPatch(from, createPatch(from, to))` equals `to`.
+*/
+function createPatch(from, to) {
+	const out = [];
+	diff(from, to, "", out);
+	return out;
+}
+//#endregion
+//#region src/blocks/versions/versions.ts
+const SOURCES = [
+	"manual",
+	"auto",
+	"restore"
+];
+function versionOf(value, fn) {
+	const row = recordOf(value, fn);
+	const label = optionalText(row["label"]);
+	const storagePath = optionalText(row["storagePath"]);
+	const createdBy = optionalText(row["createdBy"]);
+	return {
+		id: textOf(row["id"]),
+		number: Number(row["number"]),
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		source: enumOrThrow(row["source"], SOURCES, "version source"),
+		frozen: row["frozen"] === true,
+		contentHash: textOf(row["contentHash"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...label === void 0 ? {} : { label },
+		...storagePath === void 0 ? {} : { storagePath },
+		...createdBy === void 0 ? {} : { createdBy },
+		..."content" in row ? { content: jsonOf(row["content"]) } : {},
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+const jsonOf = (value) => value ?? null;
+function snapshotOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		number: Number(row["number"]),
+		contentHash: textOf(row["contentHash"]),
+		unchanged: row["unchanged"] === true
+	};
+}
+/** The `versions` SQL module as typed calls. */
+function restoreOf(value) {
+	const row = recordOf(value, "restore_version");
+	return {
+		...snapshotOf(row, "restore_version"),
+		restoredFrom: Number(row["restoredFrom"]),
+		content: jsonOf(row["content"])
+	};
+}
+function createVersions(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "version fields");
+	const get = (id) => call("get_version", { version_id: id }, (value) => versionOf(value, "get_version")).andThen(fields.row);
+	return withBlockHooks({
+		getShared: (token) => call("get_shared_version", { token }, (value) => value === null || value === void 0 ? null : versionOf(value, "get_shared_version")),
+		snapshot: (input) => fields.args(input.fields).andThen((checked) => call("snapshot_version", {
+			tenant: input.organizationId,
+			subject_type: input.subjectType,
+			subject_id: input.subjectId,
+			content: input.content ?? null,
+			label: input.label ?? null,
+			storage_path: input.storagePath ?? null,
+			fields: checked
+		}, (value) => snapshotOf(value, "snapshot_version"))),
+		list: (organizationId, subjectType, subjectId, page = {}) => call("list_versions", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			page_size: page.pageSize ?? null,
+			before: page.before ?? null
+		}, (value) => recordsOf(value, "list_versions").map((row) => versionOf(row, "list_versions"))).andThen(fields.rows),
+		get,
+		restore: (id) => call("restore_version", { version_id: id }, restoreOf),
+		restoreFields: (id, fields) => call("restore_version", {
+			version_id: id,
+			fields: [...fields]
+		}, restoreOf),
+		label: (id, label) => call("label_version", {
+			version_id: id,
+			label
+		}, (value) => value === true),
+		delete: (id) => call("delete_version", { version_id: id }, (value) => value === true),
+		diff: (fromId, toId) => get(fromId).andThen((from) => get(toId).map((to) => createPatch(from.content ?? null, to.content ?? null)))
+	}, options.hooks, {
+		block: "versions",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/versions/events.ts
+/** The `versions` block's event types, for its manifest and `onBlockEvent`. */
+const versionsEvents = defineEvents({
+	"version.created": event(),
+	"version.restored": event(),
+	"version.deleted": event()
+});
+//#endregion
+//#region src/blocks/versions/manifest.ts
+/** The `versions` block's manifest (ADR 0029). */
+const versionsBlock = defineBlock({
+	name: "versions",
+	sql: ["versions"],
+	options: { versions: versionsSqlOptions },
+	events: versionsEvents,
+	create: createVersions,
+	category: "content",
+	recipes: ["version-history", "record-history"]
+});
+//#endregion
+export { JsonPatchError, applyPatch, createPatch, createVersions, dbTransport, jsonEqual, rpcTransport, sqlTransport, versionsBlock, versionsEvents };

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

@@ -1,11 +1,18 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "../../result-BchM1XZn.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-inD4fFq-.js";
-import { r as BlockTemporalOptions } from "../../block-helpers-C0Xj8War.js";
-import { n as VerifyOptions } from "../../signatures-BRS_p3WD.js";
+import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
+import { G as InviteCodeEventData, Z as OrganizationEventData, mt as WaitlistEventData, wt as Events } from "../../events-CtAHxPal.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { n as BlockOptions } from "../../block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+import { n as VerifyOptions } from "../../signatures-BMdJ7neI.js";
 //#region src/blocks/waitlist/waitlist.d.ts
 type WaitlistStatus = "waiting" | "approved" | "rejected" | "joined";
-interface WaitlistEntry {
+/** An entry. `F` types the extra columns the `fields` schema describes. */
+interface WaitlistEntry<F extends object = Record<never, never>> {
   readonly id: string;
   readonly email: string;
   readonly status: WaitlistStatus;
@@ -16,6 +23,8 @@ interface WaitlistEntry {
   readonly decidedBy: string | undefined;
   readonly decidedAt: Temporal.Instant | undefined;
   readonly createdAt: Temporal.Instant;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
 }
 /**
  * What `join` tells the person. Without the service role it is always
@@ -47,7 +56,7 @@ interface CreateInviteCodeInput {
   readonly expiresAt?: Temporal.Instant;
   /** Adds whoever redeems the code to this organization. */
   readonly organizationId?: string;
-  /** The role in `organizationId`; `sql.modules.waitlist.options.defaultRole` otherwise. */
+  /** The role in `organizationId`; `blocks.waitlist.options.defaultRole` otherwise. */
   readonly role?: string;
   /** Your own code, such as `LAUNCH2026`; a random one otherwise. */
   readonly code?: string;
@@ -57,27 +66,39 @@ interface Redemption {
   /** The role the code granted; `undefined` when the user was a member already. */
   readonly role: string | undefined;
 }
-interface WaitlistOptions extends BlockTemporalOptions {
-  readonly transport: BlockTransport;
-  /** The module schema (`sql.modules.waitlist.schema`), default `better_supabase`. */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
+interface WaitlistOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the entry's extra columns
+   * (`blocks.waitlist.options.extraColumns`), keyed by database name, such
+   * as a company or a use case from the sign-up form. It types and parses
+   * them on `entries`, `approve` and `reject`, and validates them on `join`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Waitlist<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
 }
-interface Waitlist {
-  /** Adds an address, or returns its place when it is already there. Works signed out; see `WaitlistPlace`. */
+interface Waitlist<F extends object = Record<never, never>> {
+  /**
+   * Adds an address, or returns its place when it is already there. Works
+   * signed out; see `WaitlistPlace`. `fields` is written only when the
+   * address is new.
+   */
   join(email: string, options?: {
     readonly referrer?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly fields?: Partial<F>;
   }): AsyncResult<WaitlistPlace>;
   /** Entries by position; needs `waitlist.manage` on the platform. */
   entries(options?: {
     readonly status?: WaitlistStatus | null;
     readonly limit?: number;
     readonly afterPosition?: number;
-  }): AsyncResult<readonly WaitlistEntry[]>;
+  }): AsyncResult<readonly WaitlistEntry<F>[]>;
   /** Lets the address sign up and emits `waitlist.approved`. */
-  approve(entryId: string): AsyncResult<WaitlistEntry>;
-  reject(entryId: string): AsyncResult<WaitlistEntry>;
+  approve(entryId: string): AsyncResult<WaitlistEntry<F>>;
+  reject(entryId: string): AsyncResult<WaitlistEntry<F>>;
   /** Creates a code; `code` is shown once, the database keeps its hash. */
   createCode(input?: CreateInviteCodeInput): AsyncResult<{
     readonly code: string;
@@ -91,13 +112,14 @@ interface Waitlist {
 }
 /** A random code in groups of four, without characters that look alike. */
 export declare function generateInviteCode(): string;
-export declare function createWaitlist(options: WaitlistOptions): Waitlist;
+/** The `waitlist` SQL module as typed calls. */
+export declare function createWaitlist<S extends StandardSchemaV1 | undefined = undefined>(options: WaitlistOptions<S>): Waitlist<FieldsOf<S>>;
 interface WaitlistHookOptions {
   /** A service transport: `waitlist_admit` is granted to the service role. */
   readonly transport: BlockTransport;
   /** The hook secret, `v1,whsec_...`, or several while rotating. */
   readonly secret: string | readonly string[];
-  /** The user metadata field the client puts the code in (`codeField`), default `invite_code`. */
+  /** The user metadata field the client puts the code in: `blockConfig.waitlist.options.codeField` from `blocks.generated.ts`, default `invite_code`. */
   readonly codeField?: string;
   /** What Supabase Auth tells a rejected sign-up. */
   readonly message?: string;
@@ -114,4 +136,20 @@ interface WaitlistHookOptions {
  */
 export declare function waitlistHook(options: WaitlistHookOptions): (request: Request) => Promise<Response>;
 //#endregion
-export { type BlockTransport, type CreateInviteCodeInput, type InviteCode, type Redemption, type Waitlist, type WaitlistEntry, type WaitlistHookOptions, type WaitlistOptions, type WaitlistPlace, type WaitlistStatus, dbTransport, rpcTransport, sqlTransport };
+//#region src/blocks/waitlist/events.d.ts
+/** The events of the `waitlist` block: type to data. */
+type WaitlistEvents = {
+  readonly "organization.member_added": OrganizationEventData;
+  readonly "waitlist.approved": WaitlistEventData;
+  readonly "waitlist.rejected": WaitlistEventData;
+  readonly "invite_code.created": InviteCodeEventData;
+  readonly "invite_code.revoked": InviteCodeEventData;
+};
+/** The `waitlist` block's event types, for its manifest and `onBlockEvent`. */
+export declare const waitlistEvents: Events<WaitlistEvents>;
+//#endregion
+//#region src/blocks/waitlist/manifest.d.ts
+/** The `waitlist` block's manifest (ADR 0029). */
+export declare const waitlistBlock: BlockOf<"waitlist", typeof createWaitlist, WaitlistEvents>;
+//#endregion
+export { type BlockTransport, type CreateInviteCodeInput, type InviteCode, type Redemption, type Waitlist, type WaitlistEntry, type WaitlistEvents, type WaitlistHookOptions, type WaitlistOptions, type WaitlistPlace, type WaitlistStatus, dbTransport, rpcTransport, sqlTransport };