better-supabase 0.14.0 → 0.15.0

package/dist/blocks/sessions/index.js

@@ -1,6 +1,177 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { a as ok, r as err } from "../../result-ntFBW2p2.js";
 import { t as sessionsSqlOptions } from "../../options-D40CQzji.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { n as createOAuthGrantsController, t as createOAuthConsentController } from "../../client-BcXmbm4f.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { R as toInstant } from "../../block-helpers-CtBdjgO4.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as authResult } from "../../auth-reply-tlXB2FQ9.js";
+//#region src/blocks/sessions/client.ts
+const filled = (value) => value === null || value === void 0 || value === "" ? void 0 : value;
+const clientInfo = (raw) => ({
+	id: raw.id,
+	name: raw.name,
+	uri: filled(raw.uri),
+	logoUri: filled(raw.logo_uri)
+});
+const hostOf = (uri) => {
+	try {
+		return new URL(uri).host;
+	} catch {
+		return uri;
+	}
+};
+/**
+* Reads per authorization id. A request the user approved before is used up by
+* its first read, so a second controller for the same id (React Strict Mode
+* mounts twice) has to share the answer.
+*/
+const reads = /* @__PURE__ */ new Map();
+async function readDetails(oauth, authorizationId) {
+	const result = await authResult(() => oauth.getAuthorizationDetails(authorizationId));
+	if (!result.ok) return result;
+	const data = result.data;
+	if (!("authorization_id" in data)) return ok({ redirectUrl: data.redirect_url });
+	return ok({
+		authorizationId: data.authorization_id,
+		client: clientInfo(data.client),
+		user: data.user,
+		scopes: data.scope.split(" ").filter((scope) => scope !== ""),
+		redirectUri: data.redirect_uri,
+		redirectHost: hostOf(data.redirect_uri)
+	});
+}
+const assign = (url) => {
+	globalThis.location.assign(url);
+};
+/**
+* The consent page of the Supabase Auth OAuth server: it reads the request for
+* `authorizationId`, and `approve` or `deny` send the browser to the
+* `redirect_url` that Auth returns, never to a URL from the page.
+*/
+function createOAuthConsentController(options) {
+	const { oauth, authorizationId } = options;
+	const redirect = options.redirect ?? assign;
+	return defineController({
+		request: void 0,
+		redirectUrl: void 0,
+		deciding: void 0,
+		error: void 0
+	}, (state) => {
+		const leave = (url) => {
+			state.set({
+				request: void 0,
+				redirectUrl: url
+			});
+			redirect(url);
+		};
+		const load = async (id) => {
+			let read = reads.get(id);
+			if (read === void 0) {
+				read = readDetails(oauth, id);
+				reads.set(id, read);
+			}
+			const run = state.run();
+			const result = await read;
+			if (run !== state.run()) return;
+			if (!result.ok) {
+				reads.delete(id);
+				state.set({ error: result.error });
+				return;
+			}
+			if ("redirectUrl" in result.data) {
+				leave(result.data.redirectUrl);
+				return;
+			}
+			state.set({
+				request: result.data,
+				error: void 0
+			});
+		};
+		const decide = async (decision) => {
+			const id = state.get().request?.authorizationId;
+			if (id === void 0 || state.get().deciding !== void 0) return err(dbError("invalid_input", "No authorization request to decide"));
+			state.set({
+				deciding: decision,
+				error: void 0
+			});
+			const result = await authResult(() => decision === "approve" ? oauth.approveAuthorization(id, { skipBrowserRedirect: true }) : oauth.denyAuthorization(id, { skipBrowserRedirect: true }));
+			if (!result.ok) {
+				state.set({
+					deciding: void 0,
+					error: result.error
+				});
+				return result;
+			}
+			reads.delete(id);
+			leave(result.data.redirect_url);
+			return ok(result.data.redirect_url);
+		};
+		return {
+			actions: {
+				approve: () => decide("approve"),
+				deny: () => decide("deny")
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				if (authorizationId !== void 0) load(authorizationId);
+			})
+		};
+	});
+}
+/**
+* The OAuth clients (such as MCP clients) the user approved, for a connected
+* agents list.
+*/
+function createOAuthGrantsController(options) {
+	const { oauth } = options;
+	return defineController({
+		grants: void 0,
+		revoking: [],
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			const result = await authResult(() => oauth.listGrants());
+			if (request !== ticket) return;
+			if (!result.ok) {
+				state.set({ error: result.error });
+				return;
+			}
+			state.set({
+				grants: result.data.map((grant) => ({
+					client: clientInfo(grant.client),
+					scopes: grant.scopes,
+					grantedAt: toInstant(grant.granted_at)
+				})).toSorted((a, b) => b.grantedAt.epochMilliseconds - a.grantedAt.epochMilliseconds),
+				error: void 0
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				revoke: async (clientId) => {
+					state.set((current) => ({
+						revoking: [...current.revoking, clientId],
+						error: void 0
+					}));
+					const result = await authResult(() => oauth.revokeGrant({ clientId }));
+					state.set((current) => ({
+						revoking: current.revoking.filter((each) => each !== clientId),
+						...result.ok ? {} : { error: result.error }
+					}));
+					if (!result.ok) return result;
+					await refresh();
+					return ok(true);
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
 //#region src/blocks/sessions/manifest.ts
 /** The `sessions` block's manifest (ADR 0029). */
 const sessionsBlock = defineBlock({

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

@@ -1,7 +1,105 @@
-import { Ct as Events, rt as SettingEventData } from "../../events-DbLjvxDX.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 { _ as createSettings, a as SettingsControllerOptions, c as settingFields, d as SettingInputs, f as SettingValues, g as SettingsSpec, h as SettingsOptions, i as SettingsController, l as SettingEntries, m as SettingsDefinition, n as SettingKind, o as SettingsSnapshot, p as Settings, r as SettingsActions, s as createSettingsController, t as SettingField, u as SettingEntry, v as defineSettings } from "../../client-CBcq7LBg.js";
+import { b as DbError, f as Result, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { Ct as Events, rt as SettingEventData } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { n as BlockOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller, t as AuthPort } from "../../controller-BrP0gn47.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/settings/settings.d.ts
+/**
+ * One setting: its Standard Schema and the value `get` returns when none is
+ * stored.
+ */
+interface SettingEntry<S extends StandardSchemaV1 = StandardSchemaV1> {
+  readonly schema: S;
+  readonly default?: StandardSchemaV1.InferOutput<S>;
+  /**
+   * Platform settings only: the platform permission (`is_platform`) that may
+   * change this key. Default `blocks.settings.options.platform.permission`,
+   * then `settings.manage`.
+   */
+  readonly permission?: string;
+  /**
+   * Platform settings only: who reads this key, `public` (anyone, also signed
+   * out), `authenticated` (default) or `staff` (holders of its permission).
+   */
+  readonly read?: "public" | "authenticated" | "staff";
+}
+type SettingEntries = Readonly<Record<string, SettingEntry>>;
+/**
+ * The value type of each key: the schema output, or `undefined` without a
+ * default.
+ */
+type SettingValues<E extends SettingEntries> = { readonly [K in keyof E]: E[K] extends SettingEntry<infer S> ? E[K] extends {
+  readonly default: unknown;
+} ? StandardSchemaV1.InferOutput<S> : StandardSchemaV1.InferOutput<S> | undefined : never; };
+/** What a scope's `set` accepts per key: the schema input. */
+type SettingInputs<E extends SettingEntries> = { readonly [K in keyof E]: E[K] extends SettingEntry<infer S> ? StandardSchemaV1.InferInput<S> : never; };
+interface SettingsSpec<U extends SettingEntries = SettingEntries, O extends SettingEntries = SettingEntries, P extends SettingEntries = SettingEntries> {
+  readonly user?: U;
+  readonly organization?: O;
+  /** Settings for the whole product, such as an admin console edits. */
+  readonly platform?: P;
+}
+interface SettingsOptions<U extends SettingEntries = SettingEntries, O extends SettingEntries = SettingEntries, P extends SettingEntries = SettingEntries> extends BlockOptions {
+  /**
+   * The app's settings, from `defineSettings`. Without it (a block wired with
+   * no definition) every key is unknown.
+   */
+  readonly settings?: SettingsDefinition<U, O, P>;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Settings<U, O, P>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/**
+ * Typed reads and writes of the caller's settings, an organization's settings
+ * (reads need `settings.read`, writes `settings.update`) and the product-wide
+ * settings (reads follow each key's `read`, writes need its platform
+ * permission).
+ */
+interface Settings<U extends SettingEntries = SettingEntries, O extends SettingEntries = SettingEntries, P extends SettingEntries = Record<never, never>> {
+  /** Every key of the caller's settings, stored values merged over the defaults. */
+  getUser(): AsyncResult<SettingValues<U>>;
+  getUser<K extends keyof U & string>(key: K): AsyncResult<SettingValues<U>[K]>;
+  /** Validates `value` with the key's schema, then stores the output. */
+  setUser<K extends keyof U & string>(key: K, value: SettingInputs<U>[K]): AsyncResult<SettingValues<U>[K]>;
+  /** Removes the stored value, so `getUser` returns the default again. */
+  resetUser(key: keyof U & string): AsyncResult<boolean>;
+  getOrganization(organizationId: string): AsyncResult<SettingValues<O>>;
+  getOrganization<K extends keyof O & string>(organizationId: string, key: K): AsyncResult<SettingValues<O>[K]>;
+  setOrganization<K extends keyof O & string>(organizationId: string, key: K, value: SettingInputs<O>[K]): AsyncResult<SettingValues<O>[K]>;
+  resetOrganization(organizationId: string, key: keyof O & string): AsyncResult<boolean>;
+  getPlatform(): AsyncResult<SettingValues<P>>;
+  getPlatform<K extends keyof P & string>(key: K): AsyncResult<SettingValues<P>[K]>;
+  setPlatform<K extends keyof P & string>(key: K, value: SettingInputs<P>[K]): AsyncResult<SettingValues<P>[K]>;
+  resetPlatform(key: keyof P & string): AsyncResult<boolean>;
+}
+interface SettingsDefinition<U extends SettingEntries, O extends SettingEntries, P extends SettingEntries = Record<never, never>> {
+  /**
+   * Pass as `blocks.settings.options.schemas` for the database checks, and the
+   * platform keys' permissions and read rules.
+   */
+  readonly schemas: {
+    readonly user: U;
+    readonly organization: O;
+    readonly platform: P;
+  };
+}
+/**
+ * Declares the app's settings with a Standard Schema per key. Values are
+ * validated before they are written, and stored values that no longer match
+ * their schema read as the default. Pass the result to `createSettings`.
+ */
+export declare function defineSettings<const U extends SettingEntries = Record<never, never>, const O extends SettingEntries = Record<never, never>, const P extends SettingEntries = Record<never, never>>(spec: SettingsSpec<U, O, P>): SettingsDefinition<U, O, P>;
+/**
+ * The settings block: typed `get`, `set` and `reset` over the settings module's
+ * functions.
+ */
+export declare function createSettings<U extends SettingEntries, O extends SettingEntries, P extends SettingEntries = Record<never, never>>(options: SettingsOptions<U, O, P>): Settings<U, O, P>;
+//#endregion
 //#region src/blocks/settings/events.d.ts
 /** The events of the `settings` block: type to data. */
 type SettingsEvents = {
@@ -21,4 +119,82 @@ export declare const settingsEvents: Events<SettingsEvents>;
  */
 export declare const settingsBlock: BlockOf<"settings", typeof createSettings, SettingsEvents>;
 //#endregion
-export { type BlockTransport, type SettingEntries, type SettingEntry, type SettingField, type SettingInputs, type SettingKind, type SettingValues, type Settings, type SettingsActions, type SettingsController, type SettingsControllerOptions, type SettingsDefinition, type SettingsEvents, type SettingsOptions, type SettingsSnapshot, type SettingsSpec, createSettings, createSettingsController, dbTransport, defineSettings, rpcTransport, settingFields, sqlTransport };
+//#region src/blocks/settings/client.d.ts
+/** How a settings page renders a key. */
+type SettingKind = "boolean" | "number" | "text" | "choice" | "json";
+/**
+ * One generated form field: a key of the settings definition and what its
+ * schema says about it.
+ */
+interface SettingField<K extends string = string> {
+  readonly key: K;
+  /**
+   * From the schema's Standard JSON Schema (`type` and `enum`), or from the
+   * default's type for a schema library without it.
+   */
+  readonly kind: SettingKind;
+  /** The values a `choice` allows, from the JSON Schema `enum`. */
+  readonly choices: readonly (string | number)[];
+  /** The JSON Schema `title` and `description`, such as zod's `.meta()`. */
+  readonly title: string | undefined;
+  readonly description: string | undefined;
+  readonly default: unknown;
+}
+/**
+ * The form fields of one scope of a settings definition, in declaration order:
+ * `settingFields(settings.schemas.organization)`.
+ */
+export declare function settingFields<E extends SettingEntries>(entries: E): readonly SettingField<keyof E & string>[];
+interface SettingsControllerOptions<E extends SettingEntries> {
+  /**
+   * One scope of the definition: `settings.schemas.user` or
+   * `settings.schemas.organization`.
+   */
+  readonly entries: E;
+  readonly auth: AuthPort;
+  /**
+   * The caller's own settings: a `createSettings` client. Pass this or
+   * `organization`.
+   */
+  readonly user?: Pick<Settings<E>, "getUser" | "setUser" | "resetUser">;
+  /**
+   * An organization's settings: a `createSettings` client, with
+   * `organizationId`.
+   */
+  readonly organization?: Pick<Settings<SettingEntries, E>, "getOrganization" | "setOrganization" | "resetOrganization">;
+  /** The organization for `organization`; the page waits without one. */
+  readonly organizationId?: string | null;
+}
+interface SettingsSnapshot<E extends SettingEntries> {
+  /** The form fields, from the definition; there before the first load. */
+  readonly fields: readonly SettingField<keyof E & string>[];
+  /** Stored values over the defaults; `undefined` until the first load. */
+  readonly values: SettingValues<E> | undefined;
+  /** The key being saved. */
+  readonly saving: (keyof E & string) | undefined;
+  readonly error: DbError | undefined;
+}
+interface SettingsActions<E extends SettingEntries> {
+  /**
+   * Validates and stores one value, then shows it; a failure is also kept in
+   * `error`.
+   */
+  readonly set: <K extends keyof E & string>(key: K, value: SettingInputs<E>[K]) => Promise<Result<SettingValues<E>[K]>>;
+  /**
+   * `set` for a form generated from `fields`, whose controls produce plain
+   * values: the key's schema validates `value` before it is stored.
+   */
+  readonly setField: (key: keyof E & string, value: unknown) => Promise<Result<unknown>>;
+  /** Removes the stored value, so the key reads as its default again. */
+  readonly reset: (key: keyof E & string) => Promise<Result<boolean>>;
+  readonly refresh: () => Promise<void>;
+}
+type SettingsController<E extends SettingEntries> = Controller<SettingsSnapshot<E>, SettingsActions<E>>;
+/**
+ * One scope of the app's settings for a settings page: the form fields
+ * generated from the definition, the stored values over the defaults, and `set`
+ * and `reset` per key.
+ */
+export declare function createSettingsController<E extends SettingEntries>(options: SettingsControllerOptions<E>): SettingsController<E>;
+//#endregion
+export { type BlockTransport, type SettingEntries, type SettingEntry, type SettingField, type SettingInputs, type SettingKind, type SettingValues, type Settings, type SettingsActions, type SettingsController, type SettingsControllerOptions, type SettingsDefinition, type SettingsEvents, type SettingsOptions, type SettingsSnapshot, type SettingsSpec, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/settings/index.js

@@ -1,9 +1,99 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { n as isRecord, t as isList } from "../../guards-6F2bCtQR.js";
+import { r as err, t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { n as validate } from "../../standard-BA3mLh6w.js";
 import { t as settingsSqlOptions } from "../../options-CVSWgZpY.js";
-import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CiKtrb6g.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { B as dbTransport, H as rpcTransport, U as sqlTransport, n as applyTemporal, o as blockCall } 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 { n as defineSettings, t as createSettings } from "../../settings-mL-i7QUM.js";
-import { n as settingFields, t as createSettingsController } from "../../client-ChOJ4v0D.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+//#region src/blocks/settings/settings.ts
+/**
+* Declares the app's settings with a Standard Schema per key. Values are
+* validated before they are written, and stored values that no longer match
+* their schema read as the default. Pass the result to `createSettings`.
+*/
+function defineSettings(spec) {
+	return { schemas: {
+		user: spec.user ?? {},
+		organization: spec.organization ?? {},
+		platform: spec.platform ?? {}
+	} };
+}
+/**
+* The settings block: typed `get`, `set` and `reset` over the settings module's
+* functions.
+*/
+function createSettings(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const { user, organization, platform } = (options.settings ?? defineSettings({})).schemas;
+	function getUser(key) {
+		return reader(user, call, "get_user_settings", {}, key);
+	}
+	function getOrganization(organizationId, key) {
+		return reader(organization, call, "get_organization_settings", { tenant: organizationId }, key);
+	}
+	function getPlatform(key) {
+		return reader(platform, call, "get_platform_settings", {}, key);
+	}
+	return withBlockHooks({
+		getUser,
+		setUser: (key, value) => writer(user, call, "set_user_setting", {}, key, value),
+		resetUser: (key) => remover(user, call, "reset_user_setting", {}, key),
+		getOrganization,
+		setOrganization: (organizationId, key, value) => writer(organization, call, "set_organization_setting", { tenant: organizationId }, key, value),
+		resetOrganization: (organizationId, key) => remover(organization, call, "reset_organization_setting", { tenant: organizationId }, key),
+		getPlatform,
+		setPlatform: (key, value) => writer(platform, call, "set_platform_setting", {}, key, value),
+		resetPlatform: (key) => remover(platform, call, "reset_platform_setting", {}, key)
+	}, options.hooks, {
+		block: "settings",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/** Stored values merged over the defaults; unknown keys are dropped. */
+async function merged(entries, stored) {
+	const values = isRecord(stored) ? stored : {};
+	const out = {};
+	for (const [key, entry] of Object.entries(entries)) out[key] = await readValue(entry, values[key]);
+	return out;
+}
+async function readValue(entry, stored) {
+	if (stored === void 0) return entry.default;
+	const parsed = await validate(entry.schema, stored);
+	return parsed.ok ? parsed.data : entry.default;
+}
+function unknownSetting(key) {
+	return AsyncResult.from(() => Promise.resolve(err(dbError("invalid_input", `Unknown setting "${key}"`))));
+}
+/** Reads every key, or one key, through `fn`. */
+function reader(entries, call, fn, args, key) {
+	if (key !== void 0 && !(key in entries)) return unknownSetting(key);
+	return call(fn, args, async (stored) => {
+		const values = await merged(entries, stored);
+		return key === void 0 ? values : values[key];
+	});
+}
+/** Validates `value` with the key's schema, then writes the output through `fn`. */
+function writer(entries, call, fn, args, key, value) {
+	const entry = entries[key];
+	if (!entry) return unknownSetting(key);
+	return AsyncResult.from(() => validate(entry.schema, value, `setting "${key}"`)).andThen((output) => call(fn, {
+		...args,
+		key,
+		value: { value: output ?? null }
+	}, () => output));
+}
+function remover(entries, call, fn, args, key) {
+	if (!(key in entries)) return unknownSetting(key);
+	return call(fn, {
+		...args,
+		key
+	}, (removed) => removed === true);
+}
+//#endregion
 //#region src/blocks/settings/events.ts
 /** The `settings` block's event types, for its manifest and `onBlockEvent`. */
 const settingsEvents = defineEvents({
@@ -29,4 +119,136 @@ const settingsBlock = defineBlock({
 	recipes: ["settings-layout"]
 });
 //#endregion
+//#region src/blocks/settings/client.ts
+const isConverter = (value) => isRecord(value) && typeof value["input"] === "function";
+const jsonSchemaOf = (entry) => {
+	const standard = entry.schema["~standard"];
+	const converter = isRecord(standard) ? standard["jsonSchema"] : void 0;
+	if (!isConverter(converter)) return;
+	try {
+		const converted = converter.input({ target: "draft-2020-12" });
+		return isRecord(converted) ? converted : void 0;
+	} catch {
+		return;
+	}
+};
+const kindOfValue = (value) => typeof value === "boolean" ? "boolean" : typeof value === "number" ? "number" : typeof value === "string" ? "text" : "json";
+const text = (value) => typeof value === "string" ? value : void 0;
+function fieldOf(key, entry) {
+	const schema = jsonSchemaOf(entry);
+	const values = schema?.["enum"];
+	const choices = isList(values) ? values.filter((value) => typeof value === "string" || typeof value === "number") : [];
+	const type = schema?.["type"];
+	return {
+		key,
+		kind: choices.length > 0 ? "choice" : type === "boolean" ? "boolean" : type === "number" || type === "integer" ? "number" : type === "string" ? "text" : type === void 0 ? kindOfValue(entry.default) : "json",
+		choices,
+		title: text(schema?.["title"]),
+		description: text(schema?.["description"]),
+		default: entry.default
+	};
+}
+/**
+* The form fields of one scope of a settings definition, in declaration order:
+* `settingFields(settings.schemas.organization)`.
+*/
+function settingFields(entries) {
+	const fields = [];
+	for (const key of Object.keys(entries)) {
+		const entry = entries[key];
+		if (!entry) continue;
+		fields.push(fieldOf(key, entry));
+	}
+	return fields;
+}
+function storeOf(options) {
+	const { user, organization } = options;
+	if (user) return {
+		get: () => user.getUser(),
+		set: (key, value) => user.setUser(key, value),
+		reset: (key) => user.resetUser(key)
+	};
+	if (!organization) throw new TypeError("better-supabase: createSettingsController needs `user` or `organization`");
+	const organizationId = options.organizationId ?? null;
+	if (organizationId === null) return;
+	return {
+		get: () => organization.getOrganization(organizationId),
+		set: (key, value) => organization.setOrganization(organizationId, key, value),
+		reset: (key) => organization.resetOrganization(organizationId, key)
+	};
+}
+/**
+* One scope of the app's settings for a settings page: the form fields
+* generated from the definition, the stored values over the defaults, and `set`
+* and `reset` per key.
+*/
+function createSettingsController(options) {
+	const store = storeOf(options);
+	return defineController({
+		fields: settingFields(options.entries),
+		values: void 0,
+		saving: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			if (!store) return;
+			const run = state.run();
+			const result = await store.get();
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				values: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const waiting = () => err(dbError("invalid_input", "No organization to save the setting for"));
+		const set = async (key, value) => {
+			if (!store) return waiting();
+			state.set({
+				saving: key,
+				error: void 0
+			});
+			const result = await store.set(key, value);
+			if (!result.ok) {
+				state.set({
+					saving: void 0,
+					error: result.error
+				});
+				return result;
+			}
+			state.set((current) => ({
+				saving: void 0,
+				...current.values === void 0 ? {} : { values: {
+					...current.values,
+					[key]: result.data
+				} }
+			}));
+			return result;
+		};
+		return {
+			actions: {
+				refresh,
+				set,
+				setField: (key, value) => set(key, value),
+				reset: async (key) => {
+					if (!store) return waiting();
+					state.set({
+						saving: key,
+						error: void 0
+					});
+					const result = await store.reset(key);
+					state.set(result.ok ? { saving: void 0 } : {
+						saving: void 0,
+						error: result.error
+					});
+					if (result.ok) await refresh();
+					return result;
+				}
+			},
+			start: () => store ? whileSignedIn(options.auth, () => {
+				refresh();
+			}) : void 0
+		};
+	});
+}
+//#endregion
 export { createSettings, createSettingsController, dbTransport, defineSettings, rpcTransport, settingFields, settingsBlock, settingsEvents, sqlTransport };