better-supabase 0.13.0 → 0.14.0

package/dist/client-CBcq7LBg.d.ts

@@ -0,0 +1,178 @@
+import { b as DbError, f as Result, t as AsyncResult } from "./result-C6jDfedy.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-BaugZlJV.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.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`.
+ */
+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.
+ */
+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/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)`.
+ */
+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.
+ */
+declare function createSettingsController<E extends SettingEntries>(options: SettingsControllerOptions<E>): SettingsController<E>;
+//#endregion
+export { createSettings as _, SettingsControllerOptions as a, settingFields as c, SettingInputs as d, SettingValues as f, SettingsSpec as g, SettingsOptions as h, SettingsController as i, SettingEntries as l, SettingsDefinition as m, SettingKind as n, SettingsSnapshot as o, Settings as p, SettingsActions as r, createSettingsController as s, SettingField as t, SettingEntry as u, defineSettings as v };

package/dist/client-CGJrSTMZ.js

@@ -0,0 +1,234 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { a as ok, r as err, s as toDbError } from "./result-B3m7xtRY.js";
+import { t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/attachments/client.ts
+const uploadFailed = (status) => dbError("network", status === void 0 ? "The upload did not reach Storage" : `Storage refused the upload (${String(status)})`, { hint: "ATTACHMENT_UPLOAD_FAILED" });
+/** The default `send`: a PUT to the signed URL with upload progress. */
+const xhrSend = (ticket, body, progress, signal) => new Promise((resolve) => {
+	const Request = globalThis.XMLHttpRequest;
+	if (Request === void 0) {
+		resolve(err(dbError("invalid_request", "This runtime has no XMLHttpRequest", { hint: "ATTACHMENT_UPLOAD_FAILED" })));
+		return;
+	}
+	const request = new Request();
+	request.open("PUT", ticket.signedUrl);
+	request.setRequestHeader("x-upsert", "false");
+	if (body.type !== "") request.setRequestHeader("content-type", body.type);
+	request.upload.addEventListener("progress", (event) => {
+		if (event.total > 0) progress(event.loaded / event.total);
+	});
+	request.addEventListener("load", () => {
+		resolve(request.status >= 200 && request.status < 300 ? ok(null) : err(uploadFailed(request.status)));
+	});
+	request.addEventListener("error", () => {
+		resolve(err(uploadFailed()));
+	});
+	request.addEventListener("abort", () => {
+		resolve(err(dbError("aborted", "The upload was stopped")));
+	});
+	signal.addEventListener("abort", () => {
+		request.abort();
+	});
+	request.send(body);
+});
+const ENDED = /* @__PURE__ */ new Set([
+	"done",
+	"blocked",
+	"error"
+]);
+const scanFailed = () => dbError("raised", "The malware scan failed", { hint: "ATTACHMENT_SCAN_FAILED" });
+/**
+* Uploads files to a record: each one is created (`start`), sent to its signed
+* URL with progress (`send`), confirmed (`confirm`) and, with `refresh`,
+* watched until the scan answers. Uploads run side by side; a failed one stays
+* in the list with its error until it is retried or dismissed.
+*/
+function createAttachmentUploadController(options) {
+	const send = options.send ?? xhrSend;
+	const interval = options.pollInterval ?? 2e3;
+	return defineController({
+		uploads: [],
+		busy: false
+	}, (state) => {
+		let counter = 0;
+		const inputs = /* @__PURE__ */ new Map();
+		const aborts = /* @__PURE__ */ new Map();
+		const timers = /* @__PURE__ */ new Set();
+		const patch = (key, change) => {
+			state.set((current) => {
+				const uploads = current.uploads.map((item) => item.key === key ? {
+					...item,
+					...change
+				} : item);
+				return {
+					uploads,
+					busy: uploads.some((item) => !ENDED.has(item.status))
+				};
+			});
+		};
+		const alive = (key, signal) => !signal.aborted && inputs.has(key);
+		const finish = async (key, id) => {
+			patch(key, {
+				status: "done",
+				progress: 1
+			});
+			try {
+				await options.onUploaded?.(id);
+			} catch (cause) {
+				patch(key, { error: toDbError(cause) });
+			}
+		};
+		const settle = async (key, id, scan, signal) => {
+			if (!alive(key, signal)) return;
+			if (scan?.status === "infected") {
+				patch(key, { status: "blocked" });
+				return;
+			}
+			if (scan?.status === "failed") {
+				patch(key, {
+					status: "error",
+					error: scanFailed()
+				});
+				return;
+			}
+			if (scan === null || scan.status === "clean" || options.refresh === void 0) {
+				await finish(key, id);
+				return;
+			}
+			patch(key, { status: "scanning" });
+			const { refresh } = options;
+			const timer = setTimeout(() => {
+				timers.delete(timer);
+				Promise.resolve(refresh(id)).then(async (next) => {
+					if (!next.ok) {
+						if (alive(key, signal)) patch(key, {
+							status: "error",
+							error: next.error
+						});
+						return;
+					}
+					await settle(key, id, next.data, signal);
+				});
+			}, interval);
+			timers.add(timer);
+		};
+		const run = async (key) => {
+			const input = inputs.get(key);
+			if (input === void 0) return;
+			const abort = new AbortController();
+			aborts.get(key)?.abort();
+			aborts.set(key, abort);
+			const { signal } = abort;
+			patch(key, {
+				status: "uploading",
+				progress: 0,
+				error: void 0,
+				id: void 0
+			});
+			const fail = (error) => {
+				if (alive(key, signal)) patch(key, {
+					status: "error",
+					error
+				});
+			};
+			const started = await options.start({
+				name: input.name,
+				mimeType: mimeOf(input),
+				size: input.file.size,
+				...input.width === void 0 ? {} : { width: input.width },
+				...input.height === void 0 ? {} : { height: input.height },
+				...input.pages === void 0 ? {} : { pages: input.pages }
+			});
+			if (!started.ok) {
+				fail(started.error);
+				return;
+			}
+			const ticket = started.data;
+			if (!alive(key, signal)) return;
+			patch(key, { id: ticket.id });
+			const sent = await send(ticket, input.file, (fraction) => {
+				if (alive(key, signal)) patch(key, { progress: Math.min(1, Math.max(0, fraction)) });
+			}, signal);
+			if (!sent.ok) {
+				fail(sent.error);
+				return;
+			}
+			if (!alive(key, signal)) return;
+			patch(key, {
+				status: "confirming",
+				progress: 1
+			});
+			const confirmed = await options.confirm(ticket.id);
+			if (!confirmed.ok) {
+				fail(confirmed.error);
+				return;
+			}
+			await settle(key, ticket.id, confirmed.data, signal);
+		};
+		const add = (files) => {
+			const added = files.map((input) => {
+				counter += 1;
+				const key = `upload-${String(counter)}`;
+				inputs.set(key, input);
+				return {
+					key,
+					name: input.name,
+					mimeType: mimeOf(input),
+					size: input.file.size,
+					status: "uploading",
+					progress: 0,
+					id: void 0,
+					error: void 0
+				};
+			});
+			if (added.length === 0) return;
+			state.set((current) => ({
+				uploads: [...current.uploads, ...added],
+				busy: true
+			}));
+			for (const item of added) run(item.key);
+		};
+		const drop = (keep) => {
+			state.set((current) => {
+				const uploads = current.uploads.filter((item) => {
+					if (keep(item)) return true;
+					inputs.delete(item.key);
+					aborts.get(item.key)?.abort();
+					aborts.delete(item.key);
+					return false;
+				});
+				return {
+					uploads,
+					busy: uploads.some((item) => !ENDED.has(item.status))
+				};
+			});
+		};
+		return {
+			actions: {
+				add,
+				retry: (key) => {
+					if (state.get().uploads.find((each) => each.key === key)?.status === "error") run(key);
+				},
+				dismiss: (key) => {
+					drop((item) => item.key !== key);
+				},
+				clear: () => {
+					drop((item) => !ENDED.has(item.status));
+				}
+			},
+			start: () => {
+				for (const item of state.get().uploads) {
+					const signal = aborts.get(item.key)?.signal;
+					if (item.status === "scanning" && item.id !== void 0 && signal) settle(item.key, item.id, { status: "pending" }, signal);
+				}
+				return () => {
+					for (const timer of timers) clearTimeout(timer);
+					timers.clear();
+				};
+			}
+		};
+	});
+}
+const mimeOf = (input) => input.mimeType ?? (input.file.type || "application/octet-stream");
+//#endregion
+export { xhrSend as n, createAttachmentUploadController as t };

package/dist/client-CLIBcMzL.d.ts

@@ -0,0 +1,116 @@
+import { b as DbError, f as Result, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-BaugZlJV.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+import { t as RankNeighbors } from "./rank-result-DwR0FawB.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` and `forSubject` return. */
+  readonly kind?: string;
+  readonly color?: string;
+  readonly description?: string;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+/**
+ * `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 of `kind` in the tenant; `fields` sets its extra columns. */
+  create(kind: string, name: string, color?: string, description?: string, fields?: Partial<F>): AsyncResult<Tag<F>>;
+  /**
+   * Renames a tag (`name` null keeps it) and sets the extra columns `fields`
+   * names.
+   */
+  update(id: string, name: string | null, fields?: Partial<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 `subject`. */
+  tag(subject: SubjectRef, tagId: string): AsyncResult<boolean>;
+  /** Takes a tag off `subject`. */
+  untag(subject: SubjectRef, tagId: string): AsyncResult<boolean>;
+  /** The tenant's tags of `kind` (every kind without it), in rank order. */
+  list(kind?: string): AsyncResult<readonly Tag<F>[]>;
+  /** The tags on `subject`, in rank order; the caller must be able to read it. */
+  forSubject(subject: SubjectRef): AsyncResult<readonly Tag<F>[]>;
+}
+/** The `tags` SQL module as typed calls. */
+declare function createTags<S extends StandardSchemaV1 | undefined = undefined>(options: TagsOptions<S>): Tags<FieldsOf<S>>;
+//#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, "list" | "forSubject" | "tag" | "untag" | "create">;
+  readonly auth: AuthPort;
+  /** The subject whose tags to show; the input waits without one. */
+  readonly subject: SubjectRef | 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.
+ */
+declare function createTagInputController(options: TagInputControllerOptions): TagInputController;
+//#endregion
+export { TagInputSnapshot as a, Tags as c, TagInputControllerOptions as i, TagsOptions as l, TagInputActions as n, createTagInputController as o, TagInputController as r, Tag as s, TagChange as t, createTags as u };

