better-supabase 0.8.0 → 0.10.0

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

@@ -0,0 +1,14 @@
+import { t as useBlockController } from "../../../svelte-controller-CDAujo-_.js";
+import { t as createReactionsController } from "../../../client-CFeWXNXy.js";
+//#region src/blocks/reactions/svelte/index.ts
+/**
+* `createReactionsController` 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 useReactions(options) {
+	return useBlockController(createReactionsController, options);
+}
+//#endregion
+export { useReactions };

package/dist/blocks/reactions/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 { i as ReactionsSnapshot, r as ReactionsControllerOptions, t as ReactionsActions } from "../../../client-D9zBl9PT.js";
+//#region src/blocks/reactions/vue/index.d.ts
+/**
+ * `createReactionsController` 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 useReactions(options: BlockOptions<ReactionsControllerOptions>): VueController<ReactionsSnapshot, ReactionsActions>;
+//#endregion
+export type { BlockOptions, ReactionsActions, ReactionsControllerOptions, ReactionsSnapshot, VueController };

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

@@ -0,0 +1,14 @@
+import { t as useBlockController } from "../../../vue-controller-C9tFzqAc.js";
+import { t as createReactionsController } from "../../../client-CFeWXNXy.js";
+//#region src/blocks/reactions/vue/index.ts
+/**
+* `createReactionsController` 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 useReactions(options) {
+	return useBlockController(createReactionsController, options);
+}
+//#endregion
+export { useReactions };

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

@@ -0,0 +1,180 @@
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { et as SaasSubjectEventData, 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 { t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { i as RowFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+import { a as UndoToken } from "../../undo-D42sPjCf.js";
+//#region src/blocks/relations/relations.d.ts
+/** A record a link points at: its subject type and id. */
+interface SubjectRef {
+  readonly type: string;
+  readonly id: string;
+}
+interface LinkInput<F extends object = Record<never, never>> {
+  readonly organizationId: string;
+  /** A kind, or its inverse name (`blocked_by` stores `blocks` from the other end). */
+  readonly kind: string;
+  readonly source: SubjectRef;
+  readonly target: SubjectRef;
+  /** Data on the link, such as a Gantt dependency's `type` and `lag`. */
+  readonly data?: Readonly<Record<string, unknown>>;
+  /** Values for the app's extra columns (`options.extraColumns`); left out keeps the stored ones. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+type UnlinkInput = Omit<LinkInput, "data" | "fields">;
+interface LinkResult<F extends object = Record<never, never>> {
+  readonly id: string;
+  /** The stored kind; an inverse name resolves to its kind. */
+  readonly kind: string;
+  /** The stored source, after an inverse name or a symmetric kind swapped the ends. */
+  readonly source: SubjectRef;
+  readonly target: SubjectRef;
+  /** `false` when the link existed; its data was updated if `data` was given. */
+  readonly created: boolean;
+  /** The target a one-target kind replaced. */
+  readonly replaced: {
+    readonly target: SubjectRef;
+    readonly data: Readonly<Record<string, unknown>>;
+  } | null;
+  readonly undo: UndoToken | null;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+interface UnlinkResult {
+  readonly removed: boolean;
+  readonly undo: UndoToken | null;
+}
+interface Relation<F extends object = Record<never, never>> {
+  readonly id: string;
+  /** The kind as read from the subject's side: `blocked_by` for an incoming `blocks`. */
+  readonly kind: string;
+  readonly direction: "out" | "in";
+  readonly subject: SubjectRef;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly createdAt: string;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+interface RelationEdge<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly kind: string;
+  readonly source: SubjectRef;
+  readonly target: SubjectRef;
+  readonly data: Readonly<Record<string, unknown>>;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+interface RelationNode extends SubjectRef {
+  readonly depth: number;
+}
+type RelationRollup = "count" | "sum" | "avg" | "min" | "max";
+interface RollupInput {
+  readonly organizationId: string;
+  readonly kind: string;
+  readonly subject: SubjectRef;
+  /** The descendants' subject type whose table holds `column`. */
+  readonly of: string;
+  readonly agg: RelationRollup;
+  /** Required for every aggregate except `count`. */
+  readonly column?: string;
+}
+interface RelationsOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * A Standard Schema for the extra columns of the relations table
+   * (`blocks.relations.options.extraColumns`): writes are validated, reads
+   * parsed.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Relations<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+interface Relations<F extends object = Record<never, never>> {
+  link(input: LinkInput<F>): AsyncResult<LinkResult<F>>;
+  unlink(input: UnlinkInput): AsyncResult<UnlinkResult>;
+  /** A subject's links in both directions, optionally of one kind. */
+  of(organizationId: string, subject: SubjectRef, kind?: string): AsyncResult<Relation<F>[]>;
+  /** Every link of a kind in the organization (up to 10,000), for a chart or a tree. */
+  edges(organizationId: string, kind: string): AsyncResult<RelationEdge<F>[]>;
+  ancestors(organizationId: string, kind: string, subject: SubjectRef): AsyncResult<RelationNode[]>;
+  descendants(organizationId: string, kind: string, subject: SubjectRef): AsyncResult<RelationNode[]>;
+  /** Aggregates a column over a subject's descendants, such as estimates under an epic. */
+  rollup(input: RollupInput): AsyncResult<number | string | null>;
+  /**
+   * The id of the record of `intoType` that `origin` was already converted
+   * into through a `created_from` link, or `undefined`. Check it before a
+   * conversion so converting twice returns the first record.
+   */
+  convertedInto(organizationId: string, origin: SubjectRef, intoType: string): AsyncResult<string | undefined>;
+  /**
+   * The records a subject was converted from (`origins`, nearest first) and
+   * into (`conversions`) through `created_from` links: a deal, its quote,
+   * the order and the invoice.
+   */
+  lineage(organizationId: string, subject: SubjectRef): AsyncResult<{
+    readonly origins: RelationNode[];
+    readonly conversions: RelationNode[];
+  }>;
+}
+export declare function createRelations<S extends StandardSchemaV1 | undefined = undefined>(options: RelationsOptions<S>): Relations<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/relations/adapters.d.ts
+/** How a Gantt dependency links two bars: finish-to-start and the rest. */
+type GanttDependencyType = "FS" | "SS" | "FF" | "SF";
+interface GanttDependency {
+  /** The task this one depends on. */
+  readonly id: string;
+  readonly type: GanttDependencyType;
+  /** Days between the two ends; negative for a lead. */
+  readonly lag: number;
+}
+/**
+ * Adds each task's dependencies from `blocks` edges: when A blocks B, B
+ * depends on A. The edge's `data.type` and `data.lag` set the dependency
+ * type (default `FS`) and lag (default 0). Edges to tasks outside the list
+ * are left out.
+ */
+export declare function toGanttTasks<T extends {
+  readonly id: string;
+}>(tasks: readonly T[], edges: readonly RelationEdge[]): (T & {
+  readonly dependencies: readonly GanttDependency[];
+})[];
+interface TreeItem {
+  readonly name: string;
+  readonly children: readonly string[];
+}
+/**
+ * Builds the flat item map a tree view takes (`{ [id]: { name, children } }`,
+ * as in Headless Tree) from `parent` edges, where the source is the child.
+ * Items without a parent in the list hang under `rootId`. Children keep the
+ * order of `items`.
+ */
+export declare function toTreeItems(items: readonly {
+  readonly id: string;
+  readonly name: string;
+}[], edges: readonly RelationEdge[], options?: {
+  readonly rootId?: string;
+  readonly rootName?: string;
+}): Record<string, TreeItem>;
+//#endregion
+//#region src/blocks/relations/events.d.ts
+/** The events of the `relations` block: type to data. */
+type RelationsEvents = {
+  readonly "subject.linked": SaasSubjectEventData;
+  readonly "subject.unlinked": SaasSubjectEventData;
+};
+/** The `relations` block's event types, for its manifest and `onBlockEvent`. */
+export declare const relationsEvents: Events<RelationsEvents>;
+//#endregion
+//#region src/blocks/relations/manifest.d.ts
+/** The `relations` block's manifest (ADR 0029). */
+export declare const relationsBlock: BlockOf<"relations", typeof createRelations, RelationsEvents>;
+//#endregion
+export type { GanttDependency, GanttDependencyType, LinkInput, LinkResult, Relation, RelationEdge, RelationNode, RelationRollup, Relations, RelationsEvents, RelationsOptions, RollupInput, SubjectRef, TreeItem, UnlinkInput, UnlinkResult };

package/dist/blocks/relations/index.js

@@ -0,0 +1,254 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as relationsSqlOptions } from "../../options-wFnK3qWl.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-BfVCR5Fc.js";
+import { r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { a as readAllFields, l as writeFields, n as blockFields, o as readFields, s as rowFields } from "../../block-fields-BANwJ9Y_.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { i as undoToken } from "../../undo-0qM13zul.js";
+//#region src/blocks/relations/adapters.ts
+const DEPENDENCY_TYPES = [
+	"FS",
+	"SS",
+	"FF",
+	"SF"
+];
+function dependencyType(value) {
+	return DEPENDENCY_TYPES.find((type) => type === value) ?? "FS";
+}
+/**
+* Adds each task's dependencies from `blocks` edges: when A blocks B, B
+* depends on A. The edge's `data.type` and `data.lag` set the dependency
+* type (default `FS`) and lag (default 0). Edges to tasks outside the list
+* are left out.
+*/
+function toGanttTasks(tasks, edges) {
+	const ids = new Set(tasks.map((task) => task.id));
+	const byTask = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (!ids.has(edge.source.id) || !ids.has(edge.target.id)) continue;
+		const type = edge.data["type"];
+		const lag = edge.data["lag"];
+		const list = byTask.get(edge.target.id) ?? [];
+		list.push({
+			id: edge.source.id,
+			type: dependencyType(type),
+			lag: typeof lag === "number" && Number.isFinite(lag) ? lag : 0
+		});
+		byTask.set(edge.target.id, list);
+	}
+	return tasks.map((task) => ({
+		...task,
+		dependencies: byTask.get(task.id) ?? []
+	}));
+}
+/**
+* Builds the flat item map a tree view takes (`{ [id]: { name, children } }`,
+* as in Headless Tree) from `parent` edges, where the source is the child.
+* Items without a parent in the list hang under `rootId`. Children keep the
+* order of `items`.
+*/
+function toTreeItems(items, edges, options = {}) {
+	const rootId = options.rootId ?? "root";
+	const ids = new Set(items.map((item) => item.id));
+	const parentOf = /* @__PURE__ */ new Map();
+	for (const edge of edges) if (ids.has(edge.source.id) && ids.has(edge.target.id)) parentOf.set(edge.source.id, edge.target.id);
+	const children = /* @__PURE__ */ new Map([[rootId, []]]);
+	for (const item of items) {
+		const parent = parentOf.get(item.id) ?? rootId;
+		const list = children.get(parent) ?? [];
+		list.push(item.id);
+		children.set(parent, list);
+	}
+	const tree = { [rootId]: {
+		name: options.rootName ?? "",
+		children: children.get(rootId) ?? []
+	} };
+	for (const item of items) tree[item.id] = {
+		name: item.name,
+		children: children.get(item.id) ?? []
+	};
+	return tree;
+}
+//#endregion
+//#region src/blocks/relations/relations.ts
+const objectOf = (value) => isRecord(value) ? value : {};
+const ref = (type, id) => ({
+	type: textOf(type),
+	id: textOf(id)
+});
+const linkArgs = (organizationId, kind, source, target) => ({
+	tenant: organizationId,
+	kind,
+	source_type: source.type,
+	source_id: source.id,
+	target_type: target.type,
+	target_id: target.id
+});
+function edgeOf(value) {
+	const row = recordOf(value, "relation");
+	return {
+		id: textOf(row["id"]),
+		kind: textOf(row["kind"]),
+		source: ref(row["sourceType"], row["sourceId"]),
+		target: ref(row["targetType"], row["targetId"]),
+		data: objectOf(row["data"]),
+		fields: rowFields(row["fields"])
+	};
+}
+function nodeOf(value) {
+	const row = recordOf(value, "relation node");
+	return {
+		type: textOf(row["type"]),
+		id: textOf(row["id"]),
+		depth: typeof row["depth"] === "number" ? row["depth"] : 0
+	};
+}
+function createRelations(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "relation fields");
+	return withBlockHooks({
+		link: (input) => writeFields(fields, input.fields, (checked) => call("link", {
+			...linkArgs(input.organizationId, input.kind, input.source, input.target),
+			data: input.data ?? null,
+			fields: checked
+		}, (value) => {
+			const row = recordOf(value, "link");
+			const kind = textOf(row["kind"]);
+			const source = ref(row["sourceType"], row["sourceId"]);
+			const target = ref(row["targetType"], row["targetId"]);
+			const created = row["created"] === true;
+			const replacedRow = row["replaced"];
+			const replaced = isRecord(replacedRow) ? {
+				target: ref(replacedRow["targetType"], replacedRow["targetId"]),
+				data: objectOf(replacedRow["data"])
+			} : null;
+			const calls = [];
+			const args = linkArgs(input.organizationId, kind, source, target);
+			if (created) calls.push({
+				fn: "unlink",
+				args
+			});
+			if (replaced) calls.push({
+				fn: "link",
+				args: {
+					...linkArgs(input.organizationId, kind, source, replaced.target),
+					data: replaced.data
+				}
+			});
+			const previous = row["previousData"];
+			if (!created && input.data !== void 0 && isRecord(previous)) calls.push({
+				fn: "link",
+				args: {
+					...args,
+					data: previous
+				}
+			});
+			return {
+				id: textOf(row["id"]),
+				kind,
+				source,
+				target,
+				created,
+				replaced,
+				undo: calls.length > 0 ? undoToken(calls) : null,
+				fields: rowFields(row["fields"])
+			};
+		}).andThen((result) => readFields(fields, result))),
+		unlink: (input) => call("unlink", linkArgs(input.organizationId, input.kind, input.source, input.target), (value) => {
+			const row = recordOf(value, "unlink");
+			const removed = row["removed"] === true;
+			return {
+				removed,
+				undo: removed ? undoToken([{
+					fn: "link",
+					args: {
+						...linkArgs(input.organizationId, input.kind, input.source, input.target),
+						data: objectOf(row["data"])
+					}
+				}]) : null
+			};
+		}),
+		of: (organizationId, subject, kind) => call("relations_of", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			kind: kind ?? null
+		}, (value) => recordsOf(value, "relations_of").map((row) => ({
+			id: textOf(row["id"]),
+			kind: textOf(row["kind"]),
+			direction: row["direction"] === "in" ? "in" : "out",
+			subject: ref(row["type"], row["subjectId"]),
+			data: objectOf(row["data"]),
+			createdAt: optionalText(row["createdAt"]) ?? "",
+			fields: rowFields(row["fields"])
+		}))).andThen((relations) => readAllFields(fields, relations)),
+		edges: (organizationId, kind) => call("relations_by_kind", {
+			tenant: organizationId,
+			kind
+		}, (value) => recordsOf(value, "relations_by_kind").map(edgeOf)).andThen((edges) => readAllFields(fields, edges)),
+		ancestors: (organizationId, kind, subject) => call("ancestors", {
+			tenant: organizationId,
+			kind,
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => recordsOf(value, "ancestors").map(nodeOf)),
+		descendants: (organizationId, kind, subject) => call("descendants", {
+			tenant: organizationId,
+			kind,
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => recordsOf(value, "descendants").map(nodeOf)),
+		convertedInto: (organizationId, origin, intoType) => call("converted_into", {
+			tenant: organizationId,
+			origin_type: origin.type,
+			origin_id: origin.id,
+			into_type: intoType
+		}, (value) => typeof value === "string" ? value : void 0),
+		lineage: (organizationId, subject) => {
+			const args = {
+				tenant: organizationId,
+				kind: "created_from",
+				subject_type: subject.type,
+				subject_id: subject.id
+			};
+			return call("ancestors", args, (value) => recordsOf(value, "ancestors").map(nodeOf)).andThen((origins) => call("descendants", args, (value) => ({
+				origins,
+				conversions: recordsOf(value, "descendants").map(nodeOf)
+			})));
+		},
+		rollup: (input) => call("relation_rollup", {
+			tenant: input.organizationId,
+			kind: input.kind,
+			subject_type: input.subject.type,
+			subject_id: input.subject.id,
+			of_type: input.of,
+			column_name: input.column ?? null,
+			agg: input.agg
+		}, (value) => typeof value === "number" || typeof value === "string" ? value : null)
+	}, options.hooks, {
+		block: "relations",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/relations/events.ts
+/** The `relations` block's event types, for its manifest and `onBlockEvent`. */
+const relationsEvents = defineEvents({
+	"subject.linked": event(),
+	"subject.unlinked": event()
+});
+//#endregion
+//#region src/blocks/relations/manifest.ts
+/** The `relations` block's manifest (ADR 0029). */
+const relationsBlock = defineBlock({
+	name: "relations",
+	sql: ["relations"],
+	options: { relations: relationsSqlOptions },
+	events: relationsEvents,
+	create: createRelations,
+	category: "work",
+	recipes: ["related-items-panel"]
+});
+//#endregion
+export { createRelations, relationsBlock, relationsEvents, toGanttTasks, toTreeItems };

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

@@ -0,0 +1,177 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { et as SaasSubjectEventData, 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 { t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { i as RowFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { g as JobHandler } from "../../types-P1S1cj6N.js";
+import { g as SubscriberPolicy, i as AuthorizationHooks } from "../../authorization-hooks-Do5djkpz.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+import { n as Notifier } from "../../ports-B53rB7zg.js";
+//#region src/blocks/reminders/rrule.d.ts
+interface ExpandInput {
+  readonly dtstart: Temporal.ZonedDateTime;
+  /** An `RRULE` value, with or without the `RRULE:` prefix. */
+  readonly rrule?: string;
+  /** CentraKit's column shape, used when `ruleFormat` is `columns`. */
+  readonly columns?: {
+    readonly frequency: "daily" | "weekly" | "monthly" | "yearly";
+    readonly interval?: number;
+    readonly weekDays?: readonly number[];
+    readonly monthDay?: number;
+    readonly monthWeekday?: number;
+    readonly monthOrdinal?: number;
+    readonly count?: number;
+    readonly until?: Temporal.Instant;
+  };
+  /** Stops after this many occurrences. COUNT still wins when it is smaller. */
+  readonly limit?: number;
+  /**
+   * Returns only the occurrences that start in `[from, until)`. COUNT still
+   * counts from `dtstart`; without COUNT the expansion skips ahead to the
+   * window, so a long-running series stays cheap. `limit` then caps the
+   * occurrences in the window (default 1000).
+   */
+  readonly window?: {
+    readonly from: Temporal.Instant;
+    readonly until: Temporal.Instant;
+  };
+}
+/** The occurrences of a rule, in order, starting at `dtstart` when it matches. */
+export declare function expandRule(input: ExpandInput): Temporal.ZonedDateTime[];
+/** A weekday name for a column-format rule, 1 (Monday) through 7 (Sunday). */
+export declare function weekdayName(day: number): string;
+//#endregion
+//#region src/blocks/reminders/schedule.d.ts
+interface ReminderPlanInput {
+  readonly id: string;
+  readonly dtstart: Temporal.ZonedDateTime;
+  readonly rrule?: string;
+  readonly columns?: ExpandInput["columns"];
+  readonly offsetMinutes: number;
+}
+interface PlannedDelivery {
+  readonly reminderId: string;
+  readonly occurrenceAt: string;
+  readonly runAt: Temporal.Instant;
+  /** One job per reminder and occurrence. Pass this to `enqueueOnce`. */
+  readonly dedupeKey: string;
+}
+interface DeliveryPayload {
+  readonly reminderId: string;
+  readonly occurrenceAt: string;
+  readonly organizationId: string;
+  /** Who set the reminder; `createBlocks` notifies them. */
+  readonly userId?: string;
+  /** The reminded subject, from `list_reminder_schedule`; its watchers are notified too. */
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+}
+/**
+ * Expands each rule between `from` and `until` and returns one delivery per
+ * occurrence, shifted earlier by `offsetMinutes`. The caller enqueues each
+ * row as a delayed `reminders.deliver` job with `dedupeKey`.
+ */
+export declare function planReminderDeliveries(items: readonly ReminderPlanInput[], window: {
+  readonly from: Temporal.ZonedDateTime;
+  readonly until: Temporal.ZonedDateTime;
+}): readonly PlannedDelivery[];
+/** Records the delivery, then notifies. A second run of the same occurrence is a no-op in SQL. */
+export declare function deliverReminder(payload: DeliveryPayload, effects: {
+  readonly markSent: (reminderId: string, occurrenceAt: string) => Promise<void>;
+  readonly notify: (payload: DeliveryPayload) => Promise<void>;
+}): Promise<void>;
+//#endregion
+//#region src/blocks/reminders/reminders.d.ts
+/** The queue `reminders.job` handles. */
+export declare const REMINDER_DELIVERY_QUEUE = "reminders.deliver";
+interface RemindersOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * Runs after `deliver` records an occurrence for the first time. Defaults
+   * to sending `notification` through `notifier`.
+   */
+  readonly notifyDelivery?: (delivery: DeliveryPayload) => unknown;
+  /** The `notifier` port: the `notifications` block, from `createBlocks`. */
+  readonly notifier?: Notifier;
+  /**
+   * The notification type `notifier` sends for a delivered reminder, to the
+   * user who set it and the reminded subject's watchers. Its data is
+   * `{ reminderId, occurrenceAt }`.
+   */
+  readonly notification?: string;
+  /**
+   * Checks the reminder's user before `notifyDelivery` runs; a user it
+   * leaves out gets nothing, and a throw fails the delivery so the job
+   * retries. Defaults to `authorization.delivery.audience`; with
+   * `authorization` but no such policy, to `subjectReaders(transport)`, so
+   * a user who lost access to the subject stops getting its reminders.
+   */
+  readonly audience?: SubscriberPolicy;
+  /** `server.authorization`, for its `delivery.audience` policy. */
+  readonly authorization?: Pick<AuthorizationHooks, "delivery">;
+  /**
+   * A Standard Schema for the extra columns of the reminders table
+   * (`blocks.reminders.options.extraColumns`): writes are validated, reads
+   * parsed.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Reminders<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A saved reminder: its id and the app's extra columns. */
+interface SavedReminder<F extends object = Record<never, never>> {
+  readonly id: string;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+/** One of the caller's reminders, from `list`. */
+interface ReminderEntry {
+  readonly id: string;
+  readonly method: string;
+  /** Minutes before the occurrence; negative fires after it. */
+  readonly offsetMinutes: number;
+}
+interface Reminders<F extends object = Record<never, never>> {
+  /** Sets a reminder on a subject; `fields` fills the app's extra columns. */
+  save(organizationId: string, subjectType: string, subjectId: string, offsetMinutes?: number, fields?: Partial<F> & Readonly<Record<string, unknown>>): AsyncResult<SavedReminder<F>>;
+  /** The caller's reminders on a subject, the earliest before the occurrence first. */
+  list(organizationId: string, subjectType: string, subjectId: string): AsyncResult<readonly ReminderEntry[]>;
+  /** Removes one of the caller's reminders; `false` when there was none. */
+  remove(reminderId: string): AsyncResult<boolean>;
+  /**
+   * Service role. Records one delivery and the reminder.sent event.
+   * Resolves to `false` when the occurrence was already delivered.
+   */
+  markSent(reminderId: string, occurrenceAt: string): AsyncResult<boolean>;
+  /**
+   * Checks `audience`, then `markSent`, then `notifyDelivery` when this run
+   * recorded the occurrence and the audience kept the user.
+   */
+  deliver(delivery: DeliveryPayload): AsyncResult<boolean>;
+  /** The handler for the `reminders.deliver` queue. */
+  readonly job: JobHandler<unknown>;
+}
+export declare function createReminders<S extends StandardSchemaV1 | undefined = undefined>(options: RemindersOptions<S>): Reminders<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/reminders/events.d.ts
+/** The events of the `reminders` block: type to data. */
+type RemindersEvents = {
+  readonly "reminder.sent": SaasSubjectEventData;
+};
+/** The `reminders` block's event types, for its manifest and `onBlockEvent`. */
+export declare const remindersEvents: Events<RemindersEvents>;
+//#endregion
+//#region src/blocks/reminders/manifest.d.ts
+/** The `reminders` block's manifest (ADR 0029). */
+export declare const remindersBlock: BlockOf<"reminders", typeof createReminders, RemindersEvents, {
+  readonly notifier: "optional";
+}>;
+//#endregion
+export type { DeliveryPayload, ExpandInput, PlannedDelivery, ReminderEntry, ReminderPlanInput, Reminders, RemindersEvents, RemindersOptions, SavedReminder };