package/dist/client-COuIfjbB.d.ts

@@ -0,0 +1,46 @@
+import { n as Controller } from "./controller-DAD4hbl4.js";
+import { a as UndoToken } from "./undo-B696duxr.js";
+//#region src/blocks/undo/client.d.ts
+interface UndoEntry {
+  readonly id: number;
+  /** What the toast or menu shows, e.g. "Moved 3 tasks". */
+  readonly label: string;
+  readonly token: UndoToken;
+}
+interface UndoStackOptions {
+  /**
+   * Applies a token, e.g. a server action that calls
+   * `createUndo().apply(token)`.
+   */
+  readonly apply: (token: UndoToken) => Promise<unknown>;
+  /** How many entries to keep; older ones drop off. Default 20. */
+  readonly limit?: number | undefined;
+}
+interface UndoSnapshot {
+  /** Newest last. */
+  readonly entries: readonly UndoEntry[];
+  readonly canUndo: boolean;
+  /** Whether an undo is running. */
+  readonly pending: boolean;
+  /** What the last failed undo threw; cleared by the next push or undo. */
+  readonly error: unknown;
+}
+interface UndoActions {
+  /** Adds a token; a `null` token (a change with no inverse) is ignored. */
+  readonly push: (token: UndoToken | null | undefined, label?: string) => void;
+  /**
+   * Applies the newest entry and removes it. A failed undo removes it too,
+   * since its rows changed since, and sets `error`. Resolves whether it
+   * worked.
+   */
+  readonly undo: () => Promise<boolean>;
+  readonly clear: () => void;
+}
+type UndoController = Controller<UndoSnapshot, UndoActions>;
+/**
+ * A stack of undo tokens on the client, for a toast's Undo button or a Cmd+Z
+ * handler.
+ */
+declare function createUndoController(options: UndoStackOptions): UndoController;
+//#endregion
+export { UndoStackOptions as a, UndoSnapshot as i, UndoController as n, createUndoController as o, UndoEntry as r, UndoActions as t };

package/dist/client-CVToJ4uI.js

@@ -0,0 +1,84 @@
+import { a as ok, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { r as subjectKey } from "./block-subjects-Dzq5Xn_0.js";
+//#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 { createSubjectsController as n, batchSubjects as t